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