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