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