Pileus Git - ~andy/linux/blob - fs/cifs/connect.c

   1 /*
   2  *   fs/cifs/connect.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2011
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/net.h>
  23 #include <linux/string.h>
  24 #include <linux/list.h>
  25 #include <linux/wait.h>
  26 #include <linux/slab.h>
  27 #include <linux/pagemap.h>
  28 #include <linux/ctype.h>
  29 #include <linux/utsname.h>
  30 #include <linux/mempool.h>
  31 #include <linux/delay.h>
  32 #include <linux/completion.h>
  33 #include <linux/kthread.h>
  34 #include <linux/pagevec.h>
  35 #include <linux/freezer.h>
  36 #include <linux/namei.h>
  37 #include <asm/uaccess.h>
  38 #include <asm/processor.h>
  39 #include <linux/inet.h>
  40 #include <linux/module.h>
  41 #include <keys/user-type.h>
  42 #include <net/ipv6.h>
  43 #include <linux/parser.h>
  44
  45 #include "cifspdu.h"
  46 #include "cifsglob.h"
  47 #include "cifsproto.h"
  48 #include "cifs_unicode.h"
  49 #include "cifs_debug.h"
  50 #include "cifs_fs_sb.h"
  51 #include "ntlmssp.h"
  52 #include "nterr.h"
  53 #include "rfc1002pdu.h"
  54 #include "fscache.h"
  55
  56 #define CIFS_PORT 445
  57 #define RFC1001_PORT 139
  58
  59 extern mempool_t *cifs_req_poolp;
  60
  61 /* FIXME: should these be tunable? */
  62 #define TLINK_ERROR_EXPIRE      (1 * HZ)
  63 #define TLINK_IDLE_EXPIRE       (600 * HZ)
  64
  65 enum {
  66
  67         /* Mount options that take no arguments */
  68         Opt_user_xattr, Opt_nouser_xattr,
  69         Opt_forceuid, Opt_noforceuid,
  70         Opt_forcegid, Opt_noforcegid,
  71         Opt_noblocksend, Opt_noautotune,
  72         Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
  73         Opt_mapchars, Opt_nomapchars, Opt_sfu,
  74         Opt_nosfu, Opt_nodfs, Opt_posixpaths,
  75         Opt_noposixpaths, Opt_nounix,
  76         Opt_nocase,
  77         Opt_brl, Opt_nobrl,
  78         Opt_forcemandatorylock, Opt_setuids,
  79         Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
  80         Opt_nohard, Opt_nosoft,
  81         Opt_nointr, Opt_intr,
  82         Opt_nostrictsync, Opt_strictsync,
  83         Opt_serverino, Opt_noserverino,
  84         Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
  85         Opt_acl, Opt_noacl, Opt_locallease,
  86         Opt_sign, Opt_seal, Opt_noac,
  87         Opt_fsc, Opt_mfsymlinks,
  88         Opt_multiuser, Opt_sloppy,
  89
  90         /* Mount options which take numeric value */
  91         Opt_backupuid, Opt_backupgid, Opt_uid,
  92         Opt_cruid, Opt_gid, Opt_file_mode,
  93         Opt_dirmode, Opt_port,
  94         Opt_rsize, Opt_wsize, Opt_actimeo,
  95
  96         /* Mount options which take string value */
  97         Opt_user, Opt_pass, Opt_ip,
  98         Opt_unc, Opt_domain,
  99         Opt_srcaddr, Opt_prefixpath,
 100         Opt_iocharset, Opt_sockopt,
 101         Opt_netbiosname, Opt_servern,
 102         Opt_ver, Opt_vers, Opt_sec, Opt_cache,
 103
 104         /* Mount options to be ignored */
 105         Opt_ignore,
 106
 107         /* Options which could be blank */
 108         Opt_blank_pass,
 109         Opt_blank_user,
 110         Opt_blank_ip,
 111
 112         Opt_err
 113 };
 114
 115 static const match_table_t cifs_mount_option_tokens = {
 116
 117         { Opt_user_xattr, "user_xattr" },
 118         { Opt_nouser_xattr, "nouser_xattr" },
 119         { Opt_forceuid, "forceuid" },
 120         { Opt_noforceuid, "noforceuid" },
 121         { Opt_forcegid, "forcegid" },
 122         { Opt_noforcegid, "noforcegid" },
 123         { Opt_noblocksend, "noblocksend" },
 124         { Opt_noautotune, "noautotune" },
 125         { Opt_hard, "hard" },
 126         { Opt_soft, "soft" },
 127         { Opt_perm, "perm" },
 128         { Opt_noperm, "noperm" },
 129         { Opt_mapchars, "mapchars" },
 130         { Opt_nomapchars, "nomapchars" },
 131         { Opt_sfu, "sfu" },
 132         { Opt_nosfu, "nosfu" },
 133         { Opt_nodfs, "nodfs" },
 134         { Opt_posixpaths, "posixpaths" },
 135         { Opt_noposixpaths, "noposixpaths" },
 136         { Opt_nounix, "nounix" },
 137         { Opt_nounix, "nolinux" },
 138         { Opt_nocase, "nocase" },
 139         { Opt_nocase, "ignorecase" },
 140         { Opt_brl, "brl" },
 141         { Opt_nobrl, "nobrl" },
 142         { Opt_nobrl, "nolock" },
 143         { Opt_forcemandatorylock, "forcemandatorylock" },
 144         { Opt_forcemandatorylock, "forcemand" },
 145         { Opt_setuids, "setuids" },
 146         { Opt_nosetuids, "nosetuids" },
 147         { Opt_dynperm, "dynperm" },
 148         { Opt_nodynperm, "nodynperm" },
 149         { Opt_nohard, "nohard" },
 150         { Opt_nosoft, "nosoft" },
 151         { Opt_nointr, "nointr" },
 152         { Opt_intr, "intr" },
 153         { Opt_nostrictsync, "nostrictsync" },
 154         { Opt_strictsync, "strictsync" },
 155         { Opt_serverino, "serverino" },
 156         { Opt_noserverino, "noserverino" },
 157         { Opt_rwpidforward, "rwpidforward" },
 158         { Opt_cifsacl, "cifsacl" },
 159         { Opt_nocifsacl, "nocifsacl" },
 160         { Opt_acl, "acl" },
 161         { Opt_noacl, "noacl" },
 162         { Opt_locallease, "locallease" },
 163         { Opt_sign, "sign" },
 164         { Opt_seal, "seal" },
 165         { Opt_noac, "noac" },
 166         { Opt_fsc, "fsc" },
 167         { Opt_mfsymlinks, "mfsymlinks" },
 168         { Opt_multiuser, "multiuser" },
 169         { Opt_sloppy, "sloppy" },
 170
 171         { Opt_backupuid, "backupuid=%s" },
 172         { Opt_backupgid, "backupgid=%s" },
 173         { Opt_uid, "uid=%s" },
 174         { Opt_cruid, "cruid=%s" },
 175         { Opt_gid, "gid=%s" },
 176         { Opt_file_mode, "file_mode=%s" },
 177         { Opt_dirmode, "dirmode=%s" },
 178         { Opt_dirmode, "dir_mode=%s" },
 179         { Opt_port, "port=%s" },
 180         { Opt_rsize, "rsize=%s" },
 181         { Opt_wsize, "wsize=%s" },
 182         { Opt_actimeo, "actimeo=%s" },
 183
 184         { Opt_blank_user, "user=" },
 185         { Opt_blank_user, "username=" },
 186         { Opt_user, "user=%s" },
 187         { Opt_user, "username=%s" },
 188         { Opt_blank_pass, "pass=" },
 189         { Opt_blank_pass, "password=" },
 190         { Opt_pass, "pass=%s" },
 191         { Opt_pass, "password=%s" },
 192         { Opt_blank_ip, "ip=" },
 193         { Opt_blank_ip, "addr=" },
 194         { Opt_ip, "ip=%s" },
 195         { Opt_ip, "addr=%s" },
 196         { Opt_unc, "unc=%s" },
 197         { Opt_unc, "target=%s" },
 198         { Opt_unc, "path=%s" },
 199         { Opt_domain, "dom=%s" },
 200         { Opt_domain, "domain=%s" },
 201         { Opt_domain, "workgroup=%s" },
 202         { Opt_srcaddr, "srcaddr=%s" },
 203         { Opt_prefixpath, "prefixpath=%s" },
 204         { Opt_iocharset, "iocharset=%s" },
 205         { Opt_sockopt, "sockopt=%s" },
 206         { Opt_netbiosname, "netbiosname=%s" },
 207         { Opt_servern, "servern=%s" },
 208         { Opt_ver, "ver=%s" },
 209         { Opt_vers, "vers=%s" },
 210         { Opt_sec, "sec=%s" },
 211         { Opt_cache, "cache=%s" },
 212
 213         { Opt_ignore, "cred" },
 214         { Opt_ignore, "credentials" },
 215         { Opt_ignore, "cred=%s" },
 216         { Opt_ignore, "credentials=%s" },
 217         { Opt_ignore, "guest" },
 218         { Opt_ignore, "rw" },
 219         { Opt_ignore, "ro" },
 220         { Opt_ignore, "suid" },
 221         { Opt_ignore, "nosuid" },
 222         { Opt_ignore, "exec" },
 223         { Opt_ignore, "noexec" },
 224         { Opt_ignore, "nodev" },
 225         { Opt_ignore, "noauto" },
 226         { Opt_ignore, "dev" },
 227         { Opt_ignore, "mand" },
 228         { Opt_ignore, "nomand" },
 229         { Opt_ignore, "_netdev" },
 230
 231         { Opt_err, NULL }
 232 };
 233
 234 enum {
 235         Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
 236         Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
 237         Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
 238         Opt_sec_ntlmv2i, Opt_sec_lanman,
 239         Opt_sec_none,
 240
 241         Opt_sec_err
 242 };
 243
 244 static const match_table_t cifs_secflavor_tokens = {
 245         { Opt_sec_krb5, "krb5" },
 246         { Opt_sec_krb5i, "krb5i" },
 247         { Opt_sec_krb5p, "krb5p" },
 248         { Opt_sec_ntlmsspi, "ntlmsspi" },
 249         { Opt_sec_ntlmssp, "ntlmssp" },
 250         { Opt_ntlm, "ntlm" },
 251         { Opt_sec_ntlmi, "ntlmi" },
 252         { Opt_sec_ntlmv2, "nontlm" },
 253         { Opt_sec_ntlmv2, "ntlmv2" },
 254         { Opt_sec_ntlmv2i, "ntlmv2i" },
 255         { Opt_sec_lanman, "lanman" },
 256         { Opt_sec_none, "none" },
 257
 258         { Opt_sec_err, NULL }
 259 };
 260
 261 /* cache flavors */
 262 enum {
 263         Opt_cache_loose,
 264         Opt_cache_strict,
 265         Opt_cache_none,
 266         Opt_cache_err
 267 };
 268
 269 static const match_table_t cifs_cacheflavor_tokens = {
 270         { Opt_cache_loose, "loose" },
 271         { Opt_cache_strict, "strict" },
 272         { Opt_cache_none, "none" },
 273         { Opt_cache_err, NULL }
 274 };
 275
 276 static const match_table_t cifs_smb_version_tokens = {
 277         { Smb_1, SMB1_VERSION_STRING },
 278         { Smb_20, SMB20_VERSION_STRING},
 279         { Smb_21, SMB21_VERSION_STRING },
 280         { Smb_30, SMB30_VERSION_STRING },
 281 };
 282
 283 static int ip_connect(struct TCP_Server_Info *server);
 284 static int generic_ip_connect(struct TCP_Server_Info *server);
 285 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
 286 static void cifs_prune_tlinks(struct work_struct *work);
 287 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
 288                                         const char *devname);
 289
 290 /*
 291  * cifs tcp session reconnection
 292  *
 293  * mark tcp session as reconnecting so temporarily locked
 294  * mark all smb sessions as reconnecting for tcp session
 295  * reconnect tcp session
 296  * wake up waiters on reconnection? - (not needed currently)
 297  */
 298 int
 299 cifs_reconnect(struct TCP_Server_Info *server)
 300 {
 301         int rc = 0;
 302         struct list_head *tmp, *tmp2;
 303         struct cifs_ses *ses;
 304         struct cifs_tcon *tcon;
 305         struct mid_q_entry *mid_entry;
 306         struct list_head retry_list;
 307
 308         spin_lock(&GlobalMid_Lock);
 309         if (server->tcpStatus == CifsExiting) {
 310                 /* the demux thread will exit normally
 311                 next time through the loop */
 312                 spin_unlock(&GlobalMid_Lock);
 313                 return rc;
 314         } else
 315                 server->tcpStatus = CifsNeedReconnect;
 316         spin_unlock(&GlobalMid_Lock);
 317         server->maxBuf = 0;
 318 #ifdef CONFIG_CIFS_SMB2
 319         server->max_read = 0;
 320 #endif
 321
 322         cFYI(1, "Reconnecting tcp session");
 323
 324         /* before reconnecting the tcp session, mark the smb session (uid)
 325                 and the tid bad so they are not used until reconnected */
 326         cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
 327         spin_lock(&cifs_tcp_ses_lock);
 328         list_for_each(tmp, &server->smb_ses_list) {
 329                 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
 330                 ses->need_reconnect = true;
 331                 ses->ipc_tid = 0;
 332                 list_for_each(tmp2, &ses->tcon_list) {
 333                         tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
 334                         tcon->need_reconnect = true;
 335                 }
 336         }
 337         spin_unlock(&cifs_tcp_ses_lock);
 338
 339         /* do not want to be sending data on a socket we are freeing */
 340         cFYI(1, "%s: tearing down socket", __func__);
 341         mutex_lock(&server->srv_mutex);
 342         if (server->ssocket) {
 343                 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
 344                         server->ssocket->flags);
 345                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 346                 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
 347                         server->ssocket->state,
 348                         server->ssocket->flags);
 349                 sock_release(server->ssocket);
 350                 server->ssocket = NULL;
 351         }
 352         server->sequence_number = 0;
 353         server->session_estab = false;
 354         kfree(server->session_key.response);
 355         server->session_key.response = NULL;
 356         server->session_key.len = 0;
 357         server->lstrp = jiffies;
 358         mutex_unlock(&server->srv_mutex);
 359
 360         /* mark submitted MIDs for retry and issue callback */
 361         INIT_LIST_HEAD(&retry_list);
 362         cFYI(1, "%s: moving mids to private list", __func__);
 363         spin_lock(&GlobalMid_Lock);
 364         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 365                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 366                 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 367                         mid_entry->mid_state = MID_RETRY_NEEDED;
 368                 list_move(&mid_entry->qhead, &retry_list);
 369         }
 370         spin_unlock(&GlobalMid_Lock);
 371
 372         cFYI(1, "%s: issuing mid callbacks", __func__);
 373         list_for_each_safe(tmp, tmp2, &retry_list) {
 374                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 375                 list_del_init(&mid_entry->qhead);
 376                 mid_entry->callback(mid_entry);
 377         }
 378
 379         do {
 380                 try_to_freeze();
 381
 382                 /* we should try only the port we connected to before */
 383                 rc = generic_ip_connect(server);
 384                 if (rc) {
 385                         cFYI(1, "reconnect error %d", rc);
 386                         msleep(3000);
 387                 } else {
 388                         atomic_inc(&tcpSesReconnectCount);
 389                         spin_lock(&GlobalMid_Lock);
 390                         if (server->tcpStatus != CifsExiting)
 391                                 server->tcpStatus = CifsNeedNegotiate;
 392                         spin_unlock(&GlobalMid_Lock);
 393                 }
 394         } while (server->tcpStatus == CifsNeedReconnect);
 395
 396         return rc;
 397 }
 398
 399 static void
 400 cifs_echo_request(struct work_struct *work)
 401 {
 402         int rc;
 403         struct TCP_Server_Info *server = container_of(work,
 404                                         struct TCP_Server_Info, echo.work);
 405
 406         /*
 407          * We cannot send an echo if it is disabled or until the
 408          * NEGOTIATE_PROTOCOL request is done, which is indicated by
 409          * server->ops->need_neg() == true. Also, no need to ping if
 410          * we got a response recently.
 411          */
 412         if (!server->ops->need_neg || server->ops->need_neg(server) ||
 413             (server->ops->can_echo && !server->ops->can_echo(server)) ||
 414             time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
 415                 goto requeue_echo;
 416
 417         rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
 418         if (rc)
 419                 cFYI(1, "Unable to send echo request to server: %s",
 420                         server->hostname);
 421
 422 requeue_echo:
 423         queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
 424 }
 425
 426 static bool
 427 allocate_buffers(struct TCP_Server_Info *server)
 428 {
 429         if (!server->bigbuf) {
 430                 server->bigbuf = (char *)cifs_buf_get();
 431                 if (!server->bigbuf) {
 432                         cERROR(1, "No memory for large SMB response");
 433                         msleep(3000);
 434                         /* retry will check if exiting */
 435                         return false;
 436                 }
 437         } else if (server->large_buf) {
 438                 /* we are reusing a dirty large buf, clear its start */
 439                 memset(server->bigbuf, 0, HEADER_SIZE(server));
 440         }
 441
 442         if (!server->smallbuf) {
 443                 server->smallbuf = (char *)cifs_small_buf_get();
 444                 if (!server->smallbuf) {
 445                         cERROR(1, "No memory for SMB response");
 446                         msleep(1000);
 447                         /* retry will check if exiting */
 448                         return false;
 449                 }
 450                 /* beginning of smb buffer is cleared in our buf_get */
 451         } else {
 452                 /* if existing small buf clear beginning */
 453                 memset(server->smallbuf, 0, HEADER_SIZE(server));
 454         }
 455
 456         return true;
 457 }
 458
 459 static bool
 460 server_unresponsive(struct TCP_Server_Info *server)
 461 {
 462         /*
 463          * We need to wait 2 echo intervals to make sure we handle such
 464          * situations right:
 465          * 1s  client sends a normal SMB request
 466          * 2s  client gets a response
 467          * 30s echo workqueue job pops, and decides we got a response recently
 468          *     and don't need to send another
 469          * ...
 470          * 65s kernel_recvmsg times out, and we see that we haven't gotten
 471          *     a response in >60s.
 472          */
 473         if (server->tcpStatus == CifsGood &&
 474             time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
 475                 cERROR(1, "Server %s has not responded in %d seconds. "
 476                           "Reconnecting...", server->hostname,
 477                           (2 * SMB_ECHO_INTERVAL) / HZ);
 478                 cifs_reconnect(server);
 479                 wake_up(&server->response_q);
 480                 return true;
 481         }
 482
 483         return false;
 484 }
 485
 486 /*
 487  * kvec_array_init - clone a kvec array, and advance into it
 488  * @new:        pointer to memory for cloned array
 489  * @iov:        pointer to original array
 490  * @nr_segs:    number of members in original array
 491  * @bytes:      number of bytes to advance into the cloned array
 492  *
 493  * This function will copy the array provided in iov to a section of memory
 494  * and advance the specified number of bytes into the new array. It returns
 495  * the number of segments in the new array. "new" must be at least as big as
 496  * the original iov array.
 497  */
 498 static unsigned int
 499 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
 500                 size_t bytes)
 501 {
 502         size_t base = 0;
 503
 504         while (bytes || !iov->iov_len) {
 505                 int copy = min(bytes, iov->iov_len);
 506
 507                 bytes -= copy;
 508                 base += copy;
 509                 if (iov->iov_len == base) {
 510                         iov++;
 511                         nr_segs--;
 512                         base = 0;
 513                 }
 514         }
 515         memcpy(new, iov, sizeof(*iov) * nr_segs);
 516         new->iov_base += base;
 517         new->iov_len -= base;
 518         return nr_segs;
 519 }
 520
 521 static struct kvec *
 522 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
 523 {
 524         struct kvec *new_iov;
 525
 526         if (server->iov && nr_segs <= server->nr_iov)
 527                 return server->iov;
 528
 529         /* not big enough -- allocate a new one and release the old */
 530         new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
 531         if (new_iov) {
 532                 kfree(server->iov);
 533                 server->iov = new_iov;
 534                 server->nr_iov = nr_segs;
 535         }
 536         return new_iov;
 537 }
 538
 539 int
 540 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
 541                        unsigned int nr_segs, unsigned int to_read)
 542 {
 543         int length = 0;
 544         int total_read;
 545         unsigned int segs;
 546         struct msghdr smb_msg;
 547         struct kvec *iov;
 548
 549         iov = get_server_iovec(server, nr_segs);
 550         if (!iov)
 551                 return -ENOMEM;
 552
 553         smb_msg.msg_control = NULL;
 554         smb_msg.msg_controllen = 0;
 555
 556         for (total_read = 0; to_read; total_read += length, to_read -= length) {
 557                 try_to_freeze();
 558
 559                 if (server_unresponsive(server)) {
 560                         total_read = -EAGAIN;
 561                         break;
 562                 }
 563
 564                 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
 565
 566                 length = kernel_recvmsg(server->ssocket, &smb_msg,
 567                                         iov, segs, to_read, 0);
 568
 569                 if (server->tcpStatus == CifsExiting) {
 570                         total_read = -ESHUTDOWN;
 571                         break;
 572                 } else if (server->tcpStatus == CifsNeedReconnect) {
 573                         cifs_reconnect(server);
 574                         total_read = -EAGAIN;
 575                         break;
 576                 } else if (length == -ERESTARTSYS ||
 577                            length == -EAGAIN ||
 578                            length == -EINTR) {
 579                         /*
 580                          * Minimum sleep to prevent looping, allowing socket
 581                          * to clear and app threads to set tcpStatus
 582                          * CifsNeedReconnect if server hung.
 583                          */
 584                         usleep_range(1000, 2000);
 585                         length = 0;
 586                         continue;
 587                 } else if (length <= 0) {
 588                         cFYI(1, "Received no data or error: expecting %d "
 589                                 "got %d", to_read, length);
 590                         cifs_reconnect(server);
 591                         total_read = -EAGAIN;
 592                         break;
 593                 }
 594         }
 595         return total_read;
 596 }
 597
 598 int
 599 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 600                       unsigned int to_read)
 601 {
 602         struct kvec iov;
 603
 604         iov.iov_base = buf;
 605         iov.iov_len = to_read;
 606
 607         return cifs_readv_from_socket(server, &iov, 1, to_read);
 608 }
 609
 610 static bool
 611 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
 612 {
 613         /*
 614          * The first byte big endian of the length field,
 615          * is actually not part of the length but the type
 616          * with the most common, zero, as regular data.
 617          */
 618         switch (type) {
 619         case RFC1002_SESSION_MESSAGE:
 620                 /* Regular SMB response */
 621                 return true;
 622         case RFC1002_SESSION_KEEP_ALIVE:
 623                 cFYI(1, "RFC 1002 session keep alive");
 624                 break;
 625         case RFC1002_POSITIVE_SESSION_RESPONSE:
 626                 cFYI(1, "RFC 1002 positive session response");
 627                 break;
 628         case RFC1002_NEGATIVE_SESSION_RESPONSE:
 629                 /*
 630                  * We get this from Windows 98 instead of an error on
 631                  * SMB negprot response.
 632                  */
 633                 cFYI(1, "RFC 1002 negative session response");
 634                 /* give server a second to clean up */
 635                 msleep(1000);
 636                 /*
 637                  * Always try 445 first on reconnect since we get NACK
 638                  * on some if we ever connected to port 139 (the NACK
 639                  * is since we do not begin with RFC1001 session
 640                  * initialize frame).
 641                  */
 642                 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
 643                 cifs_reconnect(server);
 644                 wake_up(&server->response_q);
 645                 break;
 646         default:
 647                 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
 648                 cifs_reconnect(server);
 649         }
 650
 651         return false;
 652 }
 653
 654 void
 655 dequeue_mid(struct mid_q_entry *mid, bool malformed)
 656 {
 657 #ifdef CONFIG_CIFS_STATS2
 658         mid->when_received = jiffies;
 659 #endif
 660         spin_lock(&GlobalMid_Lock);
 661         if (!malformed)
 662                 mid->mid_state = MID_RESPONSE_RECEIVED;
 663         else
 664                 mid->mid_state = MID_RESPONSE_MALFORMED;
 665         list_del_init(&mid->qhead);
 666         spin_unlock(&GlobalMid_Lock);
 667 }
 668
 669 static void
 670 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 671            char *buf, int malformed)
 672 {
 673         if (server->ops->check_trans2 &&
 674             server->ops->check_trans2(mid, server, buf, malformed))
 675                 return;
 676         mid->resp_buf = buf;
 677         mid->large_buf = server->large_buf;
 678         /* Was previous buf put in mpx struct for multi-rsp? */
 679         if (!mid->multiRsp) {
 680                 /* smb buffer will be freed by user thread */
 681                 if (server->large_buf)
 682                         server->bigbuf = NULL;
 683                 else
 684                         server->smallbuf = NULL;
 685         }
 686         dequeue_mid(mid, malformed);
 687 }
 688
 689 static void clean_demultiplex_info(struct TCP_Server_Info *server)
 690 {
 691         int length;
 692
 693         /* take it off the list, if it's not already */
 694         spin_lock(&cifs_tcp_ses_lock);
 695         list_del_init(&server->tcp_ses_list);
 696         spin_unlock(&cifs_tcp_ses_lock);
 697
 698         spin_lock(&GlobalMid_Lock);
 699         server->tcpStatus = CifsExiting;
 700         spin_unlock(&GlobalMid_Lock);
 701         wake_up_all(&server->response_q);
 702
 703         /* check if we have blocked requests that need to free */
 704         spin_lock(&server->req_lock);
 705         if (server->credits <= 0)
 706                 server->credits = 1;
 707         spin_unlock(&server->req_lock);
 708         /*
 709          * Although there should not be any requests blocked on this queue it
 710          * can not hurt to be paranoid and try to wake up requests that may
 711          * haven been blocked when more than 50 at time were on the wire to the
 712          * same server - they now will see the session is in exit state and get
 713          * out of SendReceive.
 714          */
 715         wake_up_all(&server->request_q);
 716         /* give those requests time to exit */
 717         msleep(125);
 718
 719         if (server->ssocket) {
 720                 sock_release(server->ssocket);
 721                 server->ssocket = NULL;
 722         }
 723
 724         if (!list_empty(&server->pending_mid_q)) {
 725                 struct list_head dispose_list;
 726                 struct mid_q_entry *mid_entry;
 727                 struct list_head *tmp, *tmp2;
 728
 729                 INIT_LIST_HEAD(&dispose_list);
 730                 spin_lock(&GlobalMid_Lock);
 731                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 732                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 733                         cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
 734                         mid_entry->mid_state = MID_SHUTDOWN;
 735                         list_move(&mid_entry->qhead, &dispose_list);
 736                 }
 737                 spin_unlock(&GlobalMid_Lock);
 738
 739                 /* now walk dispose list and issue callbacks */
 740                 list_for_each_safe(tmp, tmp2, &dispose_list) {
 741                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 742                         cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
 743                         list_del_init(&mid_entry->qhead);
 744                         mid_entry->callback(mid_entry);
 745                 }
 746                 /* 1/8th of sec is more than enough time for them to exit */
 747                 msleep(125);
 748         }
 749
 750         if (!list_empty(&server->pending_mid_q)) {
 751                 /*
 752                  * mpx threads have not exited yet give them at least the smb
 753                  * send timeout time for long ops.
 754                  *
 755                  * Due to delays on oplock break requests, we need to wait at
 756                  * least 45 seconds before giving up on a request getting a
 757                  * response and going ahead and killing cifsd.
 758                  */
 759                 cFYI(1, "Wait for exit from demultiplex thread");
 760                 msleep(46000);
 761                 /*
 762                  * If threads still have not exited they are probably never
 763                  * coming home not much else we can do but free the memory.
 764                  */
 765         }
 766
 767         kfree(server->hostname);
 768         kfree(server->iov);
 769         kfree(server);
 770
 771         length = atomic_dec_return(&tcpSesAllocCount);
 772         if (length > 0)
 773                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 774                                 GFP_KERNEL);
 775 }
 776
 777 static int
 778 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 779 {
 780         int length;
 781         char *buf = server->smallbuf;
 782         unsigned int pdu_length = get_rfc1002_length(buf);
 783
 784         /* make sure this will fit in a large buffer */
 785         if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
 786                 cERROR(1, "SMB response too long (%u bytes)",
 787                         pdu_length);
 788                 cifs_reconnect(server);
 789                 wake_up(&server->response_q);
 790                 return -EAGAIN;
 791         }
 792
 793         /* switch to large buffer if too big for a small one */
 794         if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 795                 server->large_buf = true;
 796                 memcpy(server->bigbuf, buf, server->total_read);
 797                 buf = server->bigbuf;
 798         }
 799
 800         /* now read the rest */
 801         length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
 802                                 pdu_length - HEADER_SIZE(server) + 1 + 4);
 803         if (length < 0)
 804                 return length;
 805         server->total_read += length;
 806
 807         dump_smb(buf, server->total_read);
 808
 809         /*
 810          * We know that we received enough to get to the MID as we
 811          * checked the pdu_length earlier. Now check to see
 812          * if the rest of the header is OK. We borrow the length
 813          * var for the rest of the loop to avoid a new stack var.
 814          *
 815          * 48 bytes is enough to display the header and a little bit
 816          * into the payload for debugging purposes.
 817          */
 818         length = server->ops->check_message(buf, server->total_read);
 819         if (length != 0)
 820                 cifs_dump_mem("Bad SMB: ", buf,
 821                         min_t(unsigned int, server->total_read, 48));
 822
 823         if (server->ops->is_status_pending &&
 824             server->ops->is_status_pending(buf, server, length))
 825                 return -1;
 826
 827         if (!mid)
 828                 return length;
 829
 830         handle_mid(mid, server, buf, length);
 831         return 0;
 832 }
 833
 834 static int
 835 cifs_demultiplex_thread(void *p)
 836 {
 837         int length;
 838         struct TCP_Server_Info *server = p;
 839         unsigned int pdu_length;
 840         char *buf = NULL;
 841         struct task_struct *task_to_wake = NULL;
 842         struct mid_q_entry *mid_entry;
 843
 844         current->flags |= PF_MEMALLOC;
 845         cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
 846
 847         length = atomic_inc_return(&tcpSesAllocCount);
 848         if (length > 1)
 849                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 850                                 GFP_KERNEL);
 851
 852         set_freezable();
 853         while (server->tcpStatus != CifsExiting) {
 854                 if (try_to_freeze())
 855                         continue;
 856
 857                 if (!allocate_buffers(server))
 858                         continue;
 859
 860                 server->large_buf = false;
 861                 buf = server->smallbuf;
 862                 pdu_length = 4; /* enough to get RFC1001 header */
 863
 864                 length = cifs_read_from_socket(server, buf, pdu_length);
 865                 if (length < 0)
 866                         continue;
 867                 server->total_read = length;
 868
 869                 /*
 870                  * The right amount was read from socket - 4 bytes,
 871                  * so we can now interpret the length field.
 872                  */
 873                 pdu_length = get_rfc1002_length(buf);
 874
 875                 cFYI(1, "RFC1002 header 0x%x", pdu_length);
 876                 if (!is_smb_response(server, buf[0]))
 877                         continue;
 878
 879                 /* make sure we have enough to get to the MID */
 880                 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
 881                         cERROR(1, "SMB response too short (%u bytes)",
 882                                 pdu_length);
 883                         cifs_reconnect(server);
 884                         wake_up(&server->response_q);
 885                         continue;
 886                 }
 887
 888                 /* read down to the MID */
 889                 length = cifs_read_from_socket(server, buf + 4,
 890                                                HEADER_SIZE(server) - 1 - 4);
 891                 if (length < 0)
 892                         continue;
 893                 server->total_read += length;
 894
 895                 mid_entry = server->ops->find_mid(server, buf);
 896
 897                 if (!mid_entry || !mid_entry->receive)
 898                         length = standard_receive3(server, mid_entry);
 899                 else
 900                         length = mid_entry->receive(server, mid_entry);
 901
 902                 if (length < 0)
 903                         continue;
 904
 905                 if (server->large_buf)
 906                         buf = server->bigbuf;
 907
 908                 server->lstrp = jiffies;
 909                 if (mid_entry != NULL) {
 910                         if (!mid_entry->multiRsp || mid_entry->multiEnd)
 911                                 mid_entry->callback(mid_entry);
 912                 } else if (!server->ops->is_oplock_break ||
 913                            !server->ops->is_oplock_break(buf, server)) {
 914                         cERROR(1, "No task to wake, unknown frame received! "
 915                                    "NumMids %d", atomic_read(&midCount));
 916                         cifs_dump_mem("Received Data is: ", buf,
 917                                       HEADER_SIZE(server));
 918 #ifdef CONFIG_CIFS_DEBUG2
 919                         if (server->ops->dump_detail)
 920                                 server->ops->dump_detail(buf);
 921                         cifs_dump_mids(server);
 922 #endif /* CIFS_DEBUG2 */
 923
 924                 }
 925         } /* end while !EXITING */
 926
 927         /* buffer usually freed in free_mid - need to free it here on exit */
 928         cifs_buf_release(server->bigbuf);
 929         if (server->smallbuf) /* no sense logging a debug message if NULL */
 930                 cifs_small_buf_release(server->smallbuf);
 931
 932         task_to_wake = xchg(&server->tsk, NULL);
 933         clean_demultiplex_info(server);
 934
 935         /* if server->tsk was NULL then wait for a signal before exiting */
 936         if (!task_to_wake) {
 937                 set_current_state(TASK_INTERRUPTIBLE);
 938                 while (!signal_pending(current)) {
 939                         schedule();
 940                         set_current_state(TASK_INTERRUPTIBLE);
 941                 }
 942                 set_current_state(TASK_RUNNING);
 943         }
 944
 945         module_put_and_exit(0);
 946 }
 947
 948 /* extract the host portion of the UNC string */
 949 static char *
 950 extract_hostname(const char *unc)
 951 {
 952         const char *src;
 953         char *dst, *delim;
 954         unsigned int len;
 955
 956         /* skip double chars at beginning of string */
 957         /* BB: check validity of these bytes? */
 958         src = unc + 2;
 959
 960         /* delimiter between hostname and sharename is always '\\' now */
 961         delim = strchr(src, '\\');
 962         if (!delim)
 963                 return ERR_PTR(-EINVAL);
 964
 965         len = delim - src;
 966         dst = kmalloc((len + 1), GFP_KERNEL);
 967         if (dst == NULL)
 968                 return ERR_PTR(-ENOMEM);
 969
 970         memcpy(dst, src, len);
 971         dst[len] = '\0';
 972
 973         return dst;
 974 }
 975
 976 static int get_option_ul(substring_t args[], unsigned long *option)
 977 {
 978         int rc;
 979         char *string;
 980
 981         string = match_strdup(args);
 982         if (string == NULL)
 983                 return -ENOMEM;
 984         rc = kstrtoul(string, 0, option);
 985         kfree(string);
 986
 987         return rc;
 988 }
 989
 990
 991 static int cifs_parse_security_flavors(char *value,
 992                                        struct smb_vol *vol)
 993 {
 994
 995         substring_t args[MAX_OPT_ARGS];
 996
 997         switch (match_token(value, cifs_secflavor_tokens, args)) {
 998         case Opt_sec_krb5:
 999                 vol->secFlg |= CIFSSEC_MAY_KRB5;
1000                 break;
1001         case Opt_sec_krb5i:
1002                 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1003                 break;
1004         case Opt_sec_krb5p:
1005                 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1006                 cERROR(1, "Krb5 cifs privacy not supported");
1007                 break;
1008         case Opt_sec_ntlmssp:
1009                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1010                 break;
1011         case Opt_sec_ntlmsspi:
1012                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1013                 break;
1014         case Opt_ntlm:
1015                 /* ntlm is default so can be turned off too */
1016                 vol->secFlg |= CIFSSEC_MAY_NTLM;
1017                 break;
1018         case Opt_sec_ntlmi:
1019                 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1020                 break;
1021         case Opt_sec_ntlmv2:
1022                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1023                 break;
1024         case Opt_sec_ntlmv2i:
1025                 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1026                 break;
1027 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1028         case Opt_sec_lanman:
1029                 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1030                 break;
1031 #endif
1032         case Opt_sec_none:
1033                 vol->nullauth = 1;
1034                 break;
1035         default:
1036                 cERROR(1, "bad security option: %s", value);
1037                 return 1;
1038         }
1039
1040         return 0;
1041 }
1042
1043 static int
1044 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1045 {
1046         substring_t args[MAX_OPT_ARGS];
1047
1048         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1049         case Opt_cache_loose:
1050                 vol->direct_io = false;
1051                 vol->strict_io = false;
1052                 break;
1053         case Opt_cache_strict:
1054                 vol->direct_io = false;
1055                 vol->strict_io = true;
1056                 break;
1057         case Opt_cache_none:
1058                 vol->direct_io = true;
1059                 vol->strict_io = false;
1060                 break;
1061         default:
1062                 cERROR(1, "bad cache= option: %s", value);
1063                 return 1;
1064         }
1065         return 0;
1066 }
1067
1068 static int
1069 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1070 {
1071         substring_t args[MAX_OPT_ARGS];
1072
1073         switch (match_token(value, cifs_smb_version_tokens, args)) {
1074         case Smb_1:
1075                 vol->ops = &smb1_operations;
1076                 vol->vals = &smb1_values;
1077                 break;
1078 #ifdef CONFIG_CIFS_SMB2
1079         case Smb_20:
1080                 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1081                 vol->vals = &smb20_values;
1082                 break;
1083         case Smb_21:
1084                 vol->ops = &smb21_operations;
1085                 vol->vals = &smb21_values;
1086                 break;
1087         case Smb_30:
1088                 vol->ops = &smb30_operations;
1089                 vol->vals = &smb30_values;
1090                 break;
1091 #endif
1092         default:
1093                 cERROR(1, "Unknown vers= option specified: %s", value);
1094                 return 1;
1095         }
1096         return 0;
1097 }
1098
1099 /*
1100  * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1101  * fields with the result. Returns 0 on success and an error otherwise.
1102  */
1103 static int
1104 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1105 {
1106         char *pos;
1107         const char *delims = "/\\";
1108         size_t len;
1109
1110         /* make sure we have a valid UNC double delimiter prefix */
1111         len = strspn(devname, delims);
1112         if (len != 2)
1113                 return -EINVAL;
1114
1115         /* find delimiter between host and sharename */
1116         pos = strpbrk(devname + 2, delims);
1117         if (!pos)
1118                 return -EINVAL;
1119
1120         /* skip past delimiter */
1121         ++pos;
1122
1123         /* now go until next delimiter or end of string */
1124         len = strcspn(pos, delims);
1125
1126         /* move "pos" up to delimiter or NULL */
1127         pos += len;
1128         vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1129         if (!vol->UNC)
1130                 return -ENOMEM;
1131
1132         convert_delimiter(vol->UNC, '\\');
1133
1134         /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1135         if (!*pos++ || !*pos)
1136                 return 0;
1137
1138         vol->prepath = kstrdup(pos, GFP_KERNEL);
1139         if (!vol->prepath)
1140                 return -ENOMEM;
1141
1142         return 0;
1143 }
1144
1145 static int
1146 cifs_parse_mount_options(const char *mountdata, const char *devname,
1147                          struct smb_vol *vol)
1148 {
1149         char *data, *end;
1150         char *mountdata_copy = NULL, *options;
1151         unsigned int  temp_len, i, j;
1152         char separator[2];
1153         short int override_uid = -1;
1154         short int override_gid = -1;
1155         bool uid_specified = false;
1156         bool gid_specified = false;
1157         bool sloppy = false;
1158         char *invalid = NULL;
1159         char *nodename = utsname()->nodename;
1160         char *string = NULL;
1161         char *tmp_end, *value;
1162         char delim;
1163         bool got_ip = false;
1164         unsigned short port = 0;
1165         struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1166
1167         separator[0] = ',';
1168         separator[1] = 0;
1169         delim = separator[0];
1170
1171         /* ensure we always start with zeroed-out smb_vol */
1172         memset(vol, 0, sizeof(*vol));
1173
1174         /*
1175          * does not have to be perfect mapping since field is
1176          * informational, only used for servers that do not support
1177          * port 445 and it can be overridden at mount time
1178          */
1179         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1180         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1181                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1182
1183         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1184         /* null target name indicates to use *SMBSERVR default called name
1185            if we end up sending RFC1001 session initialize */
1186         vol->target_rfc1001_name[0] = 0;
1187         vol->cred_uid = current_uid();
1188         vol->linux_uid = current_uid();
1189         vol->linux_gid = current_gid();
1190
1191         /* default to only allowing write access to owner of the mount */
1192         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1193
1194         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1195         /* default is always to request posix paths. */
1196         vol->posix_paths = 1;
1197         /* default to using server inode numbers where available */
1198         vol->server_ino = 1;
1199
1200         /* default is to use strict cifs caching semantics */
1201         vol->strict_io = true;
1202
1203         vol->actimeo = CIFS_DEF_ACTIMEO;
1204
1205         /* FIXME: add autonegotiation -- for now, SMB1 is default */
1206         vol->ops = &smb1_operations;
1207         vol->vals = &smb1_values;
1208
1209         if (!mountdata)
1210                 goto cifs_parse_mount_err;
1211
1212         mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1213         if (!mountdata_copy)
1214                 goto cifs_parse_mount_err;
1215
1216         options = mountdata_copy;
1217         end = options + strlen(options);
1218
1219         if (strncmp(options, "sep=", 4) == 0) {
1220                 if (options[4] != 0) {
1221                         separator[0] = options[4];
1222                         options += 5;
1223                 } else {
1224                         cFYI(1, "Null separator not allowed");
1225                 }
1226         }
1227         vol->backupuid_specified = false; /* no backup intent for a user */
1228         vol->backupgid_specified = false; /* no backup intent for a group */
1229
1230         /*
1231          * For now, we ignore -EINVAL errors under the assumption that the
1232          * unc= and prefixpath= options will be usable.
1233          */
1234         if (cifs_parse_devname(devname, vol) == -ENOMEM) {
1235                 printk(KERN_ERR "CIFS: Unable to allocate memory to parse "
1236                                 "device string.\n");
1237                 goto out_nomem;
1238         }
1239
1240         while ((data = strsep(&options, separator)) != NULL) {
1241                 substring_t args[MAX_OPT_ARGS];
1242                 unsigned long option;
1243                 int token;
1244
1245                 if (!*data)
1246                         continue;
1247
1248                 token = match_token(data, cifs_mount_option_tokens, args);
1249
1250                 switch (token) {
1251
1252                 /* Ingnore the following */
1253                 case Opt_ignore:
1254                         break;
1255
1256                 /* Boolean values */
1257                 case Opt_user_xattr:
1258                         vol->no_xattr = 0;
1259                         break;
1260                 case Opt_nouser_xattr:
1261                         vol->no_xattr = 1;
1262                         break;
1263                 case Opt_forceuid:
1264                         override_uid = 1;
1265                         break;
1266                 case Opt_noforceuid:
1267                         override_uid = 0;
1268                         break;
1269                 case Opt_forcegid:
1270                         override_gid = 1;
1271                         break;
1272                 case Opt_noforcegid:
1273                         override_gid = 0;
1274                         break;
1275                 case Opt_noblocksend:
1276                         vol->noblocksnd = 1;
1277                         break;
1278                 case Opt_noautotune:
1279                         vol->noautotune = 1;
1280                         break;
1281                 case Opt_hard:
1282                         vol->retry = 1;
1283                         break;
1284                 case Opt_soft:
1285                         vol->retry = 0;
1286                         break;
1287                 case Opt_perm:
1288                         vol->noperm = 0;
1289                         break;
1290                 case Opt_noperm:
1291                         vol->noperm = 1;
1292                         break;
1293                 case Opt_mapchars:
1294                         vol->remap = 1;
1295                         break;
1296                 case Opt_nomapchars:
1297                         vol->remap = 0;
1298                         break;
1299                 case Opt_sfu:
1300                         vol->sfu_emul = 1;
1301                         break;
1302                 case Opt_nosfu:
1303                         vol->sfu_emul = 0;
1304                         break;
1305                 case Opt_nodfs:
1306                         vol->nodfs = 1;
1307                         break;
1308                 case Opt_posixpaths:
1309                         vol->posix_paths = 1;
1310                         break;
1311                 case Opt_noposixpaths:
1312                         vol->posix_paths = 0;
1313                         break;
1314                 case Opt_nounix:
1315                         vol->no_linux_ext = 1;
1316                         break;
1317                 case Opt_nocase:
1318                         vol->nocase = 1;
1319                         break;
1320                 case Opt_brl:
1321                         vol->nobrl =  0;
1322                         break;
1323                 case Opt_nobrl:
1324                         vol->nobrl =  1;
1325                         /*
1326                          * turn off mandatory locking in mode
1327                          * if remote locking is turned off since the
1328                          * local vfs will do advisory
1329                          */
1330                         if (vol->file_mode ==
1331                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1332                                 vol->file_mode = S_IALLUGO;
1333                         break;
1334                 case Opt_forcemandatorylock:
1335                         vol->mand_lock = 1;
1336                         break;
1337                 case Opt_setuids:
1338                         vol->setuids = 1;
1339                         break;
1340                 case Opt_nosetuids:
1341                         vol->setuids = 0;
1342                         break;
1343                 case Opt_dynperm:
1344                         vol->dynperm = true;
1345                         break;
1346                 case Opt_nodynperm:
1347                         vol->dynperm = false;
1348                         break;
1349                 case Opt_nohard:
1350                         vol->retry = 0;
1351                         break;
1352                 case Opt_nosoft:
1353                         vol->retry = 1;
1354                         break;
1355                 case Opt_nointr:
1356                         vol->intr = 0;
1357                         break;
1358                 case Opt_intr:
1359                         vol->intr = 1;
1360                         break;
1361                 case Opt_nostrictsync:
1362                         vol->nostrictsync = 1;
1363                         break;
1364                 case Opt_strictsync:
1365                         vol->nostrictsync = 0;
1366                         break;
1367                 case Opt_serverino:
1368                         vol->server_ino = 1;
1369                         break;
1370                 case Opt_noserverino:
1371                         vol->server_ino = 0;
1372                         break;
1373                 case Opt_rwpidforward:
1374                         vol->rwpidforward = 1;
1375                         break;
1376                 case Opt_cifsacl:
1377                         vol->cifs_acl = 1;
1378                         break;
1379                 case Opt_nocifsacl:
1380                         vol->cifs_acl = 0;
1381                         break;
1382                 case Opt_acl:
1383                         vol->no_psx_acl = 0;
1384                         break;
1385                 case Opt_noacl:
1386                         vol->no_psx_acl = 1;
1387                         break;
1388                 case Opt_locallease:
1389                         vol->local_lease = 1;
1390                         break;
1391                 case Opt_sign:
1392                         vol->secFlg |= CIFSSEC_MUST_SIGN;
1393                         break;
1394                 case Opt_seal:
1395                         /* we do not do the following in secFlags because seal
1396                          * is a per tree connection (mount) not a per socket
1397                          * or per-smb connection option in the protocol
1398                          * vol->secFlg |= CIFSSEC_MUST_SEAL;
1399                          */
1400                         vol->seal = 1;
1401                         break;
1402                 case Opt_noac:
1403                         printk(KERN_WARNING "CIFS: Mount option noac not "
1404                                 "supported. Instead set "
1405                                 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1406                         break;
1407                 case Opt_fsc:
1408 #ifndef CONFIG_CIFS_FSCACHE
1409                         cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1410                                   "kernel config option set");
1411                         goto cifs_parse_mount_err;
1412 #endif
1413                         vol->fsc = true;
1414                         break;
1415                 case Opt_mfsymlinks:
1416                         vol->mfsymlinks = true;
1417                         break;
1418                 case Opt_multiuser:
1419                         vol->multiuser = true;
1420                         break;
1421                 case Opt_sloppy:
1422                         sloppy = true;
1423                         break;
1424
1425                 /* Numeric Values */
1426                 case Opt_backupuid:
1427                         if (get_option_ul(args, &option)) {
1428                                 cERROR(1, "%s: Invalid backupuid value",
1429                                         __func__);
1430                                 goto cifs_parse_mount_err;
1431                         }
1432                         vol->backupuid = option;
1433                         vol->backupuid_specified = true;
1434                         break;
1435                 case Opt_backupgid:
1436                         if (get_option_ul(args, &option)) {
1437                                 cERROR(1, "%s: Invalid backupgid value",
1438                                         __func__);
1439                                 goto cifs_parse_mount_err;
1440                         }
1441                         vol->backupgid = option;
1442                         vol->backupgid_specified = true;
1443                         break;
1444                 case Opt_uid:
1445                         if (get_option_ul(args, &option)) {
1446                                 cERROR(1, "%s: Invalid uid value",
1447                                         __func__);
1448                                 goto cifs_parse_mount_err;
1449                         }
1450                         vol->linux_uid = option;
1451                         uid_specified = true;
1452                         break;
1453                 case Opt_cruid:
1454                         if (get_option_ul(args, &option)) {
1455                                 cERROR(1, "%s: Invalid cruid value",
1456                                         __func__);
1457                                 goto cifs_parse_mount_err;
1458                         }
1459                         vol->cred_uid = option;
1460                         break;
1461                 case Opt_gid:
1462                         if (get_option_ul(args, &option)) {
1463                                 cERROR(1, "%s: Invalid gid value",
1464                                                 __func__);
1465                                 goto cifs_parse_mount_err;
1466                         }
1467                         vol->linux_gid = option;
1468                         gid_specified = true;
1469                         break;
1470                 case Opt_file_mode:
1471                         if (get_option_ul(args, &option)) {
1472                                 cERROR(1, "%s: Invalid file_mode value",
1473                                         __func__);
1474                                 goto cifs_parse_mount_err;
1475                         }
1476                         vol->file_mode = option;
1477                         break;
1478                 case Opt_dirmode:
1479                         if (get_option_ul(args, &option)) {
1480                                 cERROR(1, "%s: Invalid dir_mode value",
1481                                         __func__);
1482                                 goto cifs_parse_mount_err;
1483                         }
1484                         vol->dir_mode = option;
1485                         break;
1486                 case Opt_port:
1487                         if (get_option_ul(args, &option) ||
1488                             option > USHRT_MAX) {
1489                                 cERROR(1, "%s: Invalid port value", __func__);
1490                                 goto cifs_parse_mount_err;
1491                         }
1492                         port = (unsigned short)option;
1493                         break;
1494                 case Opt_rsize:
1495                         if (get_option_ul(args, &option)) {
1496                                 cERROR(1, "%s: Invalid rsize value",
1497                                         __func__);
1498                                 goto cifs_parse_mount_err;
1499                         }
1500                         vol->rsize = option;
1501                         break;
1502                 case Opt_wsize:
1503                         if (get_option_ul(args, &option)) {
1504                                 cERROR(1, "%s: Invalid wsize value",
1505                                         __func__);
1506                                 goto cifs_parse_mount_err;
1507                         }
1508                         vol->wsize = option;
1509                         break;
1510                 case Opt_actimeo:
1511                         if (get_option_ul(args, &option)) {
1512                                 cERROR(1, "%s: Invalid actimeo value",
1513                                         __func__);
1514                                 goto cifs_parse_mount_err;
1515                         }
1516                         vol->actimeo = HZ * option;
1517                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1518                                 cERROR(1, "CIFS: attribute cache"
1519                                           "timeout too large");
1520                                 goto cifs_parse_mount_err;
1521                         }
1522                         break;
1523
1524                 /* String Arguments */
1525
1526                 case Opt_blank_user:
1527                         /* null user, ie. anonymous authentication */
1528                         vol->nullauth = 1;
1529                         vol->username = NULL;
1530                         break;
1531                 case Opt_user:
1532                         string = match_strdup(args);
1533                         if (string == NULL)
1534                                 goto out_nomem;
1535
1536                         if (strnlen(string, MAX_USERNAME_SIZE) >
1537                                                         MAX_USERNAME_SIZE) {
1538                                 printk(KERN_WARNING "CIFS: username too long\n");
1539                                 goto cifs_parse_mount_err;
1540                         }
1541                         vol->username = kstrdup(string, GFP_KERNEL);
1542                         if (!vol->username) {
1543                                 printk(KERN_WARNING "CIFS: no memory "
1544                                                     "for username\n");
1545                                 goto cifs_parse_mount_err;
1546                         }
1547                         break;
1548                 case Opt_blank_pass:
1549                         vol->password = NULL;
1550                         break;
1551                 case Opt_pass:
1552                         /* passwords have to be handled differently
1553                          * to allow the character used for deliminator
1554                          * to be passed within them
1555                          */
1556
1557                         /* Obtain the value string */
1558                         value = strchr(data, '=');
1559                         value++;
1560
1561                         /* Set tmp_end to end of the string */
1562                         tmp_end = (char *) value + strlen(value);
1563
1564                         /* Check if following character is the deliminator
1565                          * If yes, we have encountered a double deliminator
1566                          * reset the NULL character to the deliminator
1567                          */
1568                         if (tmp_end < end && tmp_end[1] == delim) {
1569                                 tmp_end[0] = delim;
1570
1571                                 /* Keep iterating until we get to a single
1572                                  * deliminator OR the end
1573                                  */
1574                                 while ((tmp_end = strchr(tmp_end, delim))
1575                                         != NULL && (tmp_end[1] == delim)) {
1576                                                 tmp_end = (char *) &tmp_end[2];
1577                                 }
1578
1579                                 /* Reset var options to point to next element */
1580                                 if (tmp_end) {
1581                                         tmp_end[0] = '\0';
1582                                         options = (char *) &tmp_end[1];
1583                                 } else
1584                                         /* Reached the end of the mount option
1585                                          * string */
1586                                         options = end;
1587                         }
1588
1589                         /* Now build new password string */
1590                         temp_len = strlen(value);
1591                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1592                         if (vol->password == NULL) {
1593                                 printk(KERN_WARNING "CIFS: no memory "
1594                                                     "for password\n");
1595                                 goto cifs_parse_mount_err;
1596                         }
1597
1598                         for (i = 0, j = 0; i < temp_len; i++, j++) {
1599                                 vol->password[j] = value[i];
1600                                 if ((value[i] == delim) &&
1601                                      value[i+1] == delim)
1602                                         /* skip the second deliminator */
1603                                         i++;
1604                         }
1605                         vol->password[j] = '\0';
1606                         break;
1607                 case Opt_blank_ip:
1608                         /* FIXME: should this be an error instead? */
1609                         got_ip = false;
1610                         break;
1611                 case Opt_ip:
1612                         string = match_strdup(args);
1613                         if (string == NULL)
1614                                 goto out_nomem;
1615
1616                         if (!cifs_convert_address(dstaddr, string,
1617                                         strlen(string))) {
1618                                 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1619                                         string);
1620                                 goto cifs_parse_mount_err;
1621                         }
1622                         got_ip = true;
1623                         break;
1624                 case Opt_unc:
1625                         string = vol->UNC;
1626                         vol->UNC = match_strdup(args);
1627                         if (vol->UNC == NULL) {
1628                                 kfree(string);
1629                                 goto out_nomem;
1630                         }
1631
1632                         convert_delimiter(vol->UNC, '\\');
1633                         if (vol->UNC[0] != '\\' || vol->UNC[1] != '\\') {
1634                                 kfree(string);
1635                                 printk(KERN_ERR "CIFS: UNC Path does not "
1636                                                 "begin with // or \\\\\n");
1637                                 goto cifs_parse_mount_err;
1638                         }
1639
1640                         /* Compare old unc= option to new one */
1641                         if (!string || strcmp(string, vol->UNC))
1642                                 printk(KERN_WARNING "CIFS: the value of the "
1643                                         "unc= mount option does not match the "
1644                                         "device string. Using the unc= option "
1645                                         "for now. In 3.10, that option will "
1646                                         "be ignored and the contents of the "
1647                                         "device string will be used "
1648                                         "instead. (%s != %s)\n", string,
1649                                         vol->UNC);
1650                         break;
1651                 case Opt_domain:
1652                         string = match_strdup(args);
1653                         if (string == NULL)
1654                                 goto out_nomem;
1655
1656                         if (strnlen(string, 256) == 256) {
1657                                 printk(KERN_WARNING "CIFS: domain name too"
1658                                                     " long\n");
1659                                 goto cifs_parse_mount_err;
1660                         }
1661
1662                         vol->domainname = kstrdup(string, GFP_KERNEL);
1663                         if (!vol->domainname) {
1664                                 printk(KERN_WARNING "CIFS: no memory "
1665                                                     "for domainname\n");
1666                                 goto cifs_parse_mount_err;
1667                         }
1668                         cFYI(1, "Domain name set");
1669                         break;
1670                 case Opt_srcaddr:
1671                         string = match_strdup(args);
1672                         if (string == NULL)
1673                                 goto out_nomem;
1674
1675                         if (!cifs_convert_address(
1676                                         (struct sockaddr *)&vol->srcaddr,
1677                                         string, strlen(string))) {
1678                                 printk(KERN_WARNING "CIFS:  Could not parse"
1679                                                     " srcaddr: %s\n", string);
1680                                 goto cifs_parse_mount_err;
1681                         }
1682                         break;
1683                 case Opt_prefixpath:
1684                         /* skip over any leading delimiter */
1685                         if (*args[0].from == '/' || *args[0].from == '\\')
1686                                 args[0].from++;
1687
1688                         string = vol->prepath;
1689                         vol->prepath = match_strdup(args);
1690                         if (vol->prepath == NULL) {
1691                                 kfree(string);
1692                                 goto out_nomem;
1693                         }
1694                         /* Compare old prefixpath= option to new one */
1695                         if (!string || strcmp(string, vol->prepath))
1696                                 printk(KERN_WARNING "CIFS: the value of the "
1697                                         "prefixpath= mount option does not "
1698                                         "match the device string. Using the "
1699                                         "prefixpath= option for now. In 3.10, "
1700                                         "that option will be ignored and the "
1701                                         "contents of the device string will be "
1702                                         "used instead.(%s != %s)\n", string,
1703                                         vol->prepath);
1704                         break;
1705                 case Opt_iocharset:
1706                         string = match_strdup(args);
1707                         if (string == NULL)
1708                                 goto out_nomem;
1709
1710                         if (strnlen(string, 1024) >= 65) {
1711                                 printk(KERN_WARNING "CIFS: iocharset name "
1712                                                     "too long.\n");
1713                                 goto cifs_parse_mount_err;
1714                         }
1715
1716                          if (strnicmp(string, "default", 7) != 0) {
1717                                 vol->iocharset = kstrdup(string,
1718                                                          GFP_KERNEL);
1719                                 if (!vol->iocharset) {
1720                                         printk(KERN_WARNING "CIFS: no memory"
1721                                                             "for charset\n");
1722                                         goto cifs_parse_mount_err;
1723                                 }
1724                         }
1725                         /* if iocharset not set then load_nls_default
1726                          * is used by caller
1727                          */
1728                         cFYI(1, "iocharset set to %s", string);
1729                         break;
1730                 case Opt_sockopt:
1731                         string = match_strdup(args);
1732                         if (string == NULL)
1733                                 goto out_nomem;
1734
1735                         if (strnicmp(string, "TCP_NODELAY", 11) == 0) {
1736                                 printk(KERN_WARNING "CIFS: the "
1737                                         "sockopt=TCP_NODELAY option has been "
1738                                         "deprecated and will be removed "
1739                                         "in 3.9\n");
1740                                 vol->sockopt_tcp_nodelay = 1;
1741                         }
1742                         break;
1743                 case Opt_netbiosname:
1744                         string = match_strdup(args);
1745                         if (string == NULL)
1746                                 goto out_nomem;
1747
1748                         memset(vol->source_rfc1001_name, 0x20,
1749                                 RFC1001_NAME_LEN);
1750                         /*
1751                          * FIXME: are there cases in which a comma can
1752                          * be valid in workstation netbios name (and
1753                          * need special handling)?
1754                          */
1755                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
1756                                 /* don't ucase netbiosname for user */
1757                                 if (string[i] == 0)
1758                                         break;
1759                                 vol->source_rfc1001_name[i] = string[i];
1760                         }
1761                         /* The string has 16th byte zero still from
1762                          * set at top of the function
1763                          */
1764                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1765                                 printk(KERN_WARNING "CIFS: netbiosname"
1766                                        " longer than 15 truncated.\n");
1767
1768                         break;
1769                 case Opt_servern:
1770                         /* servernetbiosname specified override *SMBSERVER */
1771                         string = match_strdup(args);
1772                         if (string == NULL)
1773                                 goto out_nomem;
1774
1775                         /* last byte, type, is 0x20 for servr type */
1776                         memset(vol->target_rfc1001_name, 0x20,
1777                                 RFC1001_NAME_LEN_WITH_NULL);
1778
1779                         /* BB are there cases in which a comma can be
1780                            valid in this workstation netbios name
1781                            (and need special handling)? */
1782
1783                         /* user or mount helper must uppercase the
1784                            netbios name */
1785                         for (i = 0; i < 15; i++) {
1786                                 if (string[i] == 0)
1787                                         break;
1788                                 vol->target_rfc1001_name[i] = string[i];
1789                         }
1790                         /* The string has 16th byte zero still from
1791                            set at top of the function  */
1792                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1793                                 printk(KERN_WARNING "CIFS: server net"
1794                                        "biosname longer than 15 truncated.\n");
1795                         break;
1796                 case Opt_ver:
1797                         string = match_strdup(args);
1798                         if (string == NULL)
1799                                 goto out_nomem;
1800
1801                         if (strnicmp(string, "1", 1) == 0) {
1802                                 /* This is the default */
1803                                 break;
1804                         }
1805                         /* For all other value, error */
1806                         printk(KERN_WARNING "CIFS: Invalid version"
1807                                             " specified\n");
1808                         goto cifs_parse_mount_err;
1809                 case Opt_vers:
1810                         string = match_strdup(args);
1811                         if (string == NULL)
1812                                 goto out_nomem;
1813
1814                         if (cifs_parse_smb_version(string, vol) != 0)
1815                                 goto cifs_parse_mount_err;
1816                         break;
1817                 case Opt_sec:
1818                         string = match_strdup(args);
1819                         if (string == NULL)
1820                                 goto out_nomem;
1821
1822                         if (cifs_parse_security_flavors(string, vol) != 0)
1823                                 goto cifs_parse_mount_err;
1824                         break;
1825                 case Opt_cache:
1826                         string = match_strdup(args);
1827                         if (string == NULL)
1828                                 goto out_nomem;
1829
1830                         if (cifs_parse_cache_flavor(string, vol) != 0)
1831                                 goto cifs_parse_mount_err;
1832                         break;
1833                 default:
1834                         /*
1835                          * An option we don't recognize. Save it off for later
1836                          * if we haven't already found one
1837                          */
1838                         if (!invalid)
1839                                 invalid = data;
1840                         break;
1841                 }
1842                 /* Free up any allocated string */
1843                 kfree(string);
1844                 string = NULL;
1845         }
1846
1847         if (!sloppy && invalid) {
1848                 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1849                 goto cifs_parse_mount_err;
1850         }
1851
1852 #ifndef CONFIG_KEYS
1853         /* Muliuser mounts require CONFIG_KEYS support */
1854         if (vol->multiuser) {
1855                 cERROR(1, "Multiuser mounts require kernels with "
1856                           "CONFIG_KEYS enabled.");
1857                 goto cifs_parse_mount_err;
1858         }
1859 #endif
1860         if (!vol->UNC) {
1861                 cERROR(1, "CIFS mount error: No usable UNC path provided in "
1862                           "device string or in unc= option!");
1863                 goto cifs_parse_mount_err;
1864         }
1865
1866         /* make sure UNC has a share name */
1867         if (!strchr(vol->UNC + 3, '\\')) {
1868                 cERROR(1, "Malformed UNC. Unable to find share name.");
1869                 goto cifs_parse_mount_err;
1870         }
1871
1872         if (!got_ip) {
1873                 /* No ip= option specified? Try to get it from UNC */
1874                 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1875                                                 strlen(&vol->UNC[2]))) {
1876                         printk(KERN_ERR "Unable to determine destination "
1877                                         "address.\n");
1878                         goto cifs_parse_mount_err;
1879                 }
1880         }
1881
1882         /* set the port that we got earlier */
1883         cifs_set_port(dstaddr, port);
1884
1885         if (uid_specified)
1886                 vol->override_uid = override_uid;
1887         else if (override_uid == 1)
1888                 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1889                                    "specified with no uid= option.\n");
1890
1891         if (gid_specified)
1892                 vol->override_gid = override_gid;
1893         else if (override_gid == 1)
1894                 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1895                                    "specified with no gid= option.\n");
1896
1897         kfree(mountdata_copy);
1898         return 0;
1899
1900 out_nomem:
1901         printk(KERN_WARNING "Could not allocate temporary buffer\n");
1902 cifs_parse_mount_err:
1903         kfree(string);
1904         kfree(mountdata_copy);
1905         return 1;
1906 }
1907
1908 /** Returns true if srcaddr isn't specified and rhs isn't
1909  * specified, or if srcaddr is specified and
1910  * matches the IP address of the rhs argument.
1911  */
1912 static bool
1913 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1914 {
1915         switch (srcaddr->sa_family) {
1916         case AF_UNSPEC:
1917                 return (rhs->sa_family == AF_UNSPEC);
1918         case AF_INET: {
1919                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1920                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1921                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1922         }
1923         case AF_INET6: {
1924                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1925                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1926                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1927         }
1928         default:
1929                 WARN_ON(1);
1930                 return false; /* don't expect to be here */
1931         }
1932 }
1933
1934 /*
1935  * If no port is specified in addr structure, we try to match with 445 port
1936  * and if it fails - with 139 ports. It should be called only if address
1937  * families of server and addr are equal.
1938  */
1939 static bool
1940 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1941 {
1942         __be16 port, *sport;
1943
1944         switch (addr->sa_family) {
1945         case AF_INET:
1946                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1947                 port = ((struct sockaddr_in *) addr)->sin_port;
1948                 break;
1949         case AF_INET6:
1950                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1951                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1952                 break;
1953         default:
1954                 WARN_ON(1);
1955                 return false;
1956         }
1957
1958         if (!port) {
1959                 port = htons(CIFS_PORT);
1960                 if (port == *sport)
1961                         return true;
1962
1963                 port = htons(RFC1001_PORT);
1964         }
1965
1966         return port == *sport;
1967 }
1968
1969 static bool
1970 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1971               struct sockaddr *srcaddr)
1972 {
1973         switch (addr->sa_family) {
1974         case AF_INET: {
1975                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1976                 struct sockaddr_in *srv_addr4 =
1977                                         (struct sockaddr_in *)&server->dstaddr;
1978
1979                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1980                         return false;
1981                 break;
1982         }
1983         case AF_INET6: {
1984                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1985                 struct sockaddr_in6 *srv_addr6 =
1986                                         (struct sockaddr_in6 *)&server->dstaddr;
1987
1988                 if (!ipv6_addr_equal(&addr6->sin6_addr,
1989                                      &srv_addr6->sin6_addr))
1990                         return false;
1991                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1992                         return false;
1993                 break;
1994         }
1995         default:
1996                 WARN_ON(1);
1997                 return false; /* don't expect to be here */
1998         }
1999
2000         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2001                 return false;
2002
2003         return true;
2004 }
2005
2006 static bool
2007 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2008 {
2009         unsigned int secFlags;
2010
2011         if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2012                 secFlags = vol->secFlg;
2013         else
2014                 secFlags = global_secflags | vol->secFlg;
2015
2016         switch (server->secType) {
2017         case LANMAN:
2018                 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2019                         return false;
2020                 break;
2021         case NTLMv2:
2022                 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2023                         return false;
2024                 break;
2025         case NTLM:
2026                 if (!(secFlags & CIFSSEC_MAY_NTLM))
2027                         return false;
2028                 break;
2029         case Kerberos:
2030                 if (!(secFlags & CIFSSEC_MAY_KRB5))
2031                         return false;
2032                 break;
2033         case RawNTLMSSP:
2034                 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2035                         return false;
2036                 break;
2037         default:
2038                 /* shouldn't happen */
2039                 return false;
2040         }
2041
2042         /* now check if signing mode is acceptable */
2043         if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2044             (server->sec_mode & SECMODE_SIGN_REQUIRED))
2045                         return false;
2046         else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2047                  (server->sec_mode &
2048                   (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2049                         return false;
2050
2051         return true;
2052 }
2053
2054 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2055 {
2056         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2057
2058         if ((server->vals != vol->vals) || (server->ops != vol->ops))
2059                 return 0;
2060
2061         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2062                 return 0;
2063
2064         if (!match_address(server, addr,
2065                            (struct sockaddr *)&vol->srcaddr))
2066                 return 0;
2067
2068         if (!match_port(server, addr))
2069                 return 0;
2070
2071         if (!match_security(server, vol))
2072                 return 0;
2073
2074         return 1;
2075 }
2076
2077 static struct TCP_Server_Info *
2078 cifs_find_tcp_session(struct smb_vol *vol)
2079 {
2080         struct TCP_Server_Info *server;
2081
2082         spin_lock(&cifs_tcp_ses_lock);
2083         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2084                 if (!match_server(server, vol))
2085                         continue;
2086
2087                 ++server->srv_count;
2088                 spin_unlock(&cifs_tcp_ses_lock);
2089                 cFYI(1, "Existing tcp session with server found");
2090                 return server;
2091         }
2092         spin_unlock(&cifs_tcp_ses_lock);
2093         return NULL;
2094 }
2095
2096 static void
2097 cifs_put_tcp_session(struct TCP_Server_Info *server)
2098 {
2099         struct task_struct *task;
2100
2101         spin_lock(&cifs_tcp_ses_lock);
2102         if (--server->srv_count > 0) {
2103                 spin_unlock(&cifs_tcp_ses_lock);
2104                 return;
2105         }
2106
2107         put_net(cifs_net_ns(server));
2108
2109         list_del_init(&server->tcp_ses_list);
2110         spin_unlock(&cifs_tcp_ses_lock);
2111
2112         cancel_delayed_work_sync(&server->echo);
2113
2114         spin_lock(&GlobalMid_Lock);
2115         server->tcpStatus = CifsExiting;
2116         spin_unlock(&GlobalMid_Lock);
2117
2118         cifs_crypto_shash_release(server);
2119         cifs_fscache_release_client_cookie(server);
2120
2121         kfree(server->session_key.response);
2122         server->session_key.response = NULL;
2123         server->session_key.len = 0;
2124
2125         task = xchg(&server->tsk, NULL);
2126         if (task)
2127                 force_sig(SIGKILL, task);
2128 }
2129
2130 static struct TCP_Server_Info *
2131 cifs_get_tcp_session(struct smb_vol *volume_info)
2132 {
2133         struct TCP_Server_Info *tcp_ses = NULL;
2134         int rc;
2135
2136         cFYI(1, "UNC: %s", volume_info->UNC);
2137
2138         /* see if we already have a matching tcp_ses */
2139         tcp_ses = cifs_find_tcp_session(volume_info);
2140         if (tcp_ses)
2141                 return tcp_ses;
2142
2143         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2144         if (!tcp_ses) {
2145                 rc = -ENOMEM;
2146                 goto out_err;
2147         }
2148
2149         rc = cifs_crypto_shash_allocate(tcp_ses);
2150         if (rc) {
2151                 cERROR(1, "could not setup hash structures rc %d", rc);
2152                 goto out_err;
2153         }
2154
2155         tcp_ses->ops = volume_info->ops;
2156         tcp_ses->vals = volume_info->vals;
2157         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2158         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2159         if (IS_ERR(tcp_ses->hostname)) {
2160                 rc = PTR_ERR(tcp_ses->hostname);
2161                 goto out_err_crypto_release;
2162         }
2163
2164         tcp_ses->noblocksnd = volume_info->noblocksnd;
2165         tcp_ses->noautotune = volume_info->noautotune;
2166         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2167         tcp_ses->in_flight = 0;
2168         tcp_ses->credits = 1;
2169         init_waitqueue_head(&tcp_ses->response_q);
2170         init_waitqueue_head(&tcp_ses->request_q);
2171         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2172         mutex_init(&tcp_ses->srv_mutex);
2173         memcpy(tcp_ses->workstation_RFC1001_name,
2174                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2175         memcpy(tcp_ses->server_RFC1001_name,
2176                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2177         tcp_ses->session_estab = false;
2178         tcp_ses->sequence_number = 0;
2179         tcp_ses->lstrp = jiffies;
2180         spin_lock_init(&tcp_ses->req_lock);
2181         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2182         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2183         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2184         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2185                sizeof(tcp_ses->srcaddr));
2186         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2187                 sizeof(tcp_ses->dstaddr));
2188         /*
2189          * at this point we are the only ones with the pointer
2190          * to the struct since the kernel thread not created yet
2191          * no need to spinlock this init of tcpStatus or srv_count
2192          */
2193         tcp_ses->tcpStatus = CifsNew;
2194         ++tcp_ses->srv_count;
2195
2196         rc = ip_connect(tcp_ses);
2197         if (rc < 0) {
2198                 cERROR(1, "Error connecting to socket. Aborting operation");
2199                 goto out_err_crypto_release;
2200         }
2201
2202         /*
2203          * since we're in a cifs function already, we know that
2204          * this will succeed. No need for try_module_get().
2205          */
2206         __module_get(THIS_MODULE);
2207         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2208                                   tcp_ses, "cifsd");
2209         if (IS_ERR(tcp_ses->tsk)) {
2210                 rc = PTR_ERR(tcp_ses->tsk);
2211                 cERROR(1, "error %d create cifsd thread", rc);
2212                 module_put(THIS_MODULE);
2213                 goto out_err_crypto_release;
2214         }
2215         tcp_ses->tcpStatus = CifsNeedNegotiate;
2216
2217         /* thread spawned, put it on the list */
2218         spin_lock(&cifs_tcp_ses_lock);
2219         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2220         spin_unlock(&cifs_tcp_ses_lock);
2221
2222         cifs_fscache_get_client_cookie(tcp_ses);
2223
2224         /* queue echo request delayed work */
2225         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2226
2227         return tcp_ses;
2228
2229 out_err_crypto_release:
2230         cifs_crypto_shash_release(tcp_ses);
2231
2232         put_net(cifs_net_ns(tcp_ses));
2233
2234 out_err:
2235         if (tcp_ses) {
2236                 if (!IS_ERR(tcp_ses->hostname))
2237                         kfree(tcp_ses->hostname);
2238                 if (tcp_ses->ssocket)
2239                         sock_release(tcp_ses->ssocket);
2240                 kfree(tcp_ses);
2241         }
2242         return ERR_PTR(rc);
2243 }
2244
2245 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2246 {
2247         switch (ses->server->secType) {
2248         case Kerberos:
2249                 if (vol->cred_uid != ses->cred_uid)
2250                         return 0;
2251                 break;
2252         default:
2253                 /* NULL username means anonymous session */
2254                 if (ses->user_name == NULL) {
2255                         if (!vol->nullauth)
2256                                 return 0;
2257                         break;
2258                 }
2259
2260                 /* anything else takes username/password */
2261                 if (strncmp(ses->user_name,
2262                             vol->username ? vol->username : "",
2263                             MAX_USERNAME_SIZE))
2264                         return 0;
2265                 if (strlen(vol->username) != 0 &&
2266                     ses->password != NULL &&
2267                     strncmp(ses->password,
2268                             vol->password ? vol->password : "",
2269                             MAX_PASSWORD_SIZE))
2270                         return 0;
2271         }
2272         return 1;
2273 }
2274
2275 static struct cifs_ses *
2276 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2277 {
2278         struct cifs_ses *ses;
2279
2280         spin_lock(&cifs_tcp_ses_lock);
2281         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2282                 if (!match_session(ses, vol))
2283                         continue;
2284                 ++ses->ses_count;
2285                 spin_unlock(&cifs_tcp_ses_lock);
2286                 return ses;
2287         }
2288         spin_unlock(&cifs_tcp_ses_lock);
2289         return NULL;
2290 }
2291
2292 static void
2293 cifs_put_smb_ses(struct cifs_ses *ses)
2294 {
2295         unsigned int xid;
2296         struct TCP_Server_Info *server = ses->server;
2297
2298         cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
2299         spin_lock(&cifs_tcp_ses_lock);
2300         if (--ses->ses_count > 0) {
2301                 spin_unlock(&cifs_tcp_ses_lock);
2302                 return;
2303         }
2304
2305         list_del_init(&ses->smb_ses_list);
2306         spin_unlock(&cifs_tcp_ses_lock);
2307
2308         if (ses->status == CifsGood && server->ops->logoff) {
2309                 xid = get_xid();
2310                 server->ops->logoff(xid, ses);
2311                 _free_xid(xid);
2312         }
2313         sesInfoFree(ses);
2314         cifs_put_tcp_session(server);
2315 }
2316
2317 #ifdef CONFIG_KEYS
2318
2319 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2320 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2321
2322 /* Populate username and pw fields from keyring if possible */
2323 static int
2324 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2325 {
2326         int rc = 0;
2327         char *desc, *delim, *payload;
2328         ssize_t len;
2329         struct key *key;
2330         struct TCP_Server_Info *server = ses->server;
2331         struct sockaddr_in *sa;
2332         struct sockaddr_in6 *sa6;
2333         struct user_key_payload *upayload;
2334
2335         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2336         if (!desc)
2337                 return -ENOMEM;
2338
2339         /* try to find an address key first */
2340         switch (server->dstaddr.ss_family) {
2341         case AF_INET:
2342                 sa = (struct sockaddr_in *)&server->dstaddr;
2343                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2344                 break;
2345         case AF_INET6:
2346                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2347                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2348                 break;
2349         default:
2350                 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2351                 rc = -EINVAL;
2352                 goto out_err;
2353         }
2354
2355         cFYI(1, "%s: desc=%s", __func__, desc);
2356         key = request_key(&key_type_logon, desc, "");
2357         if (IS_ERR(key)) {
2358                 if (!ses->domainName) {
2359                         cFYI(1, "domainName is NULL");
2360                         rc = PTR_ERR(key);
2361                         goto out_err;
2362                 }
2363
2364                 /* didn't work, try to find a domain key */
2365                 sprintf(desc, "cifs:d:%s", ses->domainName);
2366                 cFYI(1, "%s: desc=%s", __func__, desc);
2367                 key = request_key(&key_type_logon, desc, "");
2368                 if (IS_ERR(key)) {
2369                         rc = PTR_ERR(key);
2370                         goto out_err;
2371                 }
2372         }
2373
2374         down_read(&key->sem);
2375         upayload = key->payload.data;
2376         if (IS_ERR_OR_NULL(upayload)) {
2377                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2378                 goto out_key_put;
2379         }
2380
2381         /* find first : in payload */
2382         payload = (char *)upayload->data;
2383         delim = strnchr(payload, upayload->datalen, ':');
2384         cFYI(1, "payload=%s", payload);
2385         if (!delim) {
2386                 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2387                                 upayload->datalen);
2388                 rc = -EINVAL;
2389                 goto out_key_put;
2390         }
2391
2392         len = delim - payload;
2393         if (len > MAX_USERNAME_SIZE || len <= 0) {
2394                 cFYI(1, "Bad value from username search (len=%zd)", len);
2395                 rc = -EINVAL;
2396                 goto out_key_put;
2397         }
2398
2399         vol->username = kstrndup(payload, len, GFP_KERNEL);
2400         if (!vol->username) {
2401                 cFYI(1, "Unable to allocate %zd bytes for username", len);
2402                 rc = -ENOMEM;
2403                 goto out_key_put;
2404         }
2405         cFYI(1, "%s: username=%s", __func__, vol->username);
2406
2407         len = key->datalen - (len + 1);
2408         if (len > MAX_PASSWORD_SIZE || len <= 0) {
2409                 cFYI(1, "Bad len for password search (len=%zd)", len);
2410                 rc = -EINVAL;
2411                 kfree(vol->username);
2412                 vol->username = NULL;
2413                 goto out_key_put;
2414         }
2415
2416         ++delim;
2417         vol->password = kstrndup(delim, len, GFP_KERNEL);
2418         if (!vol->password) {
2419                 cFYI(1, "Unable to allocate %zd bytes for password", len);
2420                 rc = -ENOMEM;
2421                 kfree(vol->username);
2422                 vol->username = NULL;
2423                 goto out_key_put;
2424         }
2425
2426 out_key_put:
2427         up_read(&key->sem);
2428         key_put(key);
2429 out_err:
2430         kfree(desc);
2431         cFYI(1, "%s: returning %d", __func__, rc);
2432         return rc;
2433 }
2434 #else /* ! CONFIG_KEYS */
2435 static inline int
2436 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2437                    struct cifs_ses *ses __attribute__((unused)))
2438 {
2439         return -ENOSYS;
2440 }
2441 #endif /* CONFIG_KEYS */
2442
2443 static struct cifs_ses *
2444 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2445 {
2446         int rc = -ENOMEM;
2447         unsigned int xid;
2448         struct cifs_ses *ses;
2449         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2450         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2451
2452         xid = get_xid();
2453
2454         ses = cifs_find_smb_ses(server, volume_info);
2455         if (ses) {
2456                 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2457
2458                 mutex_lock(&ses->session_mutex);
2459                 rc = cifs_negotiate_protocol(xid, ses);
2460                 if (rc) {
2461                         mutex_unlock(&ses->session_mutex);
2462                         /* problem -- put our ses reference */
2463                         cifs_put_smb_ses(ses);
2464                         free_xid(xid);
2465                         return ERR_PTR(rc);
2466                 }
2467                 if (ses->need_reconnect) {
2468                         cFYI(1, "Session needs reconnect");
2469                         rc = cifs_setup_session(xid, ses,
2470                                                 volume_info->local_nls);
2471                         if (rc) {
2472                                 mutex_unlock(&ses->session_mutex);
2473                                 /* problem -- put our reference */
2474                                 cifs_put_smb_ses(ses);
2475                                 free_xid(xid);
2476                                 return ERR_PTR(rc);
2477                         }
2478                 }
2479                 mutex_unlock(&ses->session_mutex);
2480
2481                 /* existing SMB ses has a server reference already */
2482                 cifs_put_tcp_session(server);
2483                 free_xid(xid);
2484                 return ses;
2485         }
2486
2487         cFYI(1, "Existing smb sess not found");
2488         ses = sesInfoAlloc();
2489         if (ses == NULL)
2490                 goto get_ses_fail;
2491
2492         /* new SMB session uses our server ref */
2493         ses->server = server;
2494         if (server->dstaddr.ss_family == AF_INET6)
2495                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2496         else
2497                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2498
2499         if (volume_info->username) {
2500                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2501                 if (!ses->user_name)
2502                         goto get_ses_fail;
2503         }
2504
2505         /* volume_info->password freed at unmount */
2506         if (volume_info->password) {
2507                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2508                 if (!ses->password)
2509                         goto get_ses_fail;
2510         }
2511         if (volume_info->domainname) {
2512                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2513                 if (!ses->domainName)
2514                         goto get_ses_fail;
2515         }
2516         ses->cred_uid = volume_info->cred_uid;
2517         ses->linux_uid = volume_info->linux_uid;
2518
2519         ses->overrideSecFlg = volume_info->secFlg;
2520
2521         mutex_lock(&ses->session_mutex);
2522         rc = cifs_negotiate_protocol(xid, ses);
2523         if (!rc)
2524                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2525         mutex_unlock(&ses->session_mutex);
2526         if (rc)
2527                 goto get_ses_fail;
2528
2529         /* success, put it on the list */
2530         spin_lock(&cifs_tcp_ses_lock);
2531         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2532         spin_unlock(&cifs_tcp_ses_lock);
2533
2534         free_xid(xid);
2535         return ses;
2536
2537 get_ses_fail:
2538         sesInfoFree(ses);
2539         free_xid(xid);
2540         return ERR_PTR(rc);
2541 }
2542
2543 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2544 {
2545         if (tcon->tidStatus == CifsExiting)
2546                 return 0;
2547         if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2548                 return 0;
2549         return 1;
2550 }
2551
2552 static struct cifs_tcon *
2553 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2554 {
2555         struct list_head *tmp;
2556         struct cifs_tcon *tcon;
2557
2558         spin_lock(&cifs_tcp_ses_lock);
2559         list_for_each(tmp, &ses->tcon_list) {
2560                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2561                 if (!match_tcon(tcon, unc))
2562                         continue;
2563                 ++tcon->tc_count;
2564                 spin_unlock(&cifs_tcp_ses_lock);
2565                 return tcon;
2566         }
2567         spin_unlock(&cifs_tcp_ses_lock);
2568         return NULL;
2569 }
2570
2571 static void
2572 cifs_put_tcon(struct cifs_tcon *tcon)
2573 {
2574         unsigned int xid;
2575         struct cifs_ses *ses = tcon->ses;
2576
2577         cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
2578         spin_lock(&cifs_tcp_ses_lock);
2579         if (--tcon->tc_count > 0) {
2580                 spin_unlock(&cifs_tcp_ses_lock);
2581                 return;
2582         }
2583
2584         list_del_init(&tcon->tcon_list);
2585         spin_unlock(&cifs_tcp_ses_lock);
2586
2587         xid = get_xid();
2588         if (ses->server->ops->tree_disconnect)
2589                 ses->server->ops->tree_disconnect(xid, tcon);
2590         _free_xid(xid);
2591
2592         cifs_fscache_release_super_cookie(tcon);
2593         tconInfoFree(tcon);
2594         cifs_put_smb_ses(ses);
2595 }
2596
2597 static struct cifs_tcon *
2598 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2599 {
2600         int rc, xid;
2601         struct cifs_tcon *tcon;
2602
2603         tcon = cifs_find_tcon(ses, volume_info->UNC);
2604         if (tcon) {
2605                 cFYI(1, "Found match on UNC path");
2606                 /* existing tcon already has a reference */
2607                 cifs_put_smb_ses(ses);
2608                 if (tcon->seal != volume_info->seal)
2609                         cERROR(1, "transport encryption setting "
2610                                    "conflicts with existing tid");
2611                 return tcon;
2612         }
2613
2614         if (!ses->server->ops->tree_connect) {
2615                 rc = -ENOSYS;
2616                 goto out_fail;
2617         }
2618
2619         tcon = tconInfoAlloc();
2620         if (tcon == NULL) {
2621                 rc = -ENOMEM;
2622                 goto out_fail;
2623         }
2624
2625         tcon->ses = ses;
2626         if (volume_info->password) {
2627                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2628                 if (!tcon->password) {
2629                         rc = -ENOMEM;
2630                         goto out_fail;
2631                 }
2632         }
2633
2634         /*
2635          * BB Do we need to wrap session_mutex around this TCon call and Unix
2636          * SetFS as we do on SessSetup and reconnect?
2637          */
2638         xid = get_xid();
2639         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2640                                             volume_info->local_nls);
2641         free_xid(xid);
2642         cFYI(1, "Tcon rc = %d", rc);
2643         if (rc)
2644                 goto out_fail;
2645
2646         if (volume_info->nodfs) {
2647                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2648                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2649         }
2650         tcon->seal = volume_info->seal;
2651         /*
2652          * We can have only one retry value for a connection to a share so for
2653          * resources mounted more than once to the same server share the last
2654          * value passed in for the retry flag is used.
2655          */
2656         tcon->retry = volume_info->retry;
2657         tcon->nocase = volume_info->nocase;
2658         tcon->local_lease = volume_info->local_lease;
2659         INIT_LIST_HEAD(&tcon->pending_opens);
2660
2661         spin_lock(&cifs_tcp_ses_lock);
2662         list_add(&tcon->tcon_list, &ses->tcon_list);
2663         spin_unlock(&cifs_tcp_ses_lock);
2664
2665         cifs_fscache_get_super_cookie(tcon);
2666
2667         return tcon;
2668
2669 out_fail:
2670         tconInfoFree(tcon);
2671         return ERR_PTR(rc);
2672 }
2673
2674 void
2675 cifs_put_tlink(struct tcon_link *tlink)
2676 {
2677         if (!tlink || IS_ERR(tlink))
2678                 return;
2679
2680         if (!atomic_dec_and_test(&tlink->tl_count) ||
2681             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2682                 tlink->tl_time = jiffies;
2683                 return;
2684         }
2685
2686         if (!IS_ERR(tlink_tcon(tlink)))
2687                 cifs_put_tcon(tlink_tcon(tlink));
2688         kfree(tlink);
2689         return;
2690 }
2691
2692 static inline struct tcon_link *
2693 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2694 {
2695         return cifs_sb->master_tlink;
2696 }
2697
2698 static int
2699 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2700 {
2701         struct cifs_sb_info *old = CIFS_SB(sb);
2702         struct cifs_sb_info *new = mnt_data->cifs_sb;
2703
2704         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2705                 return 0;
2706
2707         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2708             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2709                 return 0;
2710
2711         /*
2712          * We want to share sb only if we don't specify an r/wsize or
2713          * specified r/wsize is greater than or equal to existing one.
2714          */
2715         if (new->wsize && new->wsize < old->wsize)
2716                 return 0;
2717
2718         if (new->rsize && new->rsize < old->rsize)
2719                 return 0;
2720
2721         if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2722                 return 0;
2723
2724         if (old->mnt_file_mode != new->mnt_file_mode ||
2725             old->mnt_dir_mode != new->mnt_dir_mode)
2726                 return 0;
2727
2728         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2729                 return 0;
2730
2731         if (old->actimeo != new->actimeo)
2732                 return 0;
2733
2734         return 1;
2735 }
2736
2737 int
2738 cifs_match_super(struct super_block *sb, void *data)
2739 {
2740         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2741         struct smb_vol *volume_info;
2742         struct cifs_sb_info *cifs_sb;
2743         struct TCP_Server_Info *tcp_srv;
2744         struct cifs_ses *ses;
2745         struct cifs_tcon *tcon;
2746         struct tcon_link *tlink;
2747         int rc = 0;
2748
2749         spin_lock(&cifs_tcp_ses_lock);
2750         cifs_sb = CIFS_SB(sb);
2751         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2752         if (IS_ERR(tlink)) {
2753                 spin_unlock(&cifs_tcp_ses_lock);
2754                 return rc;
2755         }
2756         tcon = tlink_tcon(tlink);
2757         ses = tcon->ses;
2758         tcp_srv = ses->server;
2759
2760         volume_info = mnt_data->vol;
2761
2762         if (!match_server(tcp_srv, volume_info) ||
2763             !match_session(ses, volume_info) ||
2764             !match_tcon(tcon, volume_info->UNC)) {
2765                 rc = 0;
2766                 goto out;
2767         }
2768
2769         rc = compare_mount_options(sb, mnt_data);
2770 out:
2771         spin_unlock(&cifs_tcp_ses_lock);
2772         cifs_put_tlink(tlink);
2773         return rc;
2774 }
2775
2776 int
2777 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2778              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2779              struct dfs_info3_param **referrals, int remap)
2780 {
2781         char *temp_unc;
2782         int rc = 0;
2783
2784         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2785                 return -ENOSYS;
2786
2787         *num_referrals = 0;
2788         *referrals = NULL;
2789
2790         if (ses->ipc_tid == 0) {
2791                 temp_unc = kmalloc(2 /* for slashes */ +
2792                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2793                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2794                 if (temp_unc == NULL)
2795                         return -ENOMEM;
2796                 temp_unc[0] = '\\';
2797                 temp_unc[1] = '\\';
2798                 strcpy(temp_unc + 2, ses->serverName);
2799                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2800                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2801                                                     nls_codepage);
2802                 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
2803                 kfree(temp_unc);
2804         }
2805         if (rc == 0)
2806                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2807                                                      referrals, num_referrals,
2808                                                      nls_codepage, remap);
2809         /*
2810          * BB - map targetUNCs to dfs_info3 structures, here or in
2811          * ses->server->ops->get_dfs_refer.
2812          */
2813
2814         return rc;
2815 }
2816
2817 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2818 static struct lock_class_key cifs_key[2];
2819 static struct lock_class_key cifs_slock_key[2];
2820
2821 static inline void
2822 cifs_reclassify_socket4(struct socket *sock)
2823 {
2824         struct sock *sk = sock->sk;
2825         BUG_ON(sock_owned_by_user(sk));
2826         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2827                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2828 }
2829
2830 static inline void
2831 cifs_reclassify_socket6(struct socket *sock)
2832 {
2833         struct sock *sk = sock->sk;
2834         BUG_ON(sock_owned_by_user(sk));
2835         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2836                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2837 }
2838 #else
2839 static inline void
2840 cifs_reclassify_socket4(struct socket *sock)
2841 {
2842 }
2843
2844 static inline void
2845 cifs_reclassify_socket6(struct socket *sock)
2846 {
2847 }
2848 #endif
2849
2850 /* See RFC1001 section 14 on representation of Netbios names */
2851 static void rfc1002mangle(char *target, char *source, unsigned int length)
2852 {
2853         unsigned int i, j;
2854
2855         for (i = 0, j = 0; i < (length); i++) {
2856                 /* mask a nibble at a time and encode */
2857                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2858                 target[j+1] = 'A' + (0x0F & source[i]);
2859                 j += 2;
2860         }
2861
2862 }
2863
2864 static int
2865 bind_socket(struct TCP_Server_Info *server)
2866 {
2867         int rc = 0;
2868         if (server->srcaddr.ss_family != AF_UNSPEC) {
2869                 /* Bind to the specified local IP address */
2870                 struct socket *socket = server->ssocket;
2871                 rc = socket->ops->bind(socket,
2872                                        (struct sockaddr *) &server->srcaddr,
2873                                        sizeof(server->srcaddr));
2874                 if (rc < 0) {
2875                         struct sockaddr_in *saddr4;
2876                         struct sockaddr_in6 *saddr6;
2877                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2878                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2879                         if (saddr6->sin6_family == AF_INET6)
2880                                 cERROR(1, "cifs: "
2881                                        "Failed to bind to: %pI6c, error: %d",
2882                                        &saddr6->sin6_addr, rc);
2883                         else
2884                                 cERROR(1, "cifs: "
2885                                        "Failed to bind to: %pI4, error: %d",
2886                                        &saddr4->sin_addr.s_addr, rc);
2887                 }
2888         }
2889         return rc;
2890 }
2891
2892 static int
2893 ip_rfc1001_connect(struct TCP_Server_Info *server)
2894 {
2895         int rc = 0;
2896         /*
2897          * some servers require RFC1001 sessinit before sending
2898          * negprot - BB check reconnection in case where second
2899          * sessinit is sent but no second negprot
2900          */
2901         struct rfc1002_session_packet *ses_init_buf;
2902         struct smb_hdr *smb_buf;
2903         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2904                                GFP_KERNEL);
2905         if (ses_init_buf) {
2906                 ses_init_buf->trailer.session_req.called_len = 32;
2907
2908                 if (server->server_RFC1001_name &&
2909                     server->server_RFC1001_name[0] != 0)
2910                         rfc1002mangle(ses_init_buf->trailer.
2911                                       session_req.called_name,
2912                                       server->server_RFC1001_name,
2913                                       RFC1001_NAME_LEN_WITH_NULL);
2914                 else
2915                         rfc1002mangle(ses_init_buf->trailer.
2916                                       session_req.called_name,
2917                                       DEFAULT_CIFS_CALLED_NAME,
2918                                       RFC1001_NAME_LEN_WITH_NULL);
2919
2920                 ses_init_buf->trailer.session_req.calling_len = 32;
2921
2922                 /*
2923                  * calling name ends in null (byte 16) from old smb
2924                  * convention.
2925                  */
2926                 if (server->workstation_RFC1001_name &&
2927                     server->workstation_RFC1001_name[0] != 0)
2928                         rfc1002mangle(ses_init_buf->trailer.
2929                                       session_req.calling_name,
2930                                       server->workstation_RFC1001_name,
2931                                       RFC1001_NAME_LEN_WITH_NULL);
2932                 else
2933                         rfc1002mangle(ses_init_buf->trailer.
2934                                       session_req.calling_name,
2935                                       "LINUX_CIFS_CLNT",
2936                                       RFC1001_NAME_LEN_WITH_NULL);
2937
2938                 ses_init_buf->trailer.session_req.scope1 = 0;
2939                 ses_init_buf->trailer.session_req.scope2 = 0;
2940                 smb_buf = (struct smb_hdr *)ses_init_buf;
2941
2942                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2943                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2944                 rc = smb_send(server, smb_buf, 0x44);
2945                 kfree(ses_init_buf);
2946                 /*
2947                  * RFC1001 layer in at least one server
2948                  * requires very short break before negprot
2949                  * presumably because not expecting negprot
2950                  * to follow so fast.  This is a simple
2951                  * solution that works without
2952                  * complicating the code and causes no
2953                  * significant slowing down on mount
2954                  * for everyone else
2955                  */
2956                 usleep_range(1000, 2000);
2957         }
2958         /*
2959          * else the negprot may still work without this
2960          * even though malloc failed
2961          */
2962
2963         return rc;
2964 }
2965
2966 static int
2967 generic_ip_connect(struct TCP_Server_Info *server)
2968 {
2969         int rc = 0;
2970         __be16 sport;
2971         int slen, sfamily;
2972         struct socket *socket = server->ssocket;
2973         struct sockaddr *saddr;
2974
2975         saddr = (struct sockaddr *) &server->dstaddr;
2976
2977         if (server->dstaddr.ss_family == AF_INET6) {
2978                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2979                 slen = sizeof(struct sockaddr_in6);
2980                 sfamily = AF_INET6;
2981         } else {
2982                 sport = ((struct sockaddr_in *) saddr)->sin_port;
2983                 slen = sizeof(struct sockaddr_in);
2984                 sfamily = AF_INET;
2985         }
2986
2987         if (socket == NULL) {
2988                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2989                                    IPPROTO_TCP, &socket, 1);
2990                 if (rc < 0) {
2991                         cERROR(1, "Error %d creating socket", rc);
2992                         server->ssocket = NULL;
2993                         return rc;
2994                 }
2995
2996                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2997                 cFYI(1, "Socket created");
2998                 server->ssocket = socket;
2999                 socket->sk->sk_allocation = GFP_NOFS;
3000                 if (sfamily == AF_INET6)
3001                         cifs_reclassify_socket6(socket);
3002                 else
3003                         cifs_reclassify_socket4(socket);
3004         }
3005
3006         rc = bind_socket(server);
3007         if (rc < 0)
3008                 return rc;
3009
3010         /*
3011          * Eventually check for other socket options to change from
3012          * the default. sock_setsockopt not used because it expects
3013          * user space buffer
3014          */
3015         socket->sk->sk_rcvtimeo = 7 * HZ;
3016         socket->sk->sk_sndtimeo = 5 * HZ;
3017
3018         /* make the bufsizes depend on wsize/rsize and max requests */
3019         if (server->noautotune) {
3020                 if (socket->sk->sk_sndbuf < (200 * 1024))
3021                         socket->sk->sk_sndbuf = 200 * 1024;
3022                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3023                         socket->sk->sk_rcvbuf = 140 * 1024;
3024         }
3025
3026         if (server->tcp_nodelay) {
3027                 int val = 1;
3028                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3029                                 (char *)&val, sizeof(val));
3030                 if (rc)
3031                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3032         }
3033
3034          cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3035                  socket->sk->sk_sndbuf,
3036                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3037
3038         rc = socket->ops->connect(socket, saddr, slen, 0);
3039         if (rc < 0) {
3040                 cFYI(1, "Error %d connecting to server", rc);
3041                 sock_release(socket);
3042                 server->ssocket = NULL;
3043                 return rc;
3044         }
3045
3046         if (sport == htons(RFC1001_PORT))
3047                 rc = ip_rfc1001_connect(server);
3048
3049         return rc;
3050 }
3051
3052 static int
3053 ip_connect(struct TCP_Server_Info *server)
3054 {
3055         __be16 *sport;
3056         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3057         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3058
3059         if (server->dstaddr.ss_family == AF_INET6)
3060                 sport = &addr6->sin6_port;
3061         else
3062                 sport = &addr->sin_port;
3063
3064         if (*sport == 0) {
3065                 int rc;
3066
3067                 /* try with 445 port at first */
3068                 *sport = htons(CIFS_PORT);
3069
3070                 rc = generic_ip_connect(server);
3071                 if (rc >= 0)
3072                         return rc;
3073
3074                 /* if it failed, try with 139 port */
3075                 *sport = htons(RFC1001_PORT);
3076         }
3077
3078         return generic_ip_connect(server);
3079 }
3080
3081 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3082                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3083 {
3084         /* if we are reconnecting then should we check to see if
3085          * any requested capabilities changed locally e.g. via
3086          * remount but we can not do much about it here
3087          * if they have (even if we could detect it by the following)
3088          * Perhaps we could add a backpointer to array of sb from tcon
3089          * or if we change to make all sb to same share the same
3090          * sb as NFS - then we only have one backpointer to sb.
3091          * What if we wanted to mount the server share twice once with
3092          * and once without posixacls or posix paths? */
3093         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3094
3095         if (vol_info && vol_info->no_linux_ext) {
3096                 tcon->fsUnixInfo.Capability = 0;
3097                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3098                 cFYI(1, "Linux protocol extensions disabled");
3099                 return;
3100         } else if (vol_info)
3101                 tcon->unix_ext = 1; /* Unix Extensions supported */
3102
3103         if (tcon->unix_ext == 0) {
3104                 cFYI(1, "Unix extensions disabled so not set on reconnect");
3105                 return;
3106         }
3107
3108         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3109                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3110                 cFYI(1, "unix caps which server supports %lld", cap);
3111                 /* check for reconnect case in which we do not
3112                    want to change the mount behavior if we can avoid it */
3113                 if (vol_info == NULL) {
3114                         /* turn off POSIX ACL and PATHNAMES if not set
3115                            originally at mount time */
3116                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3117                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3118                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3119                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3120                                         cERROR(1, "POSIXPATH support change");
3121                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3122                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3123                                 cERROR(1, "possible reconnect error");
3124                                 cERROR(1, "server disabled POSIX path support");
3125                         }
3126                 }
3127
3128                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3129                         cERROR(1, "per-share encryption not supported yet");
3130
3131                 cap &= CIFS_UNIX_CAP_MASK;
3132                 if (vol_info && vol_info->no_psx_acl)
3133                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3134                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3135                         cFYI(1, "negotiated posix acl support");
3136                         if (cifs_sb)
3137                                 cifs_sb->mnt_cifs_flags |=
3138                                         CIFS_MOUNT_POSIXACL;
3139                 }
3140
3141                 if (vol_info && vol_info->posix_paths == 0)
3142                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3143                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3144                         cFYI(1, "negotiate posix pathnames");
3145                         if (cifs_sb)
3146                                 cifs_sb->mnt_cifs_flags |=
3147                                         CIFS_MOUNT_POSIX_PATHS;
3148                 }
3149
3150                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3151 #ifdef CONFIG_CIFS_DEBUG2
3152                 if (cap & CIFS_UNIX_FCNTL_CAP)
3153                         cFYI(1, "FCNTL cap");
3154                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3155                         cFYI(1, "EXTATTR cap");
3156                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3157                         cFYI(1, "POSIX path cap");
3158                 if (cap & CIFS_UNIX_XATTR_CAP)
3159                         cFYI(1, "XATTR cap");
3160                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3161                         cFYI(1, "POSIX ACL cap");
3162                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3163                         cFYI(1, "very large read cap");
3164                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3165                         cFYI(1, "very large write cap");
3166                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3167                         cFYI(1, "transport encryption cap");
3168                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3169                         cFYI(1, "mandatory transport encryption cap");
3170 #endif /* CIFS_DEBUG2 */
3171                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3172                         if (vol_info == NULL) {
3173                                 cFYI(1, "resetting capabilities failed");
3174                         } else
3175                                 cERROR(1, "Negotiating Unix capabilities "
3176                                            "with the server failed. Consider "
3177                                            "mounting with the Unix Extensions "
3178                                            "disabled if problems are found "
3179                                            "by specifying the nounix mount "
3180                                            "option.");
3181
3182                 }
3183         }
3184 }
3185
3186 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3187                         struct cifs_sb_info *cifs_sb)
3188 {
3189         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3190
3191         spin_lock_init(&cifs_sb->tlink_tree_lock);
3192         cifs_sb->tlink_tree = RB_ROOT;
3193
3194         /*
3195          * Temporarily set r/wsize for matching superblock. If we end up using
3196          * new sb then client will later negotiate it downward if needed.
3197          */
3198         cifs_sb->rsize = pvolume_info->rsize;
3199         cifs_sb->wsize = pvolume_info->wsize;
3200
3201         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3202         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3203         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3204         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3205         cFYI(1, "file mode: 0x%hx  dir mode: 0x%hx",
3206                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3207
3208         cifs_sb->actimeo = pvolume_info->actimeo;
3209         cifs_sb->local_nls = pvolume_info->local_nls;
3210
3211         if (pvolume_info->noperm)
3212                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3213         if (pvolume_info->setuids)
3214                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3215         if (pvolume_info->server_ino)
3216                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3217         if (pvolume_info->remap)
3218                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3219         if (pvolume_info->no_xattr)
3220                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3221         if (pvolume_info->sfu_emul)
3222                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3223         if (pvolume_info->nobrl)
3224                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3225         if (pvolume_info->nostrictsync)
3226                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3227         if (pvolume_info->mand_lock)
3228                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3229         if (pvolume_info->rwpidforward)
3230                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3231         if (pvolume_info->cifs_acl)
3232                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3233         if (pvolume_info->backupuid_specified) {
3234                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3235                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3236         }
3237         if (pvolume_info->backupgid_specified) {
3238                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3239                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3240         }
3241         if (pvolume_info->override_uid)
3242                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3243         if (pvolume_info->override_gid)
3244                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3245         if (pvolume_info->dynperm)
3246                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3247         if (pvolume_info->fsc)
3248                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3249         if (pvolume_info->multiuser)
3250                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3251                                             CIFS_MOUNT_NO_PERM);
3252         if (pvolume_info->strict_io)
3253                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3254         if (pvolume_info->direct_io) {
3255                 cFYI(1, "mounting share using direct i/o");
3256                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3257         }
3258         if (pvolume_info->mfsymlinks) {
3259                 if (pvolume_info->sfu_emul) {
3260                         cERROR(1,  "mount option mfsymlinks ignored if sfu "
3261                                    "mount option is used");
3262                 } else {
3263                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3264                 }
3265         }
3266
3267         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3268                 cERROR(1, "mount option dynperm ignored if cifsacl "
3269                            "mount option supported");
3270 }
3271
3272 static void
3273 cleanup_volume_info_contents(struct smb_vol *volume_info)
3274 {
3275         kfree(volume_info->username);
3276         kzfree(volume_info->password);
3277         kfree(volume_info->UNC);
3278         kfree(volume_info->domainname);
3279         kfree(volume_info->iocharset);
3280         kfree(volume_info->prepath);
3281 }
3282
3283 void
3284 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3285 {
3286         if (!volume_info)
3287                 return;
3288         cleanup_volume_info_contents(volume_info);
3289         kfree(volume_info);
3290 }
3291
3292
3293 #ifdef CONFIG_CIFS_DFS_UPCALL
3294 /*
3295  * cifs_build_path_to_root returns full path to root when we do not have an
3296  * exiting connection (tcon)
3297  */
3298 static char *
3299 build_unc_path_to_root(const struct smb_vol *vol,
3300                 const struct cifs_sb_info *cifs_sb)
3301 {
3302         char *full_path, *pos;
3303         unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3304         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3305
3306         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3307         if (full_path == NULL)
3308                 return ERR_PTR(-ENOMEM);
3309
3310         strncpy(full_path, vol->UNC, unc_len);
3311         pos = full_path + unc_len;
3312
3313         if (pplen) {
3314                 *pos++ = CIFS_DIR_SEP(cifs_sb);
3315                 strncpy(pos, vol->prepath, pplen);
3316                 pos += pplen;
3317         }
3318
3319         *pos = '\0'; /* add trailing null */
3320         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3321         cFYI(1, "%s: full_path=%s", __func__, full_path);
3322         return full_path;
3323 }
3324
3325 /*
3326  * Perform a dfs referral query for a share and (optionally) prefix
3327  *
3328  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3329  * to a string containing updated options for the submount.  Otherwise it
3330  * will be left untouched.
3331  *
3332  * Returns the rc from get_dfs_path to the caller, which can be used to
3333  * determine whether there were referrals.
3334  */
3335 static int
3336 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3337                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3338                     int check_prefix)
3339 {
3340         int rc;
3341         unsigned int num_referrals = 0;
3342         struct dfs_info3_param *referrals = NULL;
3343         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3344
3345         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3346         if (IS_ERR(full_path))
3347                 return PTR_ERR(full_path);
3348
3349         /* For DFS paths, skip the first '\' of the UNC */
3350         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3351
3352         rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3353                           &num_referrals, &referrals,
3354                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3355
3356         if (!rc && num_referrals > 0) {
3357                 char *fake_devname = NULL;
3358
3359                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3360                                                    full_path + 1, referrals,
3361                                                    &fake_devname);
3362
3363                 free_dfs_info_array(referrals, num_referrals);
3364
3365                 if (IS_ERR(mdata)) {
3366                         rc = PTR_ERR(mdata);
3367                         mdata = NULL;
3368                 } else {
3369                         cleanup_volume_info_contents(volume_info);
3370                         rc = cifs_setup_volume_info(volume_info, mdata,
3371                                                         fake_devname);
3372                 }
3373                 kfree(fake_devname);
3374                 kfree(cifs_sb->mountdata);
3375                 cifs_sb->mountdata = mdata;
3376         }
3377         kfree(full_path);
3378         return rc;
3379 }
3380 #endif
3381
3382 static int
3383 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3384                         const char *devname)
3385 {
3386         int rc = 0;
3387
3388         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3389                 return -EINVAL;
3390
3391         if (volume_info->nullauth) {
3392                 cFYI(1, "Anonymous login");
3393                 kfree(volume_info->username);
3394                 volume_info->username = NULL;
3395         } else if (volume_info->username) {
3396                 /* BB fixme parse for domain name here */
3397                 cFYI(1, "Username: %s", volume_info->username);
3398         } else {
3399                 cifserror("No username specified");
3400         /* In userspace mount helper we can get user name from alternate
3401            locations such as env variables and files on disk */
3402                 return -EINVAL;
3403         }
3404
3405         /* this is needed for ASCII cp to Unicode converts */
3406         if (volume_info->iocharset == NULL) {
3407                 /* load_nls_default cannot return null */
3408                 volume_info->local_nls = load_nls_default();
3409         } else {
3410                 volume_info->local_nls = load_nls(volume_info->iocharset);
3411                 if (volume_info->local_nls == NULL) {
3412                         cERROR(1, "CIFS mount error: iocharset %s not found",
3413                                  volume_info->iocharset);
3414                         return -ELIBACC;
3415                 }
3416         }
3417
3418         return rc;
3419 }
3420
3421 struct smb_vol *
3422 cifs_get_volume_info(char *mount_data, const char *devname)
3423 {
3424         int rc;
3425         struct smb_vol *volume_info;
3426
3427         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3428         if (!volume_info)
3429                 return ERR_PTR(-ENOMEM);
3430
3431         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3432         if (rc) {
3433                 cifs_cleanup_volume_info(volume_info);
3434                 volume_info = ERR_PTR(rc);
3435         }
3436
3437         return volume_info;
3438 }
3439
3440 int
3441 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3442 {
3443         int rc;
3444         unsigned int xid;
3445         struct cifs_ses *ses;
3446         struct cifs_tcon *tcon;
3447         struct TCP_Server_Info *server;
3448         char   *full_path;
3449         struct tcon_link *tlink;
3450 #ifdef CONFIG_CIFS_DFS_UPCALL
3451         int referral_walks_count = 0;
3452 #endif
3453
3454         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3455         if (rc)
3456                 return rc;
3457
3458 #ifdef CONFIG_CIFS_DFS_UPCALL
3459 try_mount_again:
3460         /* cleanup activities if we're chasing a referral */
3461         if (referral_walks_count) {
3462                 if (tcon)
3463                         cifs_put_tcon(tcon);
3464                 else if (ses)
3465                         cifs_put_smb_ses(ses);
3466
3467                 free_xid(xid);
3468         }
3469 #endif
3470         rc = 0;
3471         tcon = NULL;
3472         ses = NULL;
3473         server = NULL;
3474         full_path = NULL;
3475         tlink = NULL;
3476
3477         xid = get_xid();
3478
3479         /* get a reference to a tcp session */
3480         server = cifs_get_tcp_session(volume_info);
3481         if (IS_ERR(server)) {
3482                 rc = PTR_ERR(server);
3483                 bdi_destroy(&cifs_sb->bdi);
3484                 goto out;
3485         }
3486
3487         /* get a reference to a SMB session */
3488         ses = cifs_get_smb_ses(server, volume_info);
3489         if (IS_ERR(ses)) {
3490                 rc = PTR_ERR(ses);
3491                 ses = NULL;
3492                 goto mount_fail_check;
3493         }
3494
3495         /* search for existing tcon to this server share */
3496         tcon = cifs_get_tcon(ses, volume_info);
3497         if (IS_ERR(tcon)) {
3498                 rc = PTR_ERR(tcon);
3499                 tcon = NULL;
3500                 goto remote_path_check;
3501         }
3502
3503         /* tell server which Unix caps we support */
3504         if (cap_unix(tcon->ses)) {
3505                 /* reset of caps checks mount to see if unix extensions
3506                    disabled for just this mount */
3507                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3508                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3509                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3510                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3511                         rc = -EACCES;
3512                         goto mount_fail_check;
3513                 }
3514         } else
3515                 tcon->unix_ext = 0; /* server does not support them */
3516
3517         /* do not care if a following call succeed - informational */
3518         if (!tcon->ipc && server->ops->qfs_tcon)
3519                 server->ops->qfs_tcon(xid, tcon);
3520
3521         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3522         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3523
3524         /* tune readahead according to rsize */
3525         cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3526
3527 remote_path_check:
3528 #ifdef CONFIG_CIFS_DFS_UPCALL
3529         /*
3530          * Perform an unconditional check for whether there are DFS
3531          * referrals for this path without prefix, to provide support
3532          * for DFS referrals from w2k8 servers which don't seem to respond
3533          * with PATH_NOT_COVERED to requests that include the prefix.
3534          * Chase the referral if found, otherwise continue normally.
3535          */
3536         if (referral_walks_count == 0) {
3537                 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3538                                                 false);
3539                 if (!refrc) {
3540                         referral_walks_count++;
3541                         goto try_mount_again;
3542                 }
3543         }
3544 #endif
3545
3546         /* check if a whole path is not remote */
3547         if (!rc && tcon) {
3548                 if (!server->ops->is_path_accessible) {
3549                         rc = -ENOSYS;
3550                         goto mount_fail_check;
3551                 }
3552                 /*
3553                  * cifs_build_path_to_root works only when we have a valid tcon
3554                  */
3555                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3556                 if (full_path == NULL) {
3557                         rc = -ENOMEM;
3558                         goto mount_fail_check;
3559                 }
3560                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3561                                                      full_path);
3562                 if (rc != 0 && rc != -EREMOTE) {
3563                         kfree(full_path);
3564                         goto mount_fail_check;
3565                 }
3566                 kfree(full_path);
3567         }
3568
3569         /* get referral if needed */
3570         if (rc == -EREMOTE) {
3571 #ifdef CONFIG_CIFS_DFS_UPCALL
3572                 if (referral_walks_count > MAX_NESTED_LINKS) {
3573                         /*
3574                          * BB: when we implement proper loop detection,
3575                          *     we will remove this check. But now we need it
3576                          *     to prevent an indefinite loop if 'DFS tree' is
3577                          *     misconfigured (i.e. has loops).
3578                          */
3579                         rc = -ELOOP;
3580                         goto mount_fail_check;
3581                 }
3582
3583                 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3584
3585                 if (!rc) {
3586                         referral_walks_count++;
3587                         goto try_mount_again;
3588                 }
3589                 goto mount_fail_check;
3590 #else /* No DFS support, return error on mount */
3591                 rc = -EOPNOTSUPP;
3592 #endif
3593         }
3594
3595         if (rc)
3596                 goto mount_fail_check;
3597
3598         /* now, hang the tcon off of the superblock */
3599         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3600         if (tlink == NULL) {
3601                 rc = -ENOMEM;
3602                 goto mount_fail_check;
3603         }
3604
3605         tlink->tl_uid = ses->linux_uid;
3606         tlink->tl_tcon = tcon;
3607         tlink->tl_time = jiffies;
3608         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3609         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3610
3611         cifs_sb->master_tlink = tlink;
3612         spin_lock(&cifs_sb->tlink_tree_lock);
3613         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3614         spin_unlock(&cifs_sb->tlink_tree_lock);
3615
3616         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3617                                 TLINK_IDLE_EXPIRE);
3618
3619 mount_fail_check:
3620         /* on error free sesinfo and tcon struct if needed */
3621         if (rc) {
3622                 /* If find_unc succeeded then rc == 0 so we can not end */
3623                 /* up accidentally freeing someone elses tcon struct */
3624                 if (tcon)
3625                         cifs_put_tcon(tcon);
3626                 else if (ses)
3627                         cifs_put_smb_ses(ses);
3628                 else
3629                         cifs_put_tcp_session(server);
3630                 bdi_destroy(&cifs_sb->bdi);
3631         }
3632
3633 out:
3634         free_xid(xid);
3635         return rc;
3636 }
3637
3638 /*
3639  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3640  * pointer may be NULL.
3641  */
3642 int
3643 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3644          const char *tree, struct cifs_tcon *tcon,
3645          const struct nls_table *nls_codepage)
3646 {
3647         struct smb_hdr *smb_buffer;
3648         struct smb_hdr *smb_buffer_response;
3649         TCONX_REQ *pSMB;
3650         TCONX_RSP *pSMBr;
3651         unsigned char *bcc_ptr;
3652         int rc = 0;
3653         int length;
3654         __u16 bytes_left, count;
3655
3656         if (ses == NULL)
3657                 return -EIO;
3658
3659         smb_buffer = cifs_buf_get();
3660         if (smb_buffer == NULL)
3661                 return -ENOMEM;
3662
3663         smb_buffer_response = smb_buffer;
3664
3665         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3666                         NULL /*no tid */ , 4 /*wct */ );
3667
3668         smb_buffer->Mid = get_next_mid(ses->server);
3669         smb_buffer->Uid = ses->Suid;
3670         pSMB = (TCONX_REQ *) smb_buffer;
3671         pSMBr = (TCONX_RSP *) smb_buffer_response;
3672
3673         pSMB->AndXCommand = 0xFF;
3674         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3675         bcc_ptr = &pSMB->Password[0];
3676         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3677                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3678                 *bcc_ptr = 0; /* password is null byte */
3679                 bcc_ptr++;              /* skip password */
3680                 /* already aligned so no need to do it below */
3681         } else {
3682                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3683                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3684                    specified as required (when that support is added to
3685                    the vfs in the future) as only NTLM or the much
3686                    weaker LANMAN (which we do not send by default) is accepted
3687                    by Samba (not sure whether other servers allow
3688                    NTLMv2 password here) */
3689 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3690                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3691                     (ses->server->secType == LANMAN))
3692                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3693                                          ses->server->sec_mode &
3694                                             SECMODE_PW_ENCRYPT ? true : false,
3695                                          bcc_ptr);
3696                 else
3697 #endif /* CIFS_WEAK_PW_HASH */
3698                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3699                                         bcc_ptr, nls_codepage);
3700
3701                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3702                 if (ses->capabilities & CAP_UNICODE) {
3703                         /* must align unicode strings */
3704                         *bcc_ptr = 0; /* null byte password */
3705                         bcc_ptr++;
3706                 }
3707         }
3708
3709         if (ses->server->sec_mode &
3710                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3711                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3712
3713         if (ses->capabilities & CAP_STATUS32) {
3714                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3715         }
3716         if (ses->capabilities & CAP_DFS) {
3717                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3718         }
3719         if (ses->capabilities & CAP_UNICODE) {
3720                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3721                 length =
3722                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3723                         6 /* max utf8 char length in bytes */ *
3724                         (/* server len*/ + 256 /* share len */), nls_codepage);
3725                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3726                 bcc_ptr += 2;   /* skip trailing null */
3727         } else {                /* ASCII */
3728                 strcpy(bcc_ptr, tree);
3729                 bcc_ptr += strlen(tree) + 1;
3730         }
3731         strcpy(bcc_ptr, "?????");
3732         bcc_ptr += strlen("?????");
3733         bcc_ptr += 1;
3734         count = bcc_ptr - &pSMB->Password[0];
3735         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3736                                         pSMB->hdr.smb_buf_length) + count);
3737         pSMB->ByteCount = cpu_to_le16(count);
3738
3739         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3740                          0);
3741
3742         /* above now done in SendReceive */
3743         if ((rc == 0) && (tcon != NULL)) {
3744                 bool is_unicode;
3745
3746                 tcon->tidStatus = CifsGood;
3747                 tcon->need_reconnect = false;
3748                 tcon->tid = smb_buffer_response->Tid;
3749                 bcc_ptr = pByteArea(smb_buffer_response);
3750                 bytes_left = get_bcc(smb_buffer_response);
3751                 length = strnlen(bcc_ptr, bytes_left - 2);
3752                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3753                         is_unicode = true;
3754                 else
3755                         is_unicode = false;
3756
3757
3758                 /* skip service field (NB: this field is always ASCII) */
3759                 if (length == 3) {
3760                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3761                             (bcc_ptr[2] == 'C')) {
3762                                 cFYI(1, "IPC connection");
3763                                 tcon->ipc = 1;
3764                         }
3765                 } else if (length == 2) {
3766                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3767                                 /* the most common case */
3768                                 cFYI(1, "disk share connection");
3769                         }
3770                 }
3771                 bcc_ptr += length + 1;
3772                 bytes_left -= (length + 1);
3773                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3774
3775                 /* mostly informational -- no need to fail on error here */
3776                 kfree(tcon->nativeFileSystem);
3777                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3778                                                       bytes_left, is_unicode,
3779                                                       nls_codepage);
3780
3781                 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3782
3783                 if ((smb_buffer_response->WordCount == 3) ||
3784                          (smb_buffer_response->WordCount == 7))
3785                         /* field is in same location */
3786                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3787                 else
3788                         tcon->Flags = 0;
3789                 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3790         } else if ((rc == 0) && tcon == NULL) {
3791                 /* all we need to save for IPC$ connection */
3792                 ses->ipc_tid = smb_buffer_response->Tid;
3793         }
3794
3795         cifs_buf_release(smb_buffer);
3796         return rc;
3797 }
3798
3799 void
3800 cifs_umount(struct cifs_sb_info *cifs_sb)
3801 {
3802         struct rb_root *root = &cifs_sb->tlink_tree;
3803         struct rb_node *node;
3804         struct tcon_link *tlink;
3805
3806         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3807
3808         spin_lock(&cifs_sb->tlink_tree_lock);
3809         while ((node = rb_first(root))) {
3810                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3811                 cifs_get_tlink(tlink);
3812                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3813                 rb_erase(node, root);
3814
3815                 spin_unlock(&cifs_sb->tlink_tree_lock);
3816                 cifs_put_tlink(tlink);
3817                 spin_lock(&cifs_sb->tlink_tree_lock);
3818         }
3819         spin_unlock(&cifs_sb->tlink_tree_lock);
3820
3821         bdi_destroy(&cifs_sb->bdi);
3822         kfree(cifs_sb->mountdata);
3823         unload_nls(cifs_sb->local_nls);
3824         kfree(cifs_sb);
3825 }
3826
3827 int
3828 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3829 {
3830         int rc = 0;
3831         struct TCP_Server_Info *server = ses->server;
3832
3833         if (!server->ops->need_neg || !server->ops->negotiate)
3834                 return -ENOSYS;
3835
3836         /* only send once per connect */
3837         if (!server->ops->need_neg(server))
3838                 return 0;
3839
3840         set_credits(server, 1);
3841
3842         rc = server->ops->negotiate(xid, ses);
3843         if (rc == 0) {
3844                 spin_lock(&GlobalMid_Lock);
3845                 if (server->tcpStatus == CifsNeedNegotiate)
3846                         server->tcpStatus = CifsGood;
3847                 else
3848                         rc = -EHOSTDOWN;
3849                 spin_unlock(&GlobalMid_Lock);
3850         }
3851
3852         return rc;
3853 }
3854
3855 int
3856 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3857                    struct nls_table *nls_info)
3858 {
3859         int rc = -ENOSYS;
3860         struct TCP_Server_Info *server = ses->server;
3861
3862         ses->flags = 0;
3863         ses->capabilities = server->capabilities;
3864         if (linuxExtEnabled == 0)
3865                 ses->capabilities &= (~server->vals->cap_unix);
3866
3867         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3868                  server->sec_mode, server->capabilities, server->timeAdj);
3869
3870         if (server->ops->sess_setup)
3871                 rc = server->ops->sess_setup(xid, ses, nls_info);
3872
3873         if (rc) {
3874                 cERROR(1, "Send error in SessSetup = %d", rc);
3875         } else {
3876                 mutex_lock(&ses->server->srv_mutex);
3877                 if (!server->session_estab) {
3878                         server->session_key.response = ses->auth_key.response;
3879                         server->session_key.len = ses->auth_key.len;
3880                         server->sequence_number = 0x2;
3881                         server->session_estab = true;
3882                         ses->auth_key.response = NULL;
3883                 }
3884                 mutex_unlock(&server->srv_mutex);
3885
3886                 cFYI(1, "CIFS Session Established successfully");
3887                 spin_lock(&GlobalMid_Lock);
3888                 ses->status = CifsGood;
3889                 ses->need_reconnect = false;
3890                 spin_unlock(&GlobalMid_Lock);
3891         }
3892
3893         kfree(ses->auth_key.response);
3894         ses->auth_key.response = NULL;
3895         ses->auth_key.len = 0;
3896         kfree(ses->ntlmssp);
3897         ses->ntlmssp = NULL;
3898
3899         return rc;
3900 }
3901
3902 static int
3903 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3904 {
3905         switch (ses->server->secType) {
3906         case Kerberos:
3907                 vol->secFlg = CIFSSEC_MUST_KRB5;
3908                 return 0;
3909         case NTLMv2:
3910                 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3911                 break;
3912         case NTLM:
3913                 vol->secFlg = CIFSSEC_MUST_NTLM;
3914                 break;
3915         case RawNTLMSSP:
3916                 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3917                 break;
3918         case LANMAN:
3919                 vol->secFlg = CIFSSEC_MUST_LANMAN;
3920                 break;
3921         }
3922
3923         return cifs_set_cifscreds(vol, ses);
3924 }
3925
3926 static struct cifs_tcon *
3927 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3928 {
3929         int rc;
3930         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3931         struct cifs_ses *ses;
3932         struct cifs_tcon *tcon = NULL;
3933         struct smb_vol *vol_info;
3934
3935         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3936         if (vol_info == NULL)
3937                 return ERR_PTR(-ENOMEM);
3938
3939         vol_info->local_nls = cifs_sb->local_nls;
3940         vol_info->linux_uid = fsuid;
3941         vol_info->cred_uid = fsuid;
3942         vol_info->UNC = master_tcon->treeName;
3943         vol_info->retry = master_tcon->retry;
3944         vol_info->nocase = master_tcon->nocase;
3945         vol_info->local_lease = master_tcon->local_lease;
3946         vol_info->no_linux_ext = !master_tcon->unix_ext;
3947
3948         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3949         if (rc) {
3950                 tcon = ERR_PTR(rc);
3951                 goto out;
3952         }
3953
3954         /* get a reference for the same TCP session */
3955         spin_lock(&cifs_tcp_ses_lock);
3956         ++master_tcon->ses->server->srv_count;
3957         spin_unlock(&cifs_tcp_ses_lock);
3958
3959         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3960         if (IS_ERR(ses)) {
3961                 tcon = (struct cifs_tcon *)ses;
3962                 cifs_put_tcp_session(master_tcon->ses->server);
3963                 goto out;
3964         }
3965
3966         tcon = cifs_get_tcon(ses, vol_info);
3967         if (IS_ERR(tcon)) {
3968                 cifs_put_smb_ses(ses);
3969                 goto out;
3970         }
3971
3972         if (cap_unix(ses))
3973                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3974 out:
3975         kfree(vol_info->username);
3976         kfree(vol_info->password);
3977         kfree(vol_info);
3978
3979         return tcon;
3980 }
3981
3982 struct cifs_tcon *
3983 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3984 {
3985         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3986 }
3987
3988 static int
3989 cifs_sb_tcon_pending_wait(void *unused)
3990 {
3991         schedule();
3992         return signal_pending(current) ? -ERESTARTSYS : 0;
3993 }
3994
3995 /* find and return a tlink with given uid */
3996 static struct tcon_link *
3997 tlink_rb_search(struct rb_root *root, uid_t uid)
3998 {
3999         struct rb_node *node = root->rb_node;
4000         struct tcon_link *tlink;
4001
4002         while (node) {
4003                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4004
4005                 if (tlink->tl_uid > uid)
4006                         node = node->rb_left;
4007                 else if (tlink->tl_uid < uid)
4008                         node = node->rb_right;
4009                 else
4010                         return tlink;
4011         }
4012         return NULL;
4013 }
4014
4015 /* insert a tcon_link into the tree */
4016 static void
4017 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4018 {
4019         struct rb_node **new = &(root->rb_node), *parent = NULL;
4020         struct tcon_link *tlink;
4021
4022         while (*new) {
4023                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4024                 parent = *new;
4025
4026                 if (tlink->tl_uid > new_tlink->tl_uid)
4027                         new = &((*new)->rb_left);
4028                 else
4029                         new = &((*new)->rb_right);
4030         }
4031
4032         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4033         rb_insert_color(&new_tlink->tl_rbnode, root);
4034 }
4035
4036 /*
4037  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4038  * current task.
4039  *
4040  * If the superblock doesn't refer to a multiuser mount, then just return
4041  * the master tcon for the mount.
4042  *
4043  * First, search the rbtree for an existing tcon for this fsuid. If one
4044  * exists, then check to see if it's pending construction. If it is then wait
4045  * for construction to complete. Once it's no longer pending, check to see if
4046  * it failed and either return an error or retry construction, depending on
4047  * the timeout.
4048  *
4049  * If one doesn't exist then insert a new tcon_link struct into the tree and
4050  * try to construct a new one.
4051  */
4052 struct tcon_link *
4053 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4054 {
4055         int ret;
4056         uid_t fsuid = current_fsuid();
4057         struct tcon_link *tlink, *newtlink;
4058
4059         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4060                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4061
4062         spin_lock(&cifs_sb->tlink_tree_lock);
4063         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4064         if (tlink)
4065                 cifs_get_tlink(tlink);
4066         spin_unlock(&cifs_sb->tlink_tree_lock);
4067
4068         if (tlink == NULL) {
4069                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4070                 if (newtlink == NULL)
4071                         return ERR_PTR(-ENOMEM);
4072                 newtlink->tl_uid = fsuid;
4073                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4074                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4075                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4076                 cifs_get_tlink(newtlink);
4077
4078                 spin_lock(&cifs_sb->tlink_tree_lock);
4079                 /* was one inserted after previous search? */
4080                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4081                 if (tlink) {
4082                         cifs_get_tlink(tlink);
4083                         spin_unlock(&cifs_sb->tlink_tree_lock);
4084                         kfree(newtlink);
4085                         goto wait_for_construction;
4086                 }
4087                 tlink = newtlink;
4088                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4089                 spin_unlock(&cifs_sb->tlink_tree_lock);
4090         } else {
4091 wait_for_construction:
4092                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4093                                   cifs_sb_tcon_pending_wait,
4094                                   TASK_INTERRUPTIBLE);
4095                 if (ret) {
4096                         cifs_put_tlink(tlink);
4097                         return ERR_PTR(ret);
4098                 }
4099
4100                 /* if it's good, return it */
4101                 if (!IS_ERR(tlink->tl_tcon))
4102                         return tlink;
4103
4104                 /* return error if we tried this already recently */
4105                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4106                         cifs_put_tlink(tlink);
4107                         return ERR_PTR(-EACCES);
4108                 }
4109
4110                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4111                         goto wait_for_construction;
4112         }
4113
4114         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4115         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4116         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4117
4118         if (IS_ERR(tlink->tl_tcon)) {
4119                 cifs_put_tlink(tlink);
4120                 return ERR_PTR(-EACCES);
4121         }
4122
4123         return tlink;
4124 }
4125
4126 /*
4127  * periodic workqueue job that scans tcon_tree for a superblock and closes
4128  * out tcons.
4129  */
4130 static void
4131 cifs_prune_tlinks(struct work_struct *work)
4132 {
4133         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4134                                                     prune_tlinks.work);
4135         struct rb_root *root = &cifs_sb->tlink_tree;
4136         struct rb_node *node = rb_first(root);
4137         struct rb_node *tmp;
4138         struct tcon_link *tlink;
4139
4140         /*
4141          * Because we drop the spinlock in the loop in order to put the tlink
4142          * it's not guarded against removal of links from the tree. The only
4143          * places that remove entries from the tree are this function and
4144          * umounts. Because this function is non-reentrant and is canceled
4145          * before umount can proceed, this is safe.
4146          */
4147         spin_lock(&cifs_sb->tlink_tree_lock);
4148         node = rb_first(root);
4149         while (node != NULL) {
4150                 tmp = node;
4151                 node = rb_next(tmp);
4152                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4153
4154                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4155                     atomic_read(&tlink->tl_count) != 0 ||
4156                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4157                         continue;
4158
4159                 cifs_get_tlink(tlink);
4160                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4161                 rb_erase(tmp, root);
4162
4163                 spin_unlock(&cifs_sb->tlink_tree_lock);
4164                 cifs_put_tlink(tlink);
4165                 spin_lock(&cifs_sb->tlink_tree_lock);
4166         }
4167         spin_unlock(&cifs_sb->tlink_tree_lock);
4168
4169         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4170                                 TLINK_IDLE_EXPIRE);
4171 }