fs/cifs/connect.c

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