fs/cifs/connect.c

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