fs/cifs/connect.c

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