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         int is_domain = 0;
2985         const char *delim, *payload;
2986         char *desc;
2987         ssize_t len;
2988         struct key *key;
2989         struct TCP_Server_Info *server = ses->server;
2990         struct sockaddr_in *sa;
2991         struct sockaddr_in6 *sa6;
2992         const struct user_key_payload *upayload;
2993
2994         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2995         if (!desc)
2996                 return -ENOMEM;
2997
2998         /* try to find an address key first */
2999         switch (server->dstaddr.ss_family) {
3000         case AF_INET:
3001                 sa = (struct sockaddr_in *)&server->dstaddr;
3002                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
3003                 break;
3004         case AF_INET6:
3005                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
3006                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
3007                 break;
3008         default:
3009                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
3010                          server->dstaddr.ss_family);
3011                 rc = -EINVAL;
3012                 goto out_err;
3013         }
3014
3015         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3016         key = request_key(&key_type_logon, desc, "");
3017         if (IS_ERR(key)) {
3018                 if (!ses->domainName) {
3019                         cifs_dbg(FYI, "domainName is NULL\n");
3020                         rc = PTR_ERR(key);
3021                         goto out_err;
3022                 }
3023
3024                 /* didn't work, try to find a domain key */
3025                 sprintf(desc, "cifs:d:%s", ses->domainName);
3026                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3027                 key = request_key(&key_type_logon, desc, "");
3028                 if (IS_ERR(key)) {
3029                         rc = PTR_ERR(key);
3030                         goto out_err;
3031                 }
3032                 is_domain = 1;
3033         }
3034
3035         down_read(&key->sem);
3036         upayload = user_key_payload_locked(key);
3037         if (IS_ERR_OR_NULL(upayload)) {
3038                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3039                 goto out_key_put;
3040         }
3041
3042         /* find first : in payload */
3043         payload = upayload->data;
3044         delim = strnchr(payload, upayload->datalen, ':');
3045         cifs_dbg(FYI, "payload=%s\n", payload);
3046         if (!delim) {
3047                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3048                          upayload->datalen);
3049                 rc = -EINVAL;
3050                 goto out_key_put;
3051         }
3052
3053         len = delim - payload;
3054         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3055                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3056                          len);
3057                 rc = -EINVAL;
3058                 goto out_key_put;
3059         }
3060
3061         vol->username = kstrndup(payload, len, GFP_KERNEL);
3062         if (!vol->username) {
3063                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3064                          len);
3065                 rc = -ENOMEM;
3066                 goto out_key_put;
3067         }
3068         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3069
3070         len = key->datalen - (len + 1);
3071         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3072                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3073                 rc = -EINVAL;
3074                 kfree(vol->username);
3075                 vol->username = NULL;
3076                 goto out_key_put;
3077         }
3078
3079         ++delim;
3080         vol->password = kstrndup(delim, len, GFP_KERNEL);
3081         if (!vol->password) {
3082                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3083                          len);
3084                 rc = -ENOMEM;
3085                 kfree(vol->username);
3086                 vol->username = NULL;
3087                 goto out_key_put;
3088         }
3089
3090         /*
3091          * If we have a domain key then we must set the domainName in the
3092          * for the request.
3093          */
3094         if (is_domain && ses->domainName) {
3095                 vol->domainname = kstrndup(ses->domainName,
3096                                            strlen(ses->domainName),
3097                                            GFP_KERNEL);
3098                 if (!vol->domainname) {
3099                         cifs_dbg(FYI, "Unable to allocate %zd bytes for "
3100                                  "domain\n", len);
3101                         rc = -ENOMEM;
3102                         kfree(vol->username);
3103                         vol->username = NULL;
3104                         kfree(vol->password);
3105                         vol->password = NULL;
3106                         goto out_key_put;
3107                 }
3108         }
3109
3110 out_key_put:
3111         up_read(&key->sem);
3112         key_put(key);
3113 out_err:
3114         kfree(desc);
3115         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3116         return rc;
3117 }
3118 #else /* ! CONFIG_KEYS */
3119 static inline int
3120 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3121                    struct cifs_ses *ses __attribute__((unused)))
3122 {
3123         return -ENOSYS;
3124 }
3125 #endif /* CONFIG_KEYS */
3126
3127 /**
3128  * cifs_get_smb_ses - get a session matching @volume_info data from @server
3129  *
3130  * This function assumes it is being called from cifs_mount() where we
3131  * already got a server reference (server refcount +1). See
3132  * cifs_get_tcon() for refcount explanations.
3133  */
3134 struct cifs_ses *
3135 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3136 {
3137         int rc = -ENOMEM;
3138         unsigned int xid;
3139         struct cifs_ses *ses;
3140         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3141         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3142
3143         xid = get_xid();
3144
3145         ses = cifs_find_smb_ses(server, volume_info);
3146         if (ses) {
3147                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3148                          ses->status);
3149
3150                 mutex_lock(&ses->session_mutex);
3151                 rc = cifs_negotiate_protocol(xid, ses);
3152                 if (rc) {
3153                         mutex_unlock(&ses->session_mutex);
3154                         /* problem -- put our ses reference */
3155                         cifs_put_smb_ses(ses);
3156                         free_xid(xid);
3157                         return ERR_PTR(rc);
3158                 }
3159                 if (ses->need_reconnect) {
3160                         cifs_dbg(FYI, "Session needs reconnect\n");
3161                         rc = cifs_setup_session(xid, ses,
3162                                                 volume_info->local_nls);
3163                         if (rc) {
3164                                 mutex_unlock(&ses->session_mutex);
3165                                 /* problem -- put our reference */
3166                                 cifs_put_smb_ses(ses);
3167                                 free_xid(xid);
3168                                 return ERR_PTR(rc);
3169                         }
3170                 }
3171                 mutex_unlock(&ses->session_mutex);
3172
3173                 /* existing SMB ses has a server reference already */
3174                 cifs_put_tcp_session(server, 0);
3175                 free_xid(xid);
3176                 return ses;
3177         }
3178
3179         cifs_dbg(FYI, "Existing smb sess not found\n");
3180         ses = sesInfoAlloc();
3181         if (ses == NULL)
3182                 goto get_ses_fail;
3183
3184         /* new SMB session uses our server ref */
3185         ses->server = server;
3186         if (server->dstaddr.ss_family == AF_INET6)
3187                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3188         else
3189                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3190
3191         if (volume_info->username) {
3192                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3193                 if (!ses->user_name)
3194                         goto get_ses_fail;
3195         }
3196
3197         /* volume_info->password freed at unmount */
3198         if (volume_info->password) {
3199                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3200                 if (!ses->password)
3201                         goto get_ses_fail;
3202         }
3203         if (volume_info->domainname) {
3204                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3205                 if (!ses->domainName)
3206                         goto get_ses_fail;
3207         }
3208         if (volume_info->domainauto)
3209                 ses->domainAuto = volume_info->domainauto;
3210         ses->cred_uid = volume_info->cred_uid;
3211         ses->linux_uid = volume_info->linux_uid;
3212
3213         ses->sectype = volume_info->sectype;
3214         ses->sign = volume_info->sign;
3215
3216         mutex_lock(&ses->session_mutex);
3217         rc = cifs_negotiate_protocol(xid, ses);
3218         if (!rc)
3219                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3220         mutex_unlock(&ses->session_mutex);
3221         if (rc)
3222                 goto get_ses_fail;
3223
3224         /* success, put it on the list */
3225         spin_lock(&cifs_tcp_ses_lock);
3226         list_add(&ses->smb_ses_list, &server->smb_ses_list);
3227         spin_unlock(&cifs_tcp_ses_lock);
3228
3229         free_xid(xid);
3230
3231         cifs_setup_ipc(ses, volume_info);
3232
3233         return ses;
3234
3235 get_ses_fail:
3236         sesInfoFree(ses);
3237         free_xid(xid);
3238         return ERR_PTR(rc);
3239 }
3240
3241 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3242 {
3243         if (tcon->tidStatus == CifsExiting)
3244                 return 0;
3245         if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3246                 return 0;
3247         if (tcon->seal != volume_info->seal)
3248                 return 0;
3249         if (tcon->snapshot_time != volume_info->snapshot_time)
3250                 return 0;
3251         if (tcon->handle_timeout != volume_info->handle_timeout)
3252                 return 0;
3253         return 1;
3254 }
3255
3256 static struct cifs_tcon *
3257 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3258 {
3259         struct list_head *tmp;
3260         struct cifs_tcon *tcon;
3261
3262         spin_lock(&cifs_tcp_ses_lock);
3263         list_for_each(tmp, &ses->tcon_list) {
3264                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3265                 if (!match_tcon(tcon, volume_info))
3266                         continue;
3267                 ++tcon->tc_count;
3268                 spin_unlock(&cifs_tcp_ses_lock);
3269                 return tcon;
3270         }
3271         spin_unlock(&cifs_tcp_ses_lock);
3272         return NULL;
3273 }
3274
3275 void
3276 cifs_put_tcon(struct cifs_tcon *tcon)
3277 {
3278         unsigned int xid;
3279         struct cifs_ses *ses;
3280
3281         /*
3282          * IPC tcon share the lifetime of their session and are
3283          * destroyed in the session put function
3284          */
3285         if (tcon == NULL || tcon->ipc)
3286                 return;
3287
3288         ses = tcon->ses;
3289         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3290         spin_lock(&cifs_tcp_ses_lock);
3291         if (--tcon->tc_count > 0) {
3292                 spin_unlock(&cifs_tcp_ses_lock);
3293                 return;
3294         }
3295
3296         list_del_init(&tcon->tcon_list);
3297         spin_unlock(&cifs_tcp_ses_lock);
3298
3299         xid = get_xid();
3300         if (ses->server->ops->tree_disconnect)
3301                 ses->server->ops->tree_disconnect(xid, tcon);
3302         _free_xid(xid);
3303
3304         cifs_fscache_release_super_cookie(tcon);
3305         tconInfoFree(tcon);
3306         cifs_put_smb_ses(ses);
3307 }
3308
3309 /**
3310  * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3311  *
3312  * - tcon refcount is the number of mount points using the tcon.
3313  * - ses refcount is the number of tcon using the session.
3314  *
3315  * 1. This function assumes it is being called from cifs_mount() where
3316  *    we already got a session reference (ses refcount +1).
3317  *
3318  * 2. Since we're in the context of adding a mount point, the end
3319  *    result should be either:
3320  *
3321  * a) a new tcon already allocated with refcount=1 (1 mount point) and
3322  *    its session refcount incremented (1 new tcon). This +1 was
3323  *    already done in (1).
3324  *
3325  * b) an existing tcon with refcount+1 (add a mount point to it) and
3326  *    identical ses refcount (no new tcon). Because of (1) we need to
3327  *    decrement the ses refcount.
3328  */
3329 static struct cifs_tcon *
3330 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3331 {
3332         int rc, xid;
3333         struct cifs_tcon *tcon;
3334
3335         tcon = cifs_find_tcon(ses, volume_info);
3336         if (tcon) {
3337                 /*
3338                  * tcon has refcount already incremented but we need to
3339                  * decrement extra ses reference gotten by caller (case b)
3340                  */
3341                 cifs_dbg(FYI, "Found match on UNC path\n");
3342                 cifs_put_smb_ses(ses);
3343                 return tcon;
3344         }
3345
3346         if (!ses->server->ops->tree_connect) {
3347                 rc = -ENOSYS;
3348                 goto out_fail;
3349         }
3350
3351         tcon = tconInfoAlloc();
3352         if (tcon == NULL) {
3353                 rc = -ENOMEM;
3354                 goto out_fail;
3355         }
3356
3357         if (volume_info->snapshot_time) {
3358                 if (ses->server->vals->protocol_id == 0) {
3359                         cifs_dbg(VFS,
3360                              "Use SMB2 or later for snapshot mount option\n");
3361                         rc = -EOPNOTSUPP;
3362                         goto out_fail;
3363                 } else
3364                         tcon->snapshot_time = volume_info->snapshot_time;
3365         }
3366
3367         if (volume_info->handle_timeout) {
3368                 if (ses->server->vals->protocol_id == 0) {
3369                         cifs_dbg(VFS,
3370                              "Use SMB2.1 or later for handle timeout option\n");
3371                         rc = -EOPNOTSUPP;
3372                         goto out_fail;
3373                 } else
3374                         tcon->handle_timeout = volume_info->handle_timeout;
3375         }
3376
3377         tcon->ses = ses;
3378         if (volume_info->password) {
3379                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3380                 if (!tcon->password) {
3381                         rc = -ENOMEM;
3382                         goto out_fail;
3383                 }
3384         }
3385
3386         if (volume_info->seal) {
3387                 if (ses->server->vals->protocol_id == 0) {
3388                         cifs_dbg(VFS,
3389                                  "SMB3 or later required for encryption\n");
3390                         rc = -EOPNOTSUPP;
3391                         goto out_fail;
3392                 } else if (tcon->ses->server->capabilities &
3393                                         SMB2_GLOBAL_CAP_ENCRYPTION)
3394                         tcon->seal = true;
3395                 else {
3396                         cifs_dbg(VFS, "Encryption is not supported on share\n");
3397                         rc = -EOPNOTSUPP;
3398                         goto out_fail;
3399                 }
3400         }
3401
3402         if (volume_info->linux_ext) {
3403                 if (ses->server->posix_ext_supported) {
3404                         tcon->posix_extensions = true;
3405                         printk_once(KERN_WARNING
3406                                 "SMB3.11 POSIX Extensions are experimental\n");
3407                 } else {
3408                         cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3409                         rc = -EOPNOTSUPP;
3410                         goto out_fail;
3411                 }
3412         }
3413
3414         /*
3415          * BB Do we need to wrap session_mutex around this TCon call and Unix
3416          * SetFS as we do on SessSetup and reconnect?
3417          */
3418         xid = get_xid();
3419         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3420                                             volume_info->local_nls);
3421         free_xid(xid);
3422         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3423         if (rc)
3424                 goto out_fail;
3425
3426         tcon->use_persistent = false;
3427         /* check if SMB2 or later, CIFS does not support persistent handles */
3428         if (volume_info->persistent) {
3429                 if (ses->server->vals->protocol_id == 0) {
3430                         cifs_dbg(VFS,
3431                              "SMB3 or later required for persistent handles\n");
3432                         rc = -EOPNOTSUPP;
3433                         goto out_fail;
3434                 } else if (ses->server->capabilities &
3435                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3436                         tcon->use_persistent = true;
3437                 else /* persistent handles requested but not supported */ {
3438                         cifs_dbg(VFS,
3439                                 "Persistent handles not supported on share\n");
3440                         rc = -EOPNOTSUPP;
3441                         goto out_fail;
3442                 }
3443         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3444              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3445              && (volume_info->nopersistent == false)) {
3446                 cifs_dbg(FYI, "enabling persistent handles\n");
3447                 tcon->use_persistent = true;
3448         } else if (volume_info->resilient) {
3449                 if (ses->server->vals->protocol_id == 0) {
3450                         cifs_dbg(VFS,
3451                              "SMB2.1 or later required for resilient handles\n");
3452                         rc = -EOPNOTSUPP;
3453                         goto out_fail;
3454                 }
3455                 tcon->use_resilient = true;
3456         }
3457
3458         /*
3459          * We can have only one retry value for a connection to a share so for
3460          * resources mounted more than once to the same server share the last
3461          * value passed in for the retry flag is used.
3462          */
3463         tcon->retry = volume_info->retry;
3464         tcon->nocase = volume_info->nocase;
3465         tcon->nohandlecache = volume_info->nohandlecache;
3466         tcon->local_lease = volume_info->local_lease;
3467         INIT_LIST_HEAD(&tcon->pending_opens);
3468
3469         spin_lock(&cifs_tcp_ses_lock);
3470         list_add(&tcon->tcon_list, &ses->tcon_list);
3471         spin_unlock(&cifs_tcp_ses_lock);
3472
3473         cifs_fscache_get_super_cookie(tcon);
3474
3475         return tcon;
3476
3477 out_fail:
3478         tconInfoFree(tcon);
3479         return ERR_PTR(rc);
3480 }
3481
3482 void
3483 cifs_put_tlink(struct tcon_link *tlink)
3484 {
3485         if (!tlink || IS_ERR(tlink))
3486                 return;
3487
3488         if (!atomic_dec_and_test(&tlink->tl_count) ||
3489             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3490                 tlink->tl_time = jiffies;
3491                 return;
3492         }
3493
3494         if (!IS_ERR(tlink_tcon(tlink)))
3495                 cifs_put_tcon(tlink_tcon(tlink));
3496         kfree(tlink);
3497         return;
3498 }
3499
3500 static int
3501 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3502 {
3503         struct cifs_sb_info *old = CIFS_SB(sb);
3504         struct cifs_sb_info *new = mnt_data->cifs_sb;
3505         unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
3506         unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
3507
3508         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3509                 return 0;
3510
3511         if (old->mnt_cifs_serverino_autodisabled)
3512                 newflags &= ~CIFS_MOUNT_SERVER_INUM;
3513
3514         if (oldflags != newflags)
3515                 return 0;
3516
3517         /*
3518          * We want to share sb only if we don't specify an r/wsize or
3519          * specified r/wsize is greater than or equal to existing one.
3520          */
3521         if (new->wsize && new->wsize < old->wsize)
3522                 return 0;
3523
3524         if (new->rsize && new->rsize < old->rsize)
3525                 return 0;
3526
3527         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3528                 return 0;
3529
3530         if (old->mnt_file_mode != new->mnt_file_mode ||
3531             old->mnt_dir_mode != new->mnt_dir_mode)
3532                 return 0;
3533
3534         if (strcmp(old->local_nls->charset, new->local_nls->charset))
3535                 return 0;
3536
3537         if (old->actimeo != new->actimeo)
3538                 return 0;
3539
3540         return 1;
3541 }
3542
3543 static int
3544 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3545 {
3546         struct cifs_sb_info *old = CIFS_SB(sb);
3547         struct cifs_sb_info *new = mnt_data->cifs_sb;
3548         bool old_set = old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3549         bool new_set = new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH;
3550
3551         if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3552                 return 1;
3553         else if (!old_set && !new_set)
3554                 return 1;
3555
3556         return 0;
3557 }
3558
3559 int
3560 cifs_match_super(struct super_block *sb, void *data)
3561 {
3562         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3563         struct smb_vol *volume_info;
3564         struct cifs_sb_info *cifs_sb;
3565         struct TCP_Server_Info *tcp_srv;
3566         struct cifs_ses *ses;
3567         struct cifs_tcon *tcon;
3568         struct tcon_link *tlink;
3569         int rc = 0;
3570
3571         spin_lock(&cifs_tcp_ses_lock);
3572         cifs_sb = CIFS_SB(sb);
3573         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3574         if (IS_ERR(tlink)) {
3575                 spin_unlock(&cifs_tcp_ses_lock);
3576                 return rc;
3577         }
3578         tcon = tlink_tcon(tlink);
3579         ses = tcon->ses;
3580         tcp_srv = ses->server;
3581
3582         volume_info = mnt_data->vol;
3583
3584         if (!match_server(tcp_srv, volume_info) ||
3585             !match_session(ses, volume_info) ||
3586             !match_tcon(tcon, volume_info) ||
3587             !match_prepath(sb, mnt_data)) {
3588                 rc = 0;
3589                 goto out;
3590         }
3591
3592         rc = compare_mount_options(sb, mnt_data);
3593 out:
3594         spin_unlock(&cifs_tcp_ses_lock);
3595         cifs_put_tlink(tlink);
3596         return rc;
3597 }
3598
3599 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3600 static struct lock_class_key cifs_key[2];
3601 static struct lock_class_key cifs_slock_key[2];
3602
3603 static inline void
3604 cifs_reclassify_socket4(struct socket *sock)
3605 {
3606         struct sock *sk = sock->sk;
3607         BUG_ON(!sock_allow_reclassification(sk));
3608         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3609                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3610 }
3611
3612 static inline void
3613 cifs_reclassify_socket6(struct socket *sock)
3614 {
3615         struct sock *sk = sock->sk;
3616         BUG_ON(!sock_allow_reclassification(sk));
3617         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3618                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3619 }
3620 #else
3621 static inline void
3622 cifs_reclassify_socket4(struct socket *sock)
3623 {
3624 }
3625
3626 static inline void
3627 cifs_reclassify_socket6(struct socket *sock)
3628 {
3629 }
3630 #endif
3631
3632 /* See RFC1001 section 14 on representation of Netbios names */
3633 static void rfc1002mangle(char *target, char *source, unsigned int length)
3634 {
3635         unsigned int i, j;
3636
3637         for (i = 0, j = 0; i < (length); i++) {
3638                 /* mask a nibble at a time and encode */
3639                 target[j] = 'A' + (0x0F & (source[i] >> 4));
3640                 target[j+1] = 'A' + (0x0F & source[i]);
3641                 j += 2;
3642         }
3643
3644 }
3645
3646 static int
3647 bind_socket(struct TCP_Server_Info *server)
3648 {
3649         int rc = 0;
3650         if (server->srcaddr.ss_family != AF_UNSPEC) {
3651                 /* Bind to the specified local IP address */
3652                 struct socket *socket = server->ssocket;
3653                 rc = socket->ops->bind(socket,
3654                                        (struct sockaddr *) &server->srcaddr,
3655                                        sizeof(server->srcaddr));
3656                 if (rc < 0) {
3657                         struct sockaddr_in *saddr4;
3658                         struct sockaddr_in6 *saddr6;
3659                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
3660                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3661                         if (saddr6->sin6_family == AF_INET6)
3662                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3663                                          &saddr6->sin6_addr, rc);
3664                         else
3665                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3666                                          &saddr4->sin_addr.s_addr, rc);
3667                 }
3668         }
3669         return rc;
3670 }
3671
3672 static int
3673 ip_rfc1001_connect(struct TCP_Server_Info *server)
3674 {
3675         int rc = 0;
3676         /*
3677          * some servers require RFC1001 sessinit before sending
3678          * negprot - BB check reconnection in case where second
3679          * sessinit is sent but no second negprot
3680          */
3681         struct rfc1002_session_packet *ses_init_buf;
3682         struct smb_hdr *smb_buf;
3683         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3684                                GFP_KERNEL);
3685         if (ses_init_buf) {
3686                 ses_init_buf->trailer.session_req.called_len = 32;
3687
3688                 if (server->server_RFC1001_name[0] != 0)
3689                         rfc1002mangle(ses_init_buf->trailer.
3690                                       session_req.called_name,
3691                                       server->server_RFC1001_name,
3692                                       RFC1001_NAME_LEN_WITH_NULL);
3693                 else
3694                         rfc1002mangle(ses_init_buf->trailer.
3695                                       session_req.called_name,
3696                                       DEFAULT_CIFS_CALLED_NAME,
3697                                       RFC1001_NAME_LEN_WITH_NULL);
3698
3699                 ses_init_buf->trailer.session_req.calling_len = 32;
3700
3701                 /*
3702                  * calling name ends in null (byte 16) from old smb
3703                  * convention.
3704                  */
3705                 if (server->workstation_RFC1001_name[0] != 0)
3706                         rfc1002mangle(ses_init_buf->trailer.
3707                                       session_req.calling_name,
3708                                       server->workstation_RFC1001_name,
3709                                       RFC1001_NAME_LEN_WITH_NULL);
3710                 else
3711                         rfc1002mangle(ses_init_buf->trailer.
3712                                       session_req.calling_name,
3713                                       "LINUX_CIFS_CLNT",
3714                                       RFC1001_NAME_LEN_WITH_NULL);
3715
3716                 ses_init_buf->trailer.session_req.scope1 = 0;
3717                 ses_init_buf->trailer.session_req.scope2 = 0;
3718                 smb_buf = (struct smb_hdr *)ses_init_buf;
3719
3720                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3721                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3722                 rc = smb_send(server, smb_buf, 0x44);
3723                 kfree(ses_init_buf);
3724                 /*
3725                  * RFC1001 layer in at least one server
3726                  * requires very short break before negprot
3727                  * presumably because not expecting negprot
3728                  * to follow so fast.  This is a simple
3729                  * solution that works without
3730                  * complicating the code and causes no
3731                  * significant slowing down on mount
3732                  * for everyone else
3733                  */
3734                 usleep_range(1000, 2000);
3735         }
3736         /*
3737          * else the negprot may still work without this
3738          * even though malloc failed
3739          */
3740
3741         return rc;
3742 }
3743
3744 static int
3745 generic_ip_connect(struct TCP_Server_Info *server)
3746 {
3747         int rc = 0;
3748         __be16 sport;
3749         int slen, sfamily;
3750         struct socket *socket = server->ssocket;
3751         struct sockaddr *saddr;
3752
3753         saddr = (struct sockaddr *) &server->dstaddr;
3754
3755         if (server->dstaddr.ss_family == AF_INET6) {
3756                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3757                 slen = sizeof(struct sockaddr_in6);
3758                 sfamily = AF_INET6;
3759         } else {
3760                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3761                 slen = sizeof(struct sockaddr_in);
3762                 sfamily = AF_INET;
3763         }
3764
3765         if (socket == NULL) {
3766                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3767                                    IPPROTO_TCP, &socket, 1);
3768                 if (rc < 0) {
3769                         cifs_dbg(VFS, "Error %d creating socket\n", rc);
3770                         server->ssocket = NULL;
3771                         return rc;
3772                 }
3773
3774                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3775                 cifs_dbg(FYI, "Socket created\n");
3776                 server->ssocket = socket;
3777                 socket->sk->sk_allocation = GFP_NOFS;
3778                 if (sfamily == AF_INET6)
3779                         cifs_reclassify_socket6(socket);
3780                 else
3781                         cifs_reclassify_socket4(socket);
3782         }
3783
3784         rc = bind_socket(server);
3785         if (rc < 0)
3786                 return rc;
3787
3788         /*
3789          * Eventually check for other socket options to change from
3790          * the default. sock_setsockopt not used because it expects
3791          * user space buffer
3792          */
3793         socket->sk->sk_rcvtimeo = 7 * HZ;
3794         socket->sk->sk_sndtimeo = 5 * HZ;
3795
3796         /* make the bufsizes depend on wsize/rsize and max requests */
3797         if (server->noautotune) {
3798                 if (socket->sk->sk_sndbuf < (200 * 1024))
3799                         socket->sk->sk_sndbuf = 200 * 1024;
3800                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3801                         socket->sk->sk_rcvbuf = 140 * 1024;
3802         }
3803
3804         if (server->tcp_nodelay) {
3805                 int val = 1;
3806                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3807                                 (char *)&val, sizeof(val));
3808                 if (rc)
3809                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3810                                  rc);
3811         }
3812
3813         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3814                  socket->sk->sk_sndbuf,
3815                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3816
3817         rc = socket->ops->connect(socket, saddr, slen, 0);
3818         if (rc < 0) {
3819                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3820                 sock_release(socket);
3821                 server->ssocket = NULL;
3822                 return rc;
3823         }
3824
3825         if (sport == htons(RFC1001_PORT))
3826                 rc = ip_rfc1001_connect(server);
3827
3828         return rc;
3829 }
3830
3831 static int
3832 ip_connect(struct TCP_Server_Info *server)
3833 {
3834         __be16 *sport;
3835         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3836         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3837
3838         if (server->dstaddr.ss_family == AF_INET6)
3839                 sport = &addr6->sin6_port;
3840         else
3841                 sport = &addr->sin_port;
3842
3843         if (*sport == 0) {
3844                 int rc;
3845
3846                 /* try with 445 port at first */
3847                 *sport = htons(CIFS_PORT);
3848
3849                 rc = generic_ip_connect(server);
3850                 if (rc >= 0)
3851                         return rc;
3852
3853                 /* if it failed, try with 139 port */
3854                 *sport = htons(RFC1001_PORT);
3855         }
3856
3857         return generic_ip_connect(server);
3858 }
3859
3860 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3861                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3862 {
3863         /* if we are reconnecting then should we check to see if
3864          * any requested capabilities changed locally e.g. via
3865          * remount but we can not do much about it here
3866          * if they have (even if we could detect it by the following)
3867          * Perhaps we could add a backpointer to array of sb from tcon
3868          * or if we change to make all sb to same share the same
3869          * sb as NFS - then we only have one backpointer to sb.
3870          * What if we wanted to mount the server share twice once with
3871          * and once without posixacls or posix paths? */
3872         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3873
3874         if (vol_info && vol_info->no_linux_ext) {
3875                 tcon->fsUnixInfo.Capability = 0;
3876                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3877                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3878                 return;
3879         } else if (vol_info)
3880                 tcon->unix_ext = 1; /* Unix Extensions supported */
3881
3882         if (tcon->unix_ext == 0) {
3883                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3884                 return;
3885         }
3886
3887         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3888                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3889                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3890                 /* check for reconnect case in which we do not
3891                    want to change the mount behavior if we can avoid it */
3892                 if (vol_info == NULL) {
3893                         /* turn off POSIX ACL and PATHNAMES if not set
3894                            originally at mount time */
3895                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3896                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3897                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3898                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3899                                         cifs_dbg(VFS, "POSIXPATH support change\n");
3900                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3901                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3902                                 cifs_dbg(VFS, "possible reconnect error\n");
3903                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
3904                         }
3905                 }
3906
3907                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3908                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
3909
3910                 cap &= CIFS_UNIX_CAP_MASK;
3911                 if (vol_info && vol_info->no_psx_acl)
3912                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3913                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3914                         cifs_dbg(FYI, "negotiated posix acl support\n");
3915                         if (cifs_sb)
3916                                 cifs_sb->mnt_cifs_flags |=
3917                                         CIFS_MOUNT_POSIXACL;
3918                 }
3919
3920                 if (vol_info && vol_info->posix_paths == 0)
3921                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3922                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3923                         cifs_dbg(FYI, "negotiate posix pathnames\n");
3924                         if (cifs_sb)
3925                                 cifs_sb->mnt_cifs_flags |=
3926                                         CIFS_MOUNT_POSIX_PATHS;
3927                 }
3928
3929                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3930 #ifdef CONFIG_CIFS_DEBUG2
3931                 if (cap & CIFS_UNIX_FCNTL_CAP)
3932                         cifs_dbg(FYI, "FCNTL cap\n");
3933                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3934                         cifs_dbg(FYI, "EXTATTR cap\n");
3935                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3936                         cifs_dbg(FYI, "POSIX path cap\n");
3937                 if (cap & CIFS_UNIX_XATTR_CAP)
3938                         cifs_dbg(FYI, "XATTR cap\n");
3939                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3940                         cifs_dbg(FYI, "POSIX ACL cap\n");
3941                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3942                         cifs_dbg(FYI, "very large read cap\n");
3943                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3944                         cifs_dbg(FYI, "very large write cap\n");
3945                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3946                         cifs_dbg(FYI, "transport encryption cap\n");
3947                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3948                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
3949 #endif /* CIFS_DEBUG2 */
3950                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3951                         if (vol_info == NULL) {
3952                                 cifs_dbg(FYI, "resetting capabilities failed\n");
3953                         } else
3954                                 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");
3955
3956                 }
3957         }
3958 }
3959
3960 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3961                         struct cifs_sb_info *cifs_sb)
3962 {
3963         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3964
3965         spin_lock_init(&cifs_sb->tlink_tree_lock);
3966         cifs_sb->tlink_tree = RB_ROOT;
3967
3968         cifs_sb->bsize = pvolume_info->bsize;
3969         /*
3970          * Temporarily set r/wsize for matching superblock. If we end up using
3971          * new sb then client will later negotiate it downward if needed.
3972          */
3973         cifs_sb->rsize = pvolume_info->rsize;
3974         cifs_sb->wsize = pvolume_info->wsize;
3975
3976         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3977         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3978         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3979         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3980         cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
3981                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3982
3983         cifs_sb->actimeo = pvolume_info->actimeo;
3984         cifs_sb->local_nls = pvolume_info->local_nls;
3985
3986         if (pvolume_info->nodfs)
3987                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
3988         if (pvolume_info->noperm)
3989                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3990         if (pvolume_info->setuids)
3991                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3992         if (pvolume_info->setuidfromacl)
3993                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3994         if (pvolume_info->server_ino)
3995                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3996         if (pvolume_info->remap)
3997                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3998         if (pvolume_info->sfu_remap)
3999                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
4000         if (pvolume_info->no_xattr)
4001                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
4002         if (pvolume_info->sfu_emul)
4003                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
4004         if (pvolume_info->nobrl)
4005                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
4006         if (pvolume_info->nohandlecache)
4007                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
4008         if (pvolume_info->nostrictsync)
4009                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
4010         if (pvolume_info->mand_lock)
4011                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
4012         if (pvolume_info->rwpidforward)
4013                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
4014         if (pvolume_info->mode_ace)
4015                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
4016         if (pvolume_info->cifs_acl)
4017                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
4018         if (pvolume_info->backupuid_specified) {
4019                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
4020                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
4021         }
4022         if (pvolume_info->backupgid_specified) {
4023                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
4024                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
4025         }
4026         if (pvolume_info->override_uid)
4027                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
4028         if (pvolume_info->override_gid)
4029                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
4030         if (pvolume_info->dynperm)
4031                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
4032         if (pvolume_info->fsc)
4033                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
4034         if (pvolume_info->multiuser)
4035                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
4036                                             CIFS_MOUNT_NO_PERM);
4037         if (pvolume_info->strict_io)
4038                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
4039         if (pvolume_info->direct_io) {
4040                 cifs_dbg(FYI, "mounting share using direct i/o\n");
4041                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
4042         }
4043         if (pvolume_info->mfsymlinks) {
4044                 if (pvolume_info->sfu_emul) {
4045                         /*
4046                          * Our SFU ("Services for Unix" emulation does not allow
4047                          * creating symlinks but does allow reading existing SFU
4048                          * symlinks (it does allow both creating and reading SFU
4049                          * style mknod and FIFOs though). When "mfsymlinks" and
4050                          * "sfu" are both enabled at the same time, it allows
4051                          * reading both types of symlinks, but will only create
4052                          * them with mfsymlinks format. This allows better
4053                          * Apple compatibility (probably better for Samba too)
4054                          * while still recognizing old Windows style symlinks.
4055                          */
4056                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
4057                 }
4058                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
4059         }
4060
4061         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4062                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4063
4064         if (pvolume_info->prepath) {
4065                 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4066                 if (cifs_sb->prepath == NULL)
4067                         return -ENOMEM;
4068         }
4069
4070         return 0;
4071 }
4072
4073 void
4074 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4075 {
4076         kfree(volume_info->username);
4077         kzfree(volume_info->password);
4078         kfree(volume_info->UNC);
4079         kfree(volume_info->domainname);
4080         kfree(volume_info->iocharset);
4081         kfree(volume_info->prepath);
4082 }
4083
4084 void
4085 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4086 {
4087         if (!volume_info)
4088                 return;
4089         cifs_cleanup_volume_info_contents(volume_info);
4090         kfree(volume_info);
4091 }
4092
4093 /* Release all succeed connections */
4094 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4095                                    unsigned int xid,
4096                                    struct TCP_Server_Info *server,
4097                                    struct cifs_ses *ses, struct cifs_tcon *tcon)
4098 {
4099         int rc = 0;
4100
4101         if (tcon)
4102                 cifs_put_tcon(tcon);
4103         else if (ses)
4104                 cifs_put_smb_ses(ses);
4105         else if (server)
4106                 cifs_put_tcp_session(server, 0);
4107         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4108         free_xid(xid);
4109 }
4110
4111 /* Get connections for tcp, ses and tcon */
4112 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4113                            unsigned int *xid,
4114                            struct TCP_Server_Info **nserver,
4115                            struct cifs_ses **nses, struct cifs_tcon **ntcon)
4116 {
4117         int rc = 0;
4118         struct TCP_Server_Info *server;
4119         struct cifs_ses *ses;
4120         struct cifs_tcon *tcon;
4121
4122         *nserver = NULL;
4123         *nses = NULL;
4124         *ntcon = NULL;
4125
4126         *xid = get_xid();
4127
4128         /* get a reference to a tcp session */
4129         server = cifs_get_tcp_session(vol);
4130         if (IS_ERR(server)) {
4131                 rc = PTR_ERR(server);
4132                 return rc;
4133         }
4134
4135         *nserver = server;
4136
4137         if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4138                 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4139         else
4140                 server->max_credits = vol->max_credits;
4141
4142         /* get a reference to a SMB session */
4143         ses = cifs_get_smb_ses(server, vol);
4144         if (IS_ERR(ses)) {
4145                 rc = PTR_ERR(ses);
4146                 return rc;
4147         }
4148
4149         *nses = ses;
4150
4151         if ((vol->persistent == true) && (!(ses->server->capabilities &
4152                                             SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4153                 cifs_dbg(VFS, "persistent handles not supported by server\n");
4154                 return -EOPNOTSUPP;
4155         }
4156
4157         /* search for existing tcon to this server share */
4158         tcon = cifs_get_tcon(ses, vol);
4159         if (IS_ERR(tcon)) {
4160                 rc = PTR_ERR(tcon);
4161                 return rc;
4162         }
4163
4164         *ntcon = tcon;
4165
4166         /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4167         if (tcon->posix_extensions)
4168                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4169
4170         /* tell server which Unix caps we support */
4171         if (cap_unix(tcon->ses)) {
4172                 /*
4173                  * reset of caps checks mount to see if unix extensions disabled
4174                  * for just this mount.
4175                  */
4176                 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4177                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4178                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4179                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4180                         return -EACCES;
4181         } else
4182                 tcon->unix_ext = 0; /* server does not support them */
4183
4184         /* do not care if a following call succeed - informational */
4185         if (!tcon->pipe && server->ops->qfs_tcon)
4186                 server->ops->qfs_tcon(*xid, tcon);
4187
4188         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4189         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4190
4191         return 0;
4192 }
4193
4194 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4195                              struct cifs_tcon *tcon)
4196 {
4197         struct tcon_link *tlink;
4198
4199         /* hang the tcon off of the superblock */
4200         tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4201         if (tlink == NULL)
4202                 return -ENOMEM;
4203
4204         tlink->tl_uid = ses->linux_uid;
4205         tlink->tl_tcon = tcon;
4206         tlink->tl_time = jiffies;
4207         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4208         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4209
4210         cifs_sb->master_tlink = tlink;
4211         spin_lock(&cifs_sb->tlink_tree_lock);
4212         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4213         spin_unlock(&cifs_sb->tlink_tree_lock);
4214
4215         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4216                                 TLINK_IDLE_EXPIRE);
4217         return 0;
4218 }
4219
4220 #ifdef CONFIG_CIFS_DFS_UPCALL
4221 /*
4222  * cifs_build_path_to_root returns full path to root when we do not have an
4223  * exiting connection (tcon)
4224  */
4225 static char *
4226 build_unc_path_to_root(const struct smb_vol *vol,
4227                        const struct cifs_sb_info *cifs_sb, bool useppath)
4228 {
4229         char *full_path, *pos;
4230         unsigned int pplen = useppath && vol->prepath ?
4231                 strlen(vol->prepath) + 1 : 0;
4232         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4233
4234         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4235         if (full_path == NULL)
4236                 return ERR_PTR(-ENOMEM);
4237
4238         strncpy(full_path, vol->UNC, unc_len);
4239         pos = full_path + unc_len;
4240
4241         if (pplen) {
4242                 *pos = CIFS_DIR_SEP(cifs_sb);
4243                 strncpy(pos + 1, vol->prepath, pplen);
4244                 pos += pplen;
4245         }
4246
4247         *pos = '\0'; /* add trailing null */
4248         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4249         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4250         return full_path;
4251 }
4252
4253 /**
4254  * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4255  *
4256  *
4257  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4258  * to a string containing updated options for the submount.  Otherwise it
4259  * will be left untouched.
4260  *
4261  * Returns the rc from get_dfs_path to the caller, which can be used to
4262  * determine whether there were referrals.
4263  */
4264 static int
4265 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4266                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4267                     int check_prefix)
4268 {
4269         int rc;
4270         struct dfs_info3_param referral = {0};
4271         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
4272
4273         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4274                 return -EREMOTE;
4275
4276         full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4277         if (IS_ERR(full_path))
4278                 return PTR_ERR(full_path);
4279
4280         /* For DFS paths, skip the first '\' of the UNC */
4281         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
4282
4283         rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4284                             ref_path, &referral, NULL);
4285         if (!rc) {
4286                 char *fake_devname = NULL;
4287
4288                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4289                                                    full_path + 1, &referral,
4290                                                    &fake_devname);
4291                 free_dfs_info_param(&referral);
4292
4293                 if (IS_ERR(mdata)) {
4294                         rc = PTR_ERR(mdata);
4295                         mdata = NULL;
4296                 } else {
4297                         cifs_cleanup_volume_info_contents(volume_info);
4298                         rc = cifs_setup_volume_info(volume_info, mdata,
4299                                                     fake_devname, false);
4300                 }
4301                 kfree(fake_devname);
4302                 kfree(cifs_sb->mountdata);
4303                 cifs_sb->mountdata = mdata;
4304         }
4305         kfree(full_path);
4306         return rc;
4307 }
4308
4309 static inline int get_next_dfs_tgt(const char *path,
4310                                    struct dfs_cache_tgt_list *tgt_list,
4311                                    struct dfs_cache_tgt_iterator **tgt_it)
4312 {
4313         if (!*tgt_it)
4314                 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4315         else
4316                 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4317         return !*tgt_it ? -EHOSTDOWN : 0;
4318 }
4319
4320 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4321                            struct smb_vol *fake_vol, struct smb_vol *vol)
4322 {
4323         const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4324         int len = strlen(tgt) + 2;
4325         char *new_unc;
4326
4327         new_unc = kmalloc(len, GFP_KERNEL);
4328         if (!new_unc)
4329                 return -ENOMEM;
4330         scnprintf(new_unc, len, "\\%s", tgt);
4331
4332         kfree(vol->UNC);
4333         vol->UNC = new_unc;
4334
4335         if (fake_vol->prepath) {
4336                 kfree(vol->prepath);
4337                 vol->prepath = fake_vol->prepath;
4338                 fake_vol->prepath = NULL;
4339         }
4340         memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4341
4342         return 0;
4343 }
4344
4345 static int setup_dfs_tgt_conn(const char *path,
4346                               const struct dfs_cache_tgt_iterator *tgt_it,
4347                               struct cifs_sb_info *cifs_sb,
4348                               struct smb_vol *vol,
4349                               unsigned int *xid,
4350                               struct TCP_Server_Info **server,
4351                               struct cifs_ses **ses,
4352                               struct cifs_tcon **tcon)
4353 {
4354         int rc;
4355         struct dfs_info3_param ref = {0};
4356         char *mdata = NULL, *fake_devname = NULL;
4357         struct smb_vol fake_vol = {0};
4358
4359         cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4360
4361         rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4362         if (rc)
4363                 return rc;
4364
4365         mdata = cifs_compose_mount_options(cifs_sb->mountdata, path, &ref,
4366                                            &fake_devname);
4367         free_dfs_info_param(&ref);
4368
4369         if (IS_ERR(mdata)) {
4370                 rc = PTR_ERR(mdata);
4371                 mdata = NULL;
4372         } else {
4373                 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4374                 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4375                                             false);
4376         }
4377         kfree(mdata);
4378         kfree(fake_devname);
4379
4380         if (!rc) {
4381                 /*
4382                  * We use a 'fake_vol' here because we need pass it down to the
4383                  * mount_{get,put} functions to test connection against new DFS
4384                  * targets.
4385                  */
4386                 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4387                 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4388                                      tcon);
4389                 if (!rc) {
4390                         /*
4391                          * We were able to connect to new target server.
4392                          * Update current volume info with new target server.
4393                          */
4394                         rc = update_vol_info(tgt_it, &fake_vol, vol);
4395                 }
4396         }
4397         cifs_cleanup_volume_info_contents(&fake_vol);
4398         return rc;
4399 }
4400
4401 static int mount_do_dfs_failover(const char *path,
4402                                  struct cifs_sb_info *cifs_sb,
4403                                  struct smb_vol *vol,
4404                                  struct cifs_ses *root_ses,
4405                                  unsigned int *xid,
4406                                  struct TCP_Server_Info **server,
4407                                  struct cifs_ses **ses,
4408                                  struct cifs_tcon **tcon)
4409 {
4410         int rc;
4411         struct dfs_cache_tgt_list tgt_list;
4412         struct dfs_cache_tgt_iterator *tgt_it = NULL;
4413
4414         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4415                 return -EOPNOTSUPP;
4416
4417         rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4418         if (rc)
4419                 return rc;
4420
4421         for (;;) {
4422                 /* Get next DFS target server - if any */
4423                 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4424                 if (rc)
4425                         break;
4426                 /* Connect to next DFS target */
4427                 rc = setup_dfs_tgt_conn(path, tgt_it, cifs_sb, vol, xid, server,
4428                                         ses, tcon);
4429                 if (!rc || rc == -EACCES || rc == -EOPNOTSUPP)
4430                         break;
4431         }
4432         if (!rc) {
4433                 /*
4434                  * Update DFS target hint in DFS referral cache with the target
4435                  * server we successfully reconnected to.
4436                  */
4437                 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4438                                               cifs_sb->local_nls,
4439                                               cifs_remap(cifs_sb), path,
4440                                               tgt_it);
4441         }
4442         dfs_cache_free_tgts(&tgt_list);
4443         return rc;
4444 }
4445 #endif
4446
4447 int
4448 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4449                         const char *devname, bool is_smb3)
4450 {
4451         int rc = 0;
4452
4453         if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4454                 return -EINVAL;
4455
4456         if (volume_info->nullauth) {
4457                 cifs_dbg(FYI, "Anonymous login\n");
4458                 kfree(volume_info->username);
4459                 volume_info->username = NULL;
4460         } else if (volume_info->username) {
4461                 /* BB fixme parse for domain name here */
4462                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4463         } else {
4464                 cifs_dbg(VFS, "No username specified\n");
4465         /* In userspace mount helper we can get user name from alternate
4466            locations such as env variables and files on disk */
4467                 return -EINVAL;
4468         }
4469
4470         /* this is needed for ASCII cp to Unicode converts */
4471         if (volume_info->iocharset == NULL) {
4472                 /* load_nls_default cannot return null */
4473                 volume_info->local_nls = load_nls_default();
4474         } else {
4475                 volume_info->local_nls = load_nls(volume_info->iocharset);
4476                 if (volume_info->local_nls == NULL) {
4477                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4478                                  volume_info->iocharset);
4479                         return -ELIBACC;
4480                 }
4481         }
4482
4483         return rc;
4484 }
4485
4486 struct smb_vol *
4487 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4488 {
4489         int rc;
4490         struct smb_vol *volume_info;
4491
4492         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4493         if (!volume_info)
4494                 return ERR_PTR(-ENOMEM);
4495
4496         rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4497         if (rc) {
4498                 cifs_cleanup_volume_info(volume_info);
4499                 volume_info = ERR_PTR(rc);
4500         }
4501
4502         return volume_info;
4503 }
4504
4505 static int
4506 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4507                                         unsigned int xid,
4508                                         struct cifs_tcon *tcon,
4509                                         struct cifs_sb_info *cifs_sb,
4510                                         char *full_path,
4511                                         int added_treename)
4512 {
4513         int rc;
4514         char *s;
4515         char sep, tmp;
4516         int skip = added_treename ? 1 : 0;
4517
4518         sep = CIFS_DIR_SEP(cifs_sb);
4519         s = full_path;
4520
4521         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4522         while (rc == 0) {
4523                 /* skip separators */
4524                 while (*s == sep)
4525                         s++;
4526                 if (!*s)
4527                         break;
4528                 /* next separator */
4529                 while (*s && *s != sep)
4530                         s++;
4531                 /*
4532                  * if the treename is added, we then have to skip the first
4533                  * part within the separators
4534                  */
4535                 if (skip) {
4536                         skip = 0;
4537                         continue;
4538                 }
4539                 /*
4540                  * temporarily null-terminate the path at the end of
4541                  * the current component
4542                  */
4543                 tmp = *s;
4544                 *s = 0;
4545                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4546                                                      full_path);
4547                 *s = tmp;
4548         }
4549         return rc;
4550 }
4551
4552 /*
4553  * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4554  * otherwise 0.
4555  */
4556 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4557                           const unsigned int xid,
4558                           struct TCP_Server_Info *server,
4559                           struct cifs_tcon *tcon)
4560 {
4561         int rc;
4562         char *full_path;
4563
4564         if (!server->ops->is_path_accessible)
4565                 return -EOPNOTSUPP;
4566
4567         /*
4568          * cifs_build_path_to_root works only when we have a valid tcon
4569          */
4570         full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4571                                             tcon->Flags & SMB_SHARE_IS_IN_DFS);
4572         if (full_path == NULL)
4573                 return -ENOMEM;
4574
4575         cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4576
4577         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4578                                              full_path);
4579         if (rc != 0 && rc != -EREMOTE) {
4580                 kfree(full_path);
4581                 return rc;
4582         }
4583
4584         if (rc != -EREMOTE) {
4585                 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4586                         cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
4587                 if (rc != 0) {
4588                         cifs_dbg(VFS, "cannot query dirs between root and final path, "
4589                                  "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4590                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4591                         rc = 0;
4592                 }
4593         }
4594
4595         kfree(full_path);
4596         return rc;
4597 }
4598
4599 #ifdef CONFIG_CIFS_DFS_UPCALL
4600 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4601 {
4602         int rc = 0;
4603         unsigned int xid;
4604         struct cifs_ses *ses;
4605         struct cifs_tcon *root_tcon = NULL;
4606         struct cifs_tcon *tcon = NULL;
4607         struct TCP_Server_Info *server;
4608         char *root_path = NULL, *full_path = NULL;
4609         char *old_mountdata, *origin_mountdata = NULL;
4610         int count;
4611
4612         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4613         if (!rc && tcon) {
4614                 /* If not a standalone DFS root, then check if path is remote */
4615                 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls,
4616                                     cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4617                                     NULL);
4618                 if (rc) {
4619                         rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4620                         if (!rc)
4621                                 goto out;
4622                         if (rc != -EREMOTE)
4623                                 goto error;
4624                 }
4625         }
4626         /*
4627          * If first DFS target server went offline and we failed to connect it,
4628          * server and ses pointers are NULL at this point, though we still have
4629          * chance to get a cached DFS referral in expand_dfs_referral() and
4630          * retry next target available in it.
4631          *
4632          * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4633          * performed against DFS path and *no* requests will be sent to server
4634          * for any new DFS referrals. Hence it's safe to skip checking whether
4635          * server or ses ptr is NULL.
4636          */
4637         if (rc == -EACCES || rc == -EOPNOTSUPP)
4638                 goto error;
4639
4640         root_path = build_unc_path_to_root(vol, cifs_sb, false);
4641         if (IS_ERR(root_path)) {
4642                 rc = PTR_ERR(root_path);
4643                 root_path = NULL;
4644                 goto error;
4645         }
4646
4647         full_path = build_unc_path_to_root(vol, cifs_sb, true);
4648         if (IS_ERR(full_path)) {
4649                 rc = PTR_ERR(full_path);
4650                 full_path = NULL;
4651                 goto error;
4652         }
4653         /*
4654          * Perform an unconditional check for whether there are DFS
4655          * referrals for this path without prefix, to provide support
4656          * for DFS referrals from w2k8 servers which don't seem to respond
4657          * with PATH_NOT_COVERED to requests that include the prefix.
4658          * Chase the referral if found, otherwise continue normally.
4659          */
4660         old_mountdata = cifs_sb->mountdata;
4661         (void)expand_dfs_referral(xid, ses, vol, cifs_sb, false);
4662
4663         if (cifs_sb->mountdata == NULL) {
4664                 rc = -ENOENT;
4665                 goto error;
4666         }
4667
4668         /* Save DFS root volume information for DFS refresh worker */
4669         origin_mountdata = kstrndup(cifs_sb->mountdata,
4670                                     strlen(cifs_sb->mountdata), GFP_KERNEL);
4671         if (!origin_mountdata) {
4672                 rc = -ENOMEM;
4673                 goto error;
4674         }
4675
4676         if (cifs_sb->mountdata != old_mountdata) {
4677                 /* If we were redirected, reconnect to new target server */
4678                 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4679                 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4680         }
4681         if (rc) {
4682                 if (rc == -EACCES || rc == -EOPNOTSUPP)
4683                         goto error;
4684                 /* Perform DFS failover to any other DFS targets */
4685                 rc = mount_do_dfs_failover(root_path + 1, cifs_sb, vol, NULL,
4686                                            &xid, &server, &ses, &tcon);
4687                 if (rc)
4688                         goto error;
4689         }
4690
4691         kfree(root_path);
4692         root_path = build_unc_path_to_root(vol, cifs_sb, false);
4693         if (IS_ERR(root_path)) {
4694                 rc = PTR_ERR(root_path);
4695                 root_path = NULL;
4696                 goto error;
4697         }
4698         /* Cache out resolved root server */
4699         (void)dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4700                              root_path + 1, NULL, NULL);
4701         /*
4702          * Save root tcon for additional DFS requests to update or create a new
4703          * DFS cache entry, or even perform DFS failover.
4704          */
4705         spin_lock(&cifs_tcp_ses_lock);
4706         tcon->tc_count++;
4707         tcon->dfs_path = root_path;
4708         root_path = NULL;
4709         tcon->remap = cifs_remap(cifs_sb);
4710         spin_unlock(&cifs_tcp_ses_lock);
4711
4712         root_tcon = tcon;
4713
4714         for (count = 1; ;) {
4715                 if (!rc && tcon) {
4716                         rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4717                         if (!rc || rc != -EREMOTE)
4718                                 break;
4719                 }
4720                 /*
4721                  * BB: when we implement proper loop detection,
4722                  *     we will remove this check. But now we need it
4723                  *     to prevent an indefinite loop if 'DFS tree' is
4724                  *     misconfigured (i.e. has loops).
4725                  */
4726                 if (count++ > MAX_NESTED_LINKS) {
4727                         rc = -ELOOP;
4728                         break;
4729                 }
4730
4731                 kfree(full_path);
4732                 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4733                 if (IS_ERR(full_path)) {
4734                         rc = PTR_ERR(full_path);
4735                         full_path = NULL;
4736                         break;
4737                 }
4738
4739                 old_mountdata = cifs_sb->mountdata;
4740                 rc = expand_dfs_referral(xid, root_tcon->ses, vol, cifs_sb,
4741                                          true);
4742                 if (rc)
4743                         break;
4744
4745                 if (cifs_sb->mountdata != old_mountdata) {
4746                         mount_put_conns(cifs_sb, xid, server, ses, tcon);
4747                         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses,
4748                                              &tcon);
4749                 }
4750                 if (rc) {
4751                         if (rc == -EACCES || rc == -EOPNOTSUPP)
4752                                 break;
4753                         /* Perform DFS failover to any other DFS targets */
4754                         rc = mount_do_dfs_failover(full_path + 1, cifs_sb, vol,
4755                                                    root_tcon->ses, &xid,
4756                                                    &server, &ses, &tcon);
4757                         if (rc == -EACCES || rc == -EOPNOTSUPP || !server ||
4758                             !ses)
4759                                 goto error;
4760                 }
4761         }
4762         cifs_put_tcon(root_tcon);
4763
4764         if (rc)
4765                 goto error;
4766
4767         spin_lock(&cifs_tcp_ses_lock);
4768         if (!tcon->dfs_path) {
4769                 /* Save full path in new tcon to do failover when reconnecting tcons */
4770                 tcon->dfs_path = full_path;
4771                 full_path = NULL;
4772                 tcon->remap = cifs_remap(cifs_sb);
4773         }
4774         cifs_sb->origin_fullpath = kstrndup(tcon->dfs_path,
4775                                             strlen(tcon->dfs_path),
4776                                             GFP_ATOMIC);
4777         if (!cifs_sb->origin_fullpath) {
4778                 spin_unlock(&cifs_tcp_ses_lock);
4779                 rc = -ENOMEM;
4780                 goto error;
4781         }
4782         spin_unlock(&cifs_tcp_ses_lock);
4783
4784         rc = dfs_cache_add_vol(origin_mountdata, vol, cifs_sb->origin_fullpath);
4785         if (rc) {
4786                 kfree(cifs_sb->origin_fullpath);
4787                 goto error;
4788         }
4789         /*
4790          * After reconnecting to a different server, unique ids won't
4791          * match anymore, so we disable serverino. This prevents
4792          * dentry revalidation to think the dentry are stale (ESTALE).
4793          */
4794         cifs_autodisable_serverino(cifs_sb);
4795 out:
4796         free_xid(xid);
4797         return mount_setup_tlink(cifs_sb, ses, tcon);
4798
4799 error:
4800         kfree(full_path);
4801         kfree(root_path);
4802         kfree(origin_mountdata);
4803         mount_put_conns(cifs_sb, xid, server, ses, tcon);
4804         return rc;
4805 }
4806 #else
4807 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4808 {
4809         int rc = 0;
4810         unsigned int xid;
4811         struct cifs_ses *ses;
4812         struct cifs_tcon *tcon;
4813         struct TCP_Server_Info *server;
4814
4815         rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4816         if (rc)
4817                 goto error;
4818
4819         if (tcon) {
4820                 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4821                 if (rc == -EREMOTE)
4822                         rc = -EOPNOTSUPP;
4823                 if (rc)
4824                         goto error;
4825         }
4826
4827         free_xid(xid);
4828
4829         return mount_setup_tlink(cifs_sb, ses, tcon);
4830
4831 error:
4832         mount_put_conns(cifs_sb, xid, server, ses, tcon);
4833         return rc;
4834 }
4835 #endif
4836
4837 /*
4838  * Issue a TREE_CONNECT request.
4839  */
4840 int
4841 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
4842          const char *tree, struct cifs_tcon *tcon,
4843          const struct nls_table *nls_codepage)
4844 {
4845         struct smb_hdr *smb_buffer;
4846         struct smb_hdr *smb_buffer_response;
4847         TCONX_REQ *pSMB;
4848         TCONX_RSP *pSMBr;
4849         unsigned char *bcc_ptr;
4850         int rc = 0;
4851         int length;
4852         __u16 bytes_left, count;
4853
4854         if (ses == NULL)
4855                 return -EIO;
4856
4857         smb_buffer = cifs_buf_get();
4858         if (smb_buffer == NULL)
4859                 return -ENOMEM;
4860
4861         smb_buffer_response = smb_buffer;
4862
4863         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
4864                         NULL /*no tid */ , 4 /*wct */ );
4865
4866         smb_buffer->Mid = get_next_mid(ses->server);
4867         smb_buffer->Uid = ses->Suid;
4868         pSMB = (TCONX_REQ *) smb_buffer;
4869         pSMBr = (TCONX_RSP *) smb_buffer_response;
4870
4871         pSMB->AndXCommand = 0xFF;
4872         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
4873         bcc_ptr = &pSMB->Password[0];
4874         if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
4875                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
4876                 *bcc_ptr = 0; /* password is null byte */
4877                 bcc_ptr++;              /* skip password */
4878                 /* already aligned so no need to do it below */
4879         } else {
4880                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
4881                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
4882                    specified as required (when that support is added to
4883                    the vfs in the future) as only NTLM or the much
4884                    weaker LANMAN (which we do not send by default) is accepted
4885                    by Samba (not sure whether other servers allow
4886                    NTLMv2 password here) */
4887 #ifdef CONFIG_CIFS_WEAK_PW_HASH
4888                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
4889                     (ses->sectype == LANMAN))
4890                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
4891                                          ses->server->sec_mode &
4892                                             SECMODE_PW_ENCRYPT ? true : false,
4893                                          bcc_ptr);
4894                 else
4895 #endif /* CIFS_WEAK_PW_HASH */
4896                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
4897                                         bcc_ptr, nls_codepage);
4898                 if (rc) {
4899                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
4900                                  __func__, rc);
4901                         cifs_buf_release(smb_buffer);
4902                         return rc;
4903                 }
4904
4905                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
4906                 if (ses->capabilities & CAP_UNICODE) {
4907                         /* must align unicode strings */
4908                         *bcc_ptr = 0; /* null byte password */
4909                         bcc_ptr++;
4910                 }
4911         }
4912
4913         if (ses->server->sign)
4914                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4915
4916         if (ses->capabilities & CAP_STATUS32) {
4917                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4918         }
4919         if (ses->capabilities & CAP_DFS) {
4920                 smb_buffer->Flags2 |= SMBFLG2_DFS;
4921         }
4922         if (ses->capabilities & CAP_UNICODE) {
4923                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4924                 length =
4925                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4926                         6 /* max utf8 char length in bytes */ *
4927                         (/* server len*/ + 256 /* share len */), nls_codepage);
4928                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
4929                 bcc_ptr += 2;   /* skip trailing null */
4930         } else {                /* ASCII */
4931                 strcpy(bcc_ptr, tree);
4932                 bcc_ptr += strlen(tree) + 1;
4933         }
4934         strcpy(bcc_ptr, "?????");
4935         bcc_ptr += strlen("?????");
4936         bcc_ptr += 1;
4937         count = bcc_ptr - &pSMB->Password[0];
4938         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4939                                         pSMB->hdr.smb_buf_length) + count);
4940         pSMB->ByteCount = cpu_to_le16(count);
4941
4942         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4943                          0);
4944
4945         /* above now done in SendReceive */
4946         if (rc == 0) {
4947                 bool is_unicode;
4948
4949                 tcon->tidStatus = CifsGood;
4950                 tcon->need_reconnect = false;
4951                 tcon->tid = smb_buffer_response->Tid;
4952                 bcc_ptr = pByteArea(smb_buffer_response);
4953                 bytes_left = get_bcc(smb_buffer_response);
4954                 length = strnlen(bcc_ptr, bytes_left - 2);
4955                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4956                         is_unicode = true;
4957                 else
4958                         is_unicode = false;
4959
4960
4961                 /* skip service field (NB: this field is always ASCII) */
4962                 if (length == 3) {
4963                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4964                             (bcc_ptr[2] == 'C')) {
4965                                 cifs_dbg(FYI, "IPC connection\n");
4966                                 tcon->ipc = true;
4967                                 tcon->pipe = true;
4968                         }
4969                 } else if (length == 2) {
4970                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4971                                 /* the most common case */
4972                                 cifs_dbg(FYI, "disk share connection\n");
4973                         }
4974                 }
4975                 bcc_ptr += length + 1;
4976                 bytes_left -= (length + 1);
4977                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4978
4979                 /* mostly informational -- no need to fail on error here */
4980                 kfree(tcon->nativeFileSystem);
4981                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4982                                                       bytes_left, is_unicode,
4983                                                       nls_codepage);
4984
4985                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4986
4987                 if ((smb_buffer_response->WordCount == 3) ||
4988                          (smb_buffer_response->WordCount == 7))
4989                         /* field is in same location */
4990                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4991                 else
4992                         tcon->Flags = 0;
4993                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4994         }
4995
4996         cifs_buf_release(smb_buffer);
4997         return rc;
4998 }
4999
5000 static void delayed_free(struct rcu_head *p)
5001 {
5002         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
5003         unload_nls(sbi->local_nls);
5004         kfree(sbi);
5005 }
5006
5007 void
5008 cifs_umount(struct cifs_sb_info *cifs_sb)
5009 {
5010         struct rb_root *root = &cifs_sb->tlink_tree;
5011         struct rb_node *node;
5012         struct tcon_link *tlink;
5013
5014         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
5015
5016         spin_lock(&cifs_sb->tlink_tree_lock);
5017         while ((node = rb_first(root))) {
5018                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5019                 cifs_get_tlink(tlink);
5020                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5021                 rb_erase(node, root);
5022
5023                 spin_unlock(&cifs_sb->tlink_tree_lock);
5024                 cifs_put_tlink(tlink);
5025                 spin_lock(&cifs_sb->tlink_tree_lock);
5026         }
5027         spin_unlock(&cifs_sb->tlink_tree_lock);
5028
5029         kfree(cifs_sb->mountdata);
5030         kfree(cifs_sb->prepath);
5031 #ifdef CONFIG_CIFS_DFS_UPCALL
5032         dfs_cache_del_vol(cifs_sb->origin_fullpath);
5033         kfree(cifs_sb->origin_fullpath);
5034 #endif
5035         call_rcu(&cifs_sb->rcu, delayed_free);
5036 }
5037
5038 int
5039 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
5040 {
5041         int rc = 0;
5042         struct TCP_Server_Info *server = ses->server;
5043
5044         if (!server->ops->need_neg || !server->ops->negotiate)
5045                 return -ENOSYS;
5046
5047         /* only send once per connect */
5048         if (!server->ops->need_neg(server))
5049                 return 0;
5050
5051         rc = server->ops->negotiate(xid, ses);
5052         if (rc == 0) {
5053                 spin_lock(&GlobalMid_Lock);
5054                 if (server->tcpStatus == CifsNeedNegotiate)
5055                         server->tcpStatus = CifsGood;
5056                 else
5057                         rc = -EHOSTDOWN;
5058                 spin_unlock(&GlobalMid_Lock);
5059         }
5060
5061         return rc;
5062 }
5063
5064 int
5065 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
5066                    struct nls_table *nls_info)
5067 {
5068         int rc = -ENOSYS;
5069         struct TCP_Server_Info *server = ses->server;
5070
5071         ses->capabilities = server->capabilities;
5072         if (linuxExtEnabled == 0)
5073                 ses->capabilities &= (~server->vals->cap_unix);
5074
5075         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5076                  server->sec_mode, server->capabilities, server->timeAdj);
5077
5078         if (ses->auth_key.response) {
5079                 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5080                          ses->auth_key.response);
5081                 kfree(ses->auth_key.response);
5082                 ses->auth_key.response = NULL;
5083                 ses->auth_key.len = 0;
5084         }
5085
5086         if (server->ops->sess_setup)
5087                 rc = server->ops->sess_setup(xid, ses, nls_info);
5088
5089         if (rc)
5090                 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5091
5092         return rc;
5093 }
5094
5095 static int
5096 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5097 {
5098         vol->sectype = ses->sectype;
5099
5100         /* krb5 is special, since we don't need username or pw */
5101         if (vol->sectype == Kerberos)
5102                 return 0;
5103
5104         return cifs_set_cifscreds(vol, ses);
5105 }
5106
5107 static struct cifs_tcon *
5108 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5109 {
5110         int rc;
5111         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5112         struct cifs_ses *ses;
5113         struct cifs_tcon *tcon = NULL;
5114         struct smb_vol *vol_info;
5115
5116         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5117         if (vol_info == NULL)
5118                 return ERR_PTR(-ENOMEM);
5119
5120         vol_info->local_nls = cifs_sb->local_nls;
5121         vol_info->linux_uid = fsuid;
5122         vol_info->cred_uid = fsuid;
5123         vol_info->UNC = master_tcon->treeName;
5124         vol_info->retry = master_tcon->retry;
5125         vol_info->nocase = master_tcon->nocase;
5126         vol_info->nohandlecache = master_tcon->nohandlecache;
5127         vol_info->local_lease = master_tcon->local_lease;
5128         vol_info->no_linux_ext = !master_tcon->unix_ext;
5129         vol_info->sectype = master_tcon->ses->sectype;
5130         vol_info->sign = master_tcon->ses->sign;
5131
5132         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5133         if (rc) {
5134                 tcon = ERR_PTR(rc);
5135                 goto out;
5136         }
5137
5138         /* get a reference for the same TCP session */
5139         spin_lock(&cifs_tcp_ses_lock);
5140         ++master_tcon->ses->server->srv_count;
5141         spin_unlock(&cifs_tcp_ses_lock);
5142
5143         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5144         if (IS_ERR(ses)) {
5145                 tcon = (struct cifs_tcon *)ses;
5146                 cifs_put_tcp_session(master_tcon->ses->server, 0);
5147                 goto out;
5148         }
5149
5150         tcon = cifs_get_tcon(ses, vol_info);
5151         if (IS_ERR(tcon)) {
5152                 cifs_put_smb_ses(ses);
5153                 goto out;
5154         }
5155
5156         /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
5157         if (tcon->posix_extensions)
5158                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
5159
5160         if (cap_unix(ses))
5161                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5162
5163 out:
5164         kfree(vol_info->username);
5165         kzfree(vol_info->password);
5166         kfree(vol_info);
5167
5168         return tcon;
5169 }
5170
5171 struct cifs_tcon *
5172 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5173 {
5174         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5175 }
5176
5177 /* find and return a tlink with given uid */
5178 static struct tcon_link *
5179 tlink_rb_search(struct rb_root *root, kuid_t uid)
5180 {
5181         struct rb_node *node = root->rb_node;
5182         struct tcon_link *tlink;
5183
5184         while (node) {
5185                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5186
5187                 if (uid_gt(tlink->tl_uid, uid))
5188                         node = node->rb_left;
5189                 else if (uid_lt(tlink->tl_uid, uid))
5190                         node = node->rb_right;
5191                 else
5192                         return tlink;
5193         }
5194         return NULL;
5195 }
5196
5197 /* insert a tcon_link into the tree */
5198 static void
5199 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5200 {
5201         struct rb_node **new = &(root->rb_node), *parent = NULL;
5202         struct tcon_link *tlink;
5203
5204         while (*new) {
5205                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5206                 parent = *new;
5207
5208                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5209                         new = &((*new)->rb_left);
5210                 else
5211                         new = &((*new)->rb_right);
5212         }
5213
5214         rb_link_node(&new_tlink->tl_rbnode, parent, new);
5215         rb_insert_color(&new_tlink->tl_rbnode, root);
5216 }
5217
5218 /*
5219  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5220  * current task.
5221  *
5222  * If the superblock doesn't refer to a multiuser mount, then just return
5223  * the master tcon for the mount.
5224  *
5225  * First, search the rbtree for an existing tcon for this fsuid. If one
5226  * exists, then check to see if it's pending construction. If it is then wait
5227  * for construction to complete. Once it's no longer pending, check to see if
5228  * it failed and either return an error or retry construction, depending on
5229  * the timeout.
5230  *
5231  * If one doesn't exist then insert a new tcon_link struct into the tree and
5232  * try to construct a new one.
5233  */
5234 struct tcon_link *
5235 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5236 {
5237         int ret;
5238         kuid_t fsuid = current_fsuid();
5239         struct tcon_link *tlink, *newtlink;
5240
5241         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5242                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5243
5244         spin_lock(&cifs_sb->tlink_tree_lock);
5245         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5246         if (tlink)
5247                 cifs_get_tlink(tlink);
5248         spin_unlock(&cifs_sb->tlink_tree_lock);
5249
5250         if (tlink == NULL) {
5251                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5252                 if (newtlink == NULL)
5253                         return ERR_PTR(-ENOMEM);
5254                 newtlink->tl_uid = fsuid;
5255                 newtlink->tl_tcon = ERR_PTR(-EACCES);
5256                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5257                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5258                 cifs_get_tlink(newtlink);
5259
5260                 spin_lock(&cifs_sb->tlink_tree_lock);
5261                 /* was one inserted after previous search? */
5262                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5263                 if (tlink) {
5264                         cifs_get_tlink(tlink);
5265                         spin_unlock(&cifs_sb->tlink_tree_lock);
5266                         kfree(newtlink);
5267                         goto wait_for_construction;
5268                 }
5269                 tlink = newtlink;
5270                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5271                 spin_unlock(&cifs_sb->tlink_tree_lock);
5272         } else {
5273 wait_for_construction:
5274                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5275                                   TASK_INTERRUPTIBLE);
5276                 if (ret) {
5277                         cifs_put_tlink(tlink);
5278                         return ERR_PTR(-ERESTARTSYS);
5279                 }
5280
5281                 /* if it's good, return it */
5282                 if (!IS_ERR(tlink->tl_tcon))
5283                         return tlink;
5284
5285                 /* return error if we tried this already recently */
5286                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5287                         cifs_put_tlink(tlink);
5288                         return ERR_PTR(-EACCES);
5289                 }
5290
5291                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5292                         goto wait_for_construction;
5293         }
5294
5295         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5296         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5297         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5298
5299         if (IS_ERR(tlink->tl_tcon)) {
5300                 cifs_put_tlink(tlink);
5301                 return ERR_PTR(-EACCES);
5302         }
5303
5304         return tlink;
5305 }
5306
5307 /*
5308  * periodic workqueue job that scans tcon_tree for a superblock and closes
5309  * out tcons.
5310  */
5311 static void
5312 cifs_prune_tlinks(struct work_struct *work)
5313 {
5314         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5315                                                     prune_tlinks.work);
5316         struct rb_root *root = &cifs_sb->tlink_tree;
5317         struct rb_node *node;
5318         struct rb_node *tmp;
5319         struct tcon_link *tlink;
5320
5321         /*
5322          * Because we drop the spinlock in the loop in order to put the tlink
5323          * it's not guarded against removal of links from the tree. The only
5324          * places that remove entries from the tree are this function and
5325          * umounts. Because this function is non-reentrant and is canceled
5326          * before umount can proceed, this is safe.
5327          */
5328         spin_lock(&cifs_sb->tlink_tree_lock);
5329         node = rb_first(root);
5330         while (node != NULL) {
5331                 tmp = node;
5332                 node = rb_next(tmp);
5333                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5334
5335                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5336                     atomic_read(&tlink->tl_count) != 0 ||
5337                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5338                         continue;
5339
5340                 cifs_get_tlink(tlink);
5341                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5342                 rb_erase(tmp, root);
5343
5344                 spin_unlock(&cifs_sb->tlink_tree_lock);
5345                 cifs_put_tlink(tlink);
5346                 spin_lock(&cifs_sb->tlink_tree_lock);
5347         }
5348         spin_unlock(&cifs_sb->tlink_tree_lock);
5349
5350         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
5351                                 TLINK_IDLE_EXPIRE);
5352 }