fs/cifs/connect.c

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