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