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