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