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