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         spin_lock(&cifs_tcp_ses_lock);
 379         rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
 380                                   strlen(ipaddr));
 381         spin_unlock(&cifs_tcp_ses_lock);
 382         kfree(ipaddr);
 383
 384         return !rc ? -1 : 0;
 385 }
 386 #else
 387 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
 388 {
 389         return 0;
 390 }
 391 #endif
 392
 393 #ifdef CONFIG_CIFS_DFS_UPCALL
 394 /* These functions must be called with server->srv_mutex held */
 395 static void reconn_inval_dfs_target(struct TCP_Server_Info *server,
 396                                     struct cifs_sb_info *cifs_sb,
 397                                     struct dfs_cache_tgt_list *tgt_list,
 398                                     struct dfs_cache_tgt_iterator **tgt_it)
 399 {
 400         const char *name;
 401
 402         if (!cifs_sb || !cifs_sb->origin_fullpath || !tgt_list ||
 403             !server->nr_targets)
 404                 return;
 405
 406         if (!*tgt_it) {
 407                 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
 408         } else {
 409                 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
 410                 if (!*tgt_it)
 411                         *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
 412         }
 413
 414         cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
 415
 416         name = dfs_cache_get_tgt_name(*tgt_it);
 417
 418         kfree(server->hostname);
 419
 420         server->hostname = extract_hostname(name);
 421         if (IS_ERR(server->hostname)) {
 422                 cifs_dbg(FYI,
 423                          "%s: failed to extract hostname from target: %ld\n",
 424                          __func__, PTR_ERR(server->hostname));
 425         }
 426 }
 427
 428 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
 429                                            struct dfs_cache_tgt_list *tl,
 430                                            struct dfs_cache_tgt_iterator **it)
 431 {
 432         if (!cifs_sb->origin_fullpath)
 433                 return -EOPNOTSUPP;
 434         return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
 435 }
 436 #endif
 437
 438 /*
 439  * cifs tcp session reconnection
 440  *
 441  * mark tcp session as reconnecting so temporarily locked
 442  * mark all smb sessions as reconnecting for tcp session
 443  * reconnect tcp session
 444  * wake up waiters on reconnection? - (not needed currently)
 445  */
 446 int
 447 cifs_reconnect(struct TCP_Server_Info *server)
 448 {
 449         int rc = 0;
 450         struct list_head *tmp, *tmp2;
 451         struct cifs_ses *ses;
 452         struct cifs_tcon *tcon;
 453         struct mid_q_entry *mid_entry;
 454         struct list_head retry_list;
 455 #ifdef CONFIG_CIFS_DFS_UPCALL
 456         struct super_block *sb = NULL;
 457         struct cifs_sb_info *cifs_sb = NULL;
 458         struct dfs_cache_tgt_list tgt_list = {0};
 459         struct dfs_cache_tgt_iterator *tgt_it = NULL;
 460 #endif
 461
 462         spin_lock(&GlobalMid_Lock);
 463         server->nr_targets = 1;
 464 #ifdef CONFIG_CIFS_DFS_UPCALL
 465         spin_unlock(&GlobalMid_Lock);
 466         sb = cifs_get_tcp_super(server);
 467         if (IS_ERR(sb)) {
 468                 rc = PTR_ERR(sb);
 469                 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
 470                          __func__, rc);
 471                 sb = NULL;
 472         } else {
 473                 cifs_sb = CIFS_SB(sb);
 474
 475                 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list, &tgt_it);
 476                 if (rc && (rc != -EOPNOTSUPP)) {
 477                         cifs_server_dbg(VFS, "%s: no target servers for DFS failover\n",
 478                                  __func__);
 479                 } else {
 480                         server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
 481                 }
 482         }
 483         cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
 484                  server->nr_targets);
 485         spin_lock(&GlobalMid_Lock);
 486 #endif
 487         if (server->tcpStatus == CifsExiting) {
 488                 /* the demux thread will exit normally
 489                 next time through the loop */
 490                 spin_unlock(&GlobalMid_Lock);
 491 #ifdef CONFIG_CIFS_DFS_UPCALL
 492                 dfs_cache_free_tgts(&tgt_list);
 493                 cifs_put_tcp_super(sb);
 494 #endif
 495                 wake_up(&server->response_q);
 496                 return rc;
 497         } else
 498                 server->tcpStatus = CifsNeedReconnect;
 499         spin_unlock(&GlobalMid_Lock);
 500         server->maxBuf = 0;
 501         server->max_read = 0;
 502
 503         cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
 504         trace_smb3_reconnect(server->CurrentMid, server->hostname);
 505
 506         /* before reconnecting the tcp session, mark the smb session (uid)
 507                 and the tid bad so they are not used until reconnected */
 508         cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
 509                  __func__);
 510         spin_lock(&cifs_tcp_ses_lock);
 511         list_for_each(tmp, &server->smb_ses_list) {
 512                 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
 513                 ses->need_reconnect = true;
 514                 list_for_each(tmp2, &ses->tcon_list) {
 515                         tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
 516                         tcon->need_reconnect = true;
 517                 }
 518                 if (ses->tcon_ipc)
 519                         ses->tcon_ipc->need_reconnect = true;
 520         }
 521         spin_unlock(&cifs_tcp_ses_lock);
 522
 523         /* do not want to be sending data on a socket we are freeing */
 524         cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
 525         mutex_lock(&server->srv_mutex);
 526         if (server->ssocket) {
 527                 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
 528                          server->ssocket->state, server->ssocket->flags);
 529                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 530                 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
 531                          server->ssocket->state, server->ssocket->flags);
 532                 sock_release(server->ssocket);
 533                 server->ssocket = NULL;
 534         }
 535         server->sequence_number = 0;
 536         server->session_estab = false;
 537         kfree(server->session_key.response);
 538         server->session_key.response = NULL;
 539         server->session_key.len = 0;
 540         server->lstrp = jiffies;
 541
 542         /* mark submitted MIDs for retry and issue callback */
 543         INIT_LIST_HEAD(&retry_list);
 544         cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
 545         spin_lock(&GlobalMid_Lock);
 546         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 547                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 548                 kref_get(&mid_entry->refcount);
 549                 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 550                         mid_entry->mid_state = MID_RETRY_NEEDED;
 551                 list_move(&mid_entry->qhead, &retry_list);
 552                 mid_entry->mid_flags |= MID_DELETED;
 553         }
 554         spin_unlock(&GlobalMid_Lock);
 555         mutex_unlock(&server->srv_mutex);
 556
 557         cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
 558         list_for_each_safe(tmp, tmp2, &retry_list) {
 559                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 560                 list_del_init(&mid_entry->qhead);
 561                 mid_entry->callback(mid_entry);
 562                 cifs_mid_q_entry_release(mid_entry);
 563         }
 564
 565         if (cifs_rdma_enabled(server)) {
 566                 mutex_lock(&server->srv_mutex);
 567                 smbd_destroy(server);
 568                 mutex_unlock(&server->srv_mutex);
 569         }
 570
 571         do {
 572                 try_to_freeze();
 573
 574                 mutex_lock(&server->srv_mutex);
 575                 /*
 576                  * Set up next DFS target server (if any) for reconnect. If DFS
 577                  * feature is disabled, then we will retry last server we
 578                  * connected to before.
 579                  */
 580                 if (cifs_rdma_enabled(server))
 581                         rc = smbd_reconnect(server);
 582                 else
 583                         rc = generic_ip_connect(server);
 584                 if (rc) {
 585                         cifs_dbg(FYI, "reconnect error %d\n", rc);
 586 #ifdef CONFIG_CIFS_DFS_UPCALL
 587                         reconn_inval_dfs_target(server, cifs_sb, &tgt_list,
 588                                                 &tgt_it);
 589 #endif
 590                         rc = reconn_set_ipaddr(server);
 591                         if (rc) {
 592                                 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
 593                                          __func__, rc);
 594                         }
 595                         mutex_unlock(&server->srv_mutex);
 596                         msleep(3000);
 597                 } else {
 598                         atomic_inc(&tcpSesReconnectCount);
 599                         set_credits(server, 1);
 600                         spin_lock(&GlobalMid_Lock);
 601                         if (server->tcpStatus != CifsExiting)
 602                                 server->tcpStatus = CifsNeedNegotiate;
 603                         spin_unlock(&GlobalMid_Lock);
 604                         mutex_unlock(&server->srv_mutex);
 605                 }
 606         } while (server->tcpStatus == CifsNeedReconnect);
 607
 608 #ifdef CONFIG_CIFS_DFS_UPCALL
 609         if (tgt_it) {
 610                 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
 611                                                     tgt_it);
 612                 if (rc) {
 613                         cifs_server_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
 614                                  __func__, rc);
 615                 }
 616                 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
 617                 if (rc) {
 618                         cifs_server_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
 619                                  __func__, rc);
 620                 }
 621                 dfs_cache_free_tgts(&tgt_list);
 622
 623         }
 624
 625         cifs_put_tcp_super(sb);
 626 #endif
 627         if (server->tcpStatus == CifsNeedNegotiate)
 628                 mod_delayed_work(cifsiod_wq, &server->echo, 0);
 629
 630         wake_up(&server->response_q);
 631         return rc;
 632 }
 633
 634 static void
 635 cifs_echo_request(struct work_struct *work)
 636 {
 637         int rc;
 638         struct TCP_Server_Info *server = container_of(work,
 639                                         struct TCP_Server_Info, echo.work);
 640         unsigned long echo_interval;
 641
 642         /*
 643          * If we need to renegotiate, set echo interval to zero to
 644          * immediately call echo service where we can renegotiate.
 645          */
 646         if (server->tcpStatus == CifsNeedNegotiate)
 647                 echo_interval = 0;
 648         else
 649                 echo_interval = server->echo_interval;
 650
 651         /*
 652          * We cannot send an echo if it is disabled.
 653          * Also, no need to ping if we got a response recently.
 654          */
 655
 656         if (server->tcpStatus == CifsNeedReconnect ||
 657             server->tcpStatus == CifsExiting ||
 658             server->tcpStatus == CifsNew ||
 659             (server->ops->can_echo && !server->ops->can_echo(server)) ||
 660             time_before(jiffies, server->lstrp + echo_interval - HZ))
 661                 goto requeue_echo;
 662
 663         rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
 664         if (rc)
 665                 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
 666                          server->hostname);
 667
 668 requeue_echo:
 669         queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
 670 }
 671
 672 static bool
 673 allocate_buffers(struct TCP_Server_Info *server)
 674 {
 675         if (!server->bigbuf) {
 676                 server->bigbuf = (char *)cifs_buf_get();
 677                 if (!server->bigbuf) {
 678                         cifs_server_dbg(VFS, "No memory for large SMB response\n");
 679                         msleep(3000);
 680                         /* retry will check if exiting */
 681                         return false;
 682                 }
 683         } else if (server->large_buf) {
 684                 /* we are reusing a dirty large buf, clear its start */
 685                 memset(server->bigbuf, 0, HEADER_SIZE(server));
 686         }
 687
 688         if (!server->smallbuf) {
 689                 server->smallbuf = (char *)cifs_small_buf_get();
 690                 if (!server->smallbuf) {
 691                         cifs_server_dbg(VFS, "No memory for SMB response\n");
 692                         msleep(1000);
 693                         /* retry will check if exiting */
 694                         return false;
 695                 }
 696                 /* beginning of smb buffer is cleared in our buf_get */
 697         } else {
 698                 /* if existing small buf clear beginning */
 699                 memset(server->smallbuf, 0, HEADER_SIZE(server));
 700         }
 701
 702         return true;
 703 }
 704
 705 static bool
 706 server_unresponsive(struct TCP_Server_Info *server)
 707 {
 708         /*
 709          * We need to wait 3 echo intervals to make sure we handle such
 710          * situations right:
 711          * 1s  client sends a normal SMB request
 712          * 2s  client gets a response
 713          * 30s echo workqueue job pops, and decides we got a response recently
 714          *     and don't need to send another
 715          * ...
 716          * 65s kernel_recvmsg times out, and we see that we haven't gotten
 717          *     a response in >60s.
 718          */
 719         if ((server->tcpStatus == CifsGood ||
 720             server->tcpStatus == CifsNeedNegotiate) &&
 721             time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
 722                 cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
 723                          (3 * server->echo_interval) / HZ);
 724                 cifs_reconnect(server);
 725                 return true;
 726         }
 727
 728         return false;
 729 }
 730
 731 static inline bool
 732 zero_credits(struct TCP_Server_Info *server)
 733 {
 734         int val;
 735
 736         spin_lock(&server->req_lock);
 737         val = server->credits + server->echo_credits + server->oplock_credits;
 738         if (server->in_flight == 0 && val == 0) {
 739                 spin_unlock(&server->req_lock);
 740                 return true;
 741         }
 742         spin_unlock(&server->req_lock);
 743         return false;
 744 }
 745
 746 static int
 747 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
 748 {
 749         int length = 0;
 750         int total_read;
 751
 752         smb_msg->msg_control = NULL;
 753         smb_msg->msg_controllen = 0;
 754
 755         for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
 756                 try_to_freeze();
 757
 758                 /* reconnect if no credits and no requests in flight */
 759                 if (zero_credits(server)) {
 760                         cifs_reconnect(server);
 761                         return -ECONNABORTED;
 762                 }
 763
 764                 if (server_unresponsive(server))
 765                         return -ECONNABORTED;
 766                 if (cifs_rdma_enabled(server) && server->smbd_conn)
 767                         length = smbd_recv(server->smbd_conn, smb_msg);
 768                 else
 769                         length = sock_recvmsg(server->ssocket, smb_msg, 0);
 770
 771                 if (server->tcpStatus == CifsExiting)
 772                         return -ESHUTDOWN;
 773
 774                 if (server->tcpStatus == CifsNeedReconnect) {
 775                         cifs_reconnect(server);
 776                         return -ECONNABORTED;
 777                 }
 778
 779                 if (length == -ERESTARTSYS ||
 780                     length == -EAGAIN ||
 781                     length == -EINTR) {
 782                         /*
 783                          * Minimum sleep to prevent looping, allowing socket
 784                          * to clear and app threads to set tcpStatus
 785                          * CifsNeedReconnect if server hung.
 786                          */
 787                         usleep_range(1000, 2000);
 788                         length = 0;
 789                         continue;
 790                 }
 791
 792                 if (length <= 0) {
 793                         cifs_dbg(FYI, "Received no data or error: %d\n", length);
 794                         cifs_reconnect(server);
 795                         return -ECONNABORTED;
 796                 }
 797         }
 798         return total_read;
 799 }
 800
 801 int
 802 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
 803                       unsigned int to_read)
 804 {
 805         struct msghdr smb_msg;
 806         struct kvec iov = {.iov_base = buf, .iov_len = to_read};
 807         iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
 808
 809         return cifs_readv_from_socket(server, &smb_msg);
 810 }
 811
 812 int
 813 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
 814         unsigned int page_offset, unsigned int to_read)
 815 {
 816         struct msghdr smb_msg;
 817         struct bio_vec bv = {
 818                 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
 819         iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
 820         return cifs_readv_from_socket(server, &smb_msg);
 821 }
 822
 823 static bool
 824 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
 825 {
 826         /*
 827          * The first byte big endian of the length field,
 828          * is actually not part of the length but the type
 829          * with the most common, zero, as regular data.
 830          */
 831         switch (type) {
 832         case RFC1002_SESSION_MESSAGE:
 833                 /* Regular SMB response */
 834                 return true;
 835         case RFC1002_SESSION_KEEP_ALIVE:
 836                 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
 837                 break;
 838         case RFC1002_POSITIVE_SESSION_RESPONSE:
 839                 cifs_dbg(FYI, "RFC 1002 positive session response\n");
 840                 break;
 841         case RFC1002_NEGATIVE_SESSION_RESPONSE:
 842                 /*
 843                  * We get this from Windows 98 instead of an error on
 844                  * SMB negprot response.
 845                  */
 846                 cifs_dbg(FYI, "RFC 1002 negative session response\n");
 847                 /* give server a second to clean up */
 848                 msleep(1000);
 849                 /*
 850                  * Always try 445 first on reconnect since we get NACK
 851                  * on some if we ever connected to port 139 (the NACK
 852                  * is since we do not begin with RFC1001 session
 853                  * initialize frame).
 854                  */
 855                 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
 856                 cifs_reconnect(server);
 857                 break;
 858         default:
 859                 cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
 860                 cifs_reconnect(server);
 861         }
 862
 863         return false;
 864 }
 865
 866 void
 867 dequeue_mid(struct mid_q_entry *mid, bool malformed)
 868 {
 869 #ifdef CONFIG_CIFS_STATS2
 870         mid->when_received = jiffies;
 871 #endif
 872         spin_lock(&GlobalMid_Lock);
 873         if (!malformed)
 874                 mid->mid_state = MID_RESPONSE_RECEIVED;
 875         else
 876                 mid->mid_state = MID_RESPONSE_MALFORMED;
 877         /*
 878          * Trying to handle/dequeue a mid after the send_recv()
 879          * function has finished processing it is a bug.
 880          */
 881         if (mid->mid_flags & MID_DELETED)
 882                 printk_once(KERN_WARNING
 883                             "trying to dequeue a deleted mid\n");
 884         else {
 885                 list_del_init(&mid->qhead);
 886                 mid->mid_flags |= MID_DELETED;
 887         }
 888         spin_unlock(&GlobalMid_Lock);
 889 }
 890
 891 static unsigned int
 892 smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
 893 {
 894         struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
 895
 896         /*
 897          * SMB1 does not use credits.
 898          */
 899         if (server->vals->header_preamble_size)
 900                 return 0;
 901
 902         return le16_to_cpu(shdr->CreditRequest);
 903 }
 904
 905 static void
 906 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 907            char *buf, int malformed)
 908 {
 909         if (server->ops->check_trans2 &&
 910             server->ops->check_trans2(mid, server, buf, malformed))
 911                 return;
 912         mid->credits_received = smb2_get_credits_from_hdr(buf, server);
 913         mid->resp_buf = buf;
 914         mid->large_buf = server->large_buf;
 915         /* Was previous buf put in mpx struct for multi-rsp? */
 916         if (!mid->multiRsp) {
 917                 /* smb buffer will be freed by user thread */
 918                 if (server->large_buf)
 919                         server->bigbuf = NULL;
 920                 else
 921                         server->smallbuf = NULL;
 922         }
 923         dequeue_mid(mid, malformed);
 924 }
 925
 926 static void clean_demultiplex_info(struct TCP_Server_Info *server)
 927 {
 928         int length;
 929
 930         /* take it off the list, if it's not already */
 931         spin_lock(&cifs_tcp_ses_lock);
 932         list_del_init(&server->tcp_ses_list);
 933         spin_unlock(&cifs_tcp_ses_lock);
 934
 935         spin_lock(&GlobalMid_Lock);
 936         server->tcpStatus = CifsExiting;
 937         spin_unlock(&GlobalMid_Lock);
 938         wake_up_all(&server->response_q);
 939
 940         /* check if we have blocked requests that need to free */
 941         spin_lock(&server->req_lock);
 942         if (server->credits <= 0)
 943                 server->credits = 1;
 944         spin_unlock(&server->req_lock);
 945         /*
 946          * Although there should not be any requests blocked on this queue it
 947          * can not hurt to be paranoid and try to wake up requests that may
 948          * haven been blocked when more than 50 at time were on the wire to the
 949          * same server - they now will see the session is in exit state and get
 950          * out of SendReceive.
 951          */
 952         wake_up_all(&server->request_q);
 953         /* give those requests time to exit */
 954         msleep(125);
 955         if (cifs_rdma_enabled(server))
 956                 smbd_destroy(server);
 957         if (server->ssocket) {
 958                 sock_release(server->ssocket);
 959                 server->ssocket = NULL;
 960         }
 961
 962         if (!list_empty(&server->pending_mid_q)) {
 963                 struct list_head dispose_list;
 964                 struct mid_q_entry *mid_entry;
 965                 struct list_head *tmp, *tmp2;
 966
 967                 INIT_LIST_HEAD(&dispose_list);
 968                 spin_lock(&GlobalMid_Lock);
 969                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 970                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 971                         cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
 972                         kref_get(&mid_entry->refcount);
 973                         mid_entry->mid_state = MID_SHUTDOWN;
 974                         list_move(&mid_entry->qhead, &dispose_list);
 975                         mid_entry->mid_flags |= MID_DELETED;
 976                 }
 977                 spin_unlock(&GlobalMid_Lock);
 978
 979                 /* now walk dispose list and issue callbacks */
 980                 list_for_each_safe(tmp, tmp2, &dispose_list) {
 981                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 982                         cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
 983                         list_del_init(&mid_entry->qhead);
 984                         mid_entry->callback(mid_entry);
 985                         cifs_mid_q_entry_release(mid_entry);
 986                 }
 987                 /* 1/8th of sec is more than enough time for them to exit */
 988                 msleep(125);
 989         }
 990
 991         if (!list_empty(&server->pending_mid_q)) {
 992                 /*
 993                  * mpx threads have not exited yet give them at least the smb
 994                  * send timeout time for long ops.
 995                  *
 996                  * Due to delays on oplock break requests, we need to wait at
 997                  * least 45 seconds before giving up on a request getting a
 998                  * response and going ahead and killing cifsd.
 999                  */
1000                 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
1001                 msleep(46000);
1002                 /*
1003                  * If threads still have not exited they are probably never
1004                  * coming home not much else we can do but free the memory.
1005                  */
1006         }
1007
1008         kfree(server->hostname);
1009         kfree(server);
1010
1011         length = atomic_dec_return(&tcpSesAllocCount);
1012         if (length > 0)
1013                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1014 }
1015
1016 static int
1017 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1018 {
1019         int length;
1020         char *buf = server->smallbuf;
1021         unsigned int pdu_length = server->pdu_size;
1022
1023         /* make sure this will fit in a large buffer */
1024         if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
1025                 server->vals->header_preamble_size) {
1026                 cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
1027                 cifs_reconnect(server);
1028                 return -ECONNABORTED;
1029         }
1030
1031         /* switch to large buffer if too big for a small one */
1032         if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
1033                 server->large_buf = true;
1034                 memcpy(server->bigbuf, buf, server->total_read);
1035                 buf = server->bigbuf;
1036         }
1037
1038         /* now read the rest */
1039         length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
1040                                        pdu_length - HEADER_SIZE(server) + 1
1041                                        + server->vals->header_preamble_size);
1042
1043         if (length < 0)
1044                 return length;
1045         server->total_read += length;
1046
1047         dump_smb(buf, server->total_read);
1048
1049         return cifs_handle_standard(server, mid);
1050 }
1051
1052 int
1053 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1054 {
1055         char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1056         int length;
1057
1058         /*
1059          * We know that we received enough to get to the MID as we
1060          * checked the pdu_length earlier. Now check to see
1061          * if the rest of the header is OK. We borrow the length
1062          * var for the rest of the loop to avoid a new stack var.
1063          *
1064          * 48 bytes is enough to display the header and a little bit
1065          * into the payload for debugging purposes.
1066          */
1067         length = server->ops->check_message(buf, server->total_read, server);
1068         if (length != 0)
1069                 cifs_dump_mem("Bad SMB: ", buf,
1070                         min_t(unsigned int, server->total_read, 48));
1071
1072         if (server->ops->is_session_expired &&
1073             server->ops->is_session_expired(buf)) {
1074                 cifs_reconnect(server);
1075                 return -1;
1076         }
1077
1078         if (server->ops->is_status_pending &&
1079             server->ops->is_status_pending(buf, server))
1080                 return -1;
1081
1082         if (!mid)
1083                 return length;
1084
1085         handle_mid(mid, server, buf, length);
1086         return 0;
1087 }
1088
1089 static void
1090 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1091 {
1092         struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
1093
1094         /*
1095          * SMB1 does not use credits.
1096          */
1097         if (server->vals->header_preamble_size)
1098                 return;
1099
1100         if (shdr->CreditRequest) {
1101                 spin_lock(&server->req_lock);
1102                 server->credits += le16_to_cpu(shdr->CreditRequest);
1103                 spin_unlock(&server->req_lock);
1104                 wake_up(&server->request_q);
1105         }
1106 }
1107
1108
1109 static int
1110 cifs_demultiplex_thread(void *p)
1111 {
1112         int i, num_mids, length;
1113         struct TCP_Server_Info *server = p;
1114         unsigned int pdu_length;
1115         unsigned int next_offset;
1116         char *buf = NULL;
1117         struct task_struct *task_to_wake = NULL;
1118         struct mid_q_entry *mids[MAX_COMPOUND];
1119         char *bufs[MAX_COMPOUND];
1120         unsigned int noreclaim_flag;
1121
1122         noreclaim_flag = memalloc_noreclaim_save();
1123         cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1124
1125         length = atomic_inc_return(&tcpSesAllocCount);
1126         if (length > 1)
1127                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1128
1129         set_freezable();
1130         allow_kernel_signal(SIGKILL);
1131         while (server->tcpStatus != CifsExiting) {
1132                 if (try_to_freeze())
1133                         continue;
1134
1135                 if (!allocate_buffers(server))
1136                         continue;
1137
1138                 server->large_buf = false;
1139                 buf = server->smallbuf;
1140                 pdu_length = 4; /* enough to get RFC1001 header */
1141
1142                 length = cifs_read_from_socket(server, buf, pdu_length);
1143                 if (length < 0)
1144                         continue;
1145
1146                 if (server->vals->header_preamble_size == 0)
1147                         server->total_read = 0;
1148                 else
1149                         server->total_read = length;
1150
1151                 /*
1152                  * The right amount was read from socket - 4 bytes,
1153                  * so we can now interpret the length field.
1154                  */
1155                 pdu_length = get_rfc1002_length(buf);
1156
1157                 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1158                 if (!is_smb_response(server, buf[0]))
1159                         continue;
1160 next_pdu:
1161                 server->pdu_size = pdu_length;
1162
1163                 /* make sure we have enough to get to the MID */
1164                 if (server->pdu_size < HEADER_SIZE(server) - 1 -
1165                     server->vals->header_preamble_size) {
1166                         cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
1167                                  server->pdu_size);
1168                         cifs_reconnect(server);
1169                         continue;
1170                 }
1171
1172                 /* read down to the MID */
1173                 length = cifs_read_from_socket(server,
1174                              buf + server->vals->header_preamble_size,
1175                              HEADER_SIZE(server) - 1
1176                              - server->vals->header_preamble_size);
1177                 if (length < 0)
1178                         continue;
1179                 server->total_read += length;
1180
1181                 if (server->ops->next_header) {
1182                         next_offset = server->ops->next_header(buf);
1183                         if (next_offset)
1184                                 server->pdu_size = next_offset;
1185                 }
1186
1187                 memset(mids, 0, sizeof(mids));
1188                 memset(bufs, 0, sizeof(bufs));
1189                 num_mids = 0;
1190
1191                 if (server->ops->is_transform_hdr &&
1192                     server->ops->receive_transform &&
1193                     server->ops->is_transform_hdr(buf)) {
1194                         length = server->ops->receive_transform(server,
1195                                                                 mids,
1196                                                                 bufs,
1197                                                                 &num_mids);
1198                 } else {
1199                         mids[0] = server->ops->find_mid(server, buf);
1200                         bufs[0] = buf;
1201                         num_mids = 1;
1202
1203                         if (!mids[0] || !mids[0]->receive)
1204                                 length = standard_receive3(server, mids[0]);
1205                         else
1206                                 length = mids[0]->receive(server, mids[0]);
1207                 }
1208
1209                 if (length < 0) {
1210                         for (i = 0; i < num_mids; i++)
1211                                 if (mids[i])
1212                                         cifs_mid_q_entry_release(mids[i]);
1213                         continue;
1214                 }
1215
1216                 server->lstrp = jiffies;
1217
1218                 for (i = 0; i < num_mids; i++) {
1219                         if (mids[i] != NULL) {
1220                                 mids[i]->resp_buf_size = server->pdu_size;
1221
1222                                 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1223                                         mids[i]->callback(mids[i]);
1224
1225                                 cifs_mid_q_entry_release(mids[i]);
1226                         } else if (server->ops->is_oplock_break &&
1227                                    server->ops->is_oplock_break(bufs[i],
1228                                                                 server)) {
1229                                 smb2_add_credits_from_hdr(bufs[i], server);
1230                                 cifs_dbg(FYI, "Received oplock break\n");
1231                         } else {
1232                                 cifs_server_dbg(VFS, "No task to wake, unknown frame "
1233                                          "received! NumMids %d\n",
1234                                          atomic_read(&midCount));
1235                                 cifs_dump_mem("Received Data is: ", bufs[i],
1236                                               HEADER_SIZE(server));
1237                                 smb2_add_credits_from_hdr(bufs[i], server);
1238 #ifdef CONFIG_CIFS_DEBUG2
1239                                 if (server->ops->dump_detail)
1240                                         server->ops->dump_detail(bufs[i],
1241                                                                  server);
1242                                 cifs_dump_mids(server);
1243 #endif /* CIFS_DEBUG2 */
1244                         }
1245                 }
1246
1247                 if (pdu_length > server->pdu_size) {
1248                         if (!allocate_buffers(server))
1249                                 continue;
1250                         pdu_length -= server->pdu_size;
1251                         server->total_read = 0;
1252                         server->large_buf = false;
1253                         buf = server->smallbuf;
1254                         goto next_pdu;
1255                 }
1256         } /* end while !EXITING */
1257
1258         /* buffer usually freed in free_mid - need to free it here on exit */
1259         cifs_buf_release(server->bigbuf);
1260         if (server->smallbuf) /* no sense logging a debug message if NULL */
1261                 cifs_small_buf_release(server->smallbuf);
1262
1263         task_to_wake = xchg(&server->tsk, NULL);
1264         clean_demultiplex_info(server);
1265
1266         /* if server->tsk was NULL then wait for a signal before exiting */
1267         if (!task_to_wake) {
1268                 set_current_state(TASK_INTERRUPTIBLE);
1269                 while (!signal_pending(current)) {
1270                         schedule();
1271                         set_current_state(TASK_INTERRUPTIBLE);
1272                 }
1273                 set_current_state(TASK_RUNNING);
1274         }
1275
1276         memalloc_noreclaim_restore(noreclaim_flag);
1277         module_put_and_exit(0);
1278 }
1279
1280 /* extract the host portion of the UNC string */
1281 static char *
1282 extract_hostname(const char *unc)
1283 {
1284         const char *src;
1285         char *dst, *delim;
1286         unsigned int len;
1287
1288         /* skip double chars at beginning of string */
1289         /* BB: check validity of these bytes? */
1290         if (strlen(unc) < 3)
1291                 return ERR_PTR(-EINVAL);
1292         for (src = unc; *src && *src == '\\'; src++)
1293                 ;
1294         if (!*src)
1295                 return ERR_PTR(-EINVAL);
1296
1297         /* delimiter between hostname and sharename is always '\\' now */
1298         delim = strchr(src, '\\');
1299         if (!delim)
1300                 return ERR_PTR(-EINVAL);
1301
1302         len = delim - src;
1303         dst = kmalloc((len + 1), GFP_KERNEL);
1304         if (dst == NULL)
1305                 return ERR_PTR(-ENOMEM);
1306
1307         memcpy(dst, src, len);
1308         dst[len] = '\0';
1309
1310         return dst;
1311 }
1312
1313 static int get_option_ul(substring_t args[], unsigned long *option)
1314 {
1315         int rc;
1316         char *string;
1317
1318         string = match_strdup(args);
1319         if (string == NULL)
1320                 return -ENOMEM;
1321         rc = kstrtoul(string, 0, option);
1322         kfree(string);
1323
1324         return rc;
1325 }
1326
1327 static int get_option_uid(substring_t args[], kuid_t *result)
1328 {
1329         unsigned long value;
1330         kuid_t uid;
1331         int rc;
1332
1333         rc = get_option_ul(args, &value);
1334         if (rc)
1335                 return rc;
1336
1337         uid = make_kuid(current_user_ns(), value);
1338         if (!uid_valid(uid))
1339                 return -EINVAL;
1340
1341         *result = uid;
1342         return 0;
1343 }
1344
1345 static int get_option_gid(substring_t args[], kgid_t *result)
1346 {
1347         unsigned long value;
1348         kgid_t gid;
1349         int rc;
1350
1351         rc = get_option_ul(args, &value);
1352         if (rc)
1353                 return rc;
1354
1355         gid = make_kgid(current_user_ns(), value);
1356         if (!gid_valid(gid))
1357                 return -EINVAL;
1358
1359         *result = gid;
1360         return 0;
1361 }
1362
1363 static int cifs_parse_security_flavors(char *value,
1364                                        struct smb_vol *vol)
1365 {
1366
1367         substring_t args[MAX_OPT_ARGS];
1368
1369         /*
1370          * With mount options, the last one should win. Reset any existing
1371          * settings back to default.
1372          */
1373         vol->sectype = Unspecified;
1374         vol->sign = false;
1375
1376         switch (match_token(value, cifs_secflavor_tokens, args)) {
1377         case Opt_sec_krb5p:
1378                 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1379                 return 1;
1380         case Opt_sec_krb5i:
1381                 vol->sign = true;
1382                 /* Fallthrough */
1383         case Opt_sec_krb5:
1384                 vol->sectype = Kerberos;
1385                 break;
1386         case Opt_sec_ntlmsspi:
1387                 vol->sign = true;
1388                 /* Fallthrough */
1389         case Opt_sec_ntlmssp:
1390                 vol->sectype = RawNTLMSSP;
1391                 break;
1392         case Opt_sec_ntlmi:
1393                 vol->sign = true;
1394                 /* Fallthrough */
1395         case Opt_ntlm:
1396                 vol->sectype = NTLM;
1397                 break;
1398         case Opt_sec_ntlmv2i:
1399                 vol->sign = true;
1400                 /* Fallthrough */
1401         case Opt_sec_ntlmv2:
1402                 vol->sectype = NTLMv2;
1403                 break;
1404 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1405         case Opt_sec_lanman:
1406                 vol->sectype = LANMAN;
1407                 break;
1408 #endif
1409         case Opt_sec_none:
1410                 vol->nullauth = 1;
1411                 break;
1412         default:
1413                 cifs_dbg(VFS, "bad security option: %s\n", value);
1414                 return 1;
1415         }
1416
1417         return 0;
1418 }
1419
1420 static int
1421 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1422 {
1423         substring_t args[MAX_OPT_ARGS];
1424
1425         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1426         case Opt_cache_loose:
1427                 vol->direct_io = false;
1428                 vol->strict_io = false;
1429                 vol->cache_ro = false;
1430                 vol->cache_rw = false;
1431                 break;
1432         case Opt_cache_strict:
1433                 vol->direct_io = false;
1434                 vol->strict_io = true;
1435                 vol->cache_ro = false;
1436                 vol->cache_rw = false;
1437                 break;
1438         case Opt_cache_none:
1439                 vol->direct_io = true;
1440                 vol->strict_io = false;
1441                 vol->cache_ro = false;
1442                 vol->cache_rw = false;
1443                 break;
1444         case Opt_cache_ro:
1445                 vol->direct_io = false;
1446                 vol->strict_io = false;
1447                 vol->cache_ro = true;
1448                 vol->cache_rw = false;
1449                 break;
1450         case Opt_cache_rw:
1451                 vol->direct_io = false;
1452                 vol->strict_io = false;
1453                 vol->cache_ro = false;
1454                 vol->cache_rw = true;
1455                 break;
1456         default:
1457                 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1458                 return 1;
1459         }
1460         return 0;
1461 }
1462
1463 static int
1464 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1465 {
1466         substring_t args[MAX_OPT_ARGS];
1467
1468         switch (match_token(value, cifs_smb_version_tokens, args)) {
1469 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1470         case Smb_1:
1471                 if (disable_legacy_dialects) {
1472                         cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1473                         return 1;
1474                 }
1475                 if (is_smb3) {
1476                         cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1477                         return 1;
1478                 }
1479                 cifs_dbg(VFS, "Use of the less secure dialect vers=1.0 "
1480                            "is not recommended unless required for "
1481                            "access to very old servers\n");
1482                 vol->ops = &smb1_operations;
1483                 vol->vals = &smb1_values;
1484                 break;
1485         case Smb_20:
1486                 if (disable_legacy_dialects) {
1487                         cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1488                         return 1;
1489                 }
1490                 if (is_smb3) {
1491                         cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1492                         return 1;
1493                 }
1494                 vol->ops = &smb20_operations;
1495                 vol->vals = &smb20_values;
1496                 break;
1497 #else
1498         case Smb_1:
1499                 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1500                 return 1;
1501         case Smb_20:
1502                 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1503                 return 1;
1504 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1505         case Smb_21:
1506                 vol->ops = &smb21_operations;
1507                 vol->vals = &smb21_values;
1508                 break;
1509         case Smb_30:
1510                 vol->ops = &smb30_operations;
1511                 vol->vals = &smb30_values;
1512                 break;
1513         case Smb_302:
1514                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1515                 vol->vals = &smb302_values;
1516                 break;
1517         case Smb_311:
1518                 vol->ops = &smb311_operations;
1519                 vol->vals = &smb311_values;
1520                 break;
1521         case Smb_3any:
1522                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1523                 vol->vals = &smb3any_values;
1524                 break;
1525         case Smb_default:
1526                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1527                 vol->vals = &smbdefault_values;
1528                 break;
1529         default:
1530                 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1531                 return 1;
1532         }
1533         return 0;
1534 }
1535
1536 /*
1537  * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1538  * fields with the result. Returns 0 on success and an error otherwise.
1539  */
1540 static int
1541 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1542 {
1543         char *pos;
1544         const char *delims = "/\\";
1545         size_t len;
1546
1547         if (unlikely(!devname || !*devname)) {
1548                 cifs_dbg(VFS, "Device name not specified.\n");
1549                 return -EINVAL;
1550         }
1551
1552         /* make sure we have a valid UNC double delimiter prefix */
1553         len = strspn(devname, delims);
1554         if (len != 2)
1555                 return -EINVAL;
1556
1557         /* find delimiter between host and sharename */
1558         pos = strpbrk(devname + 2, delims);
1559         if (!pos)
1560                 return -EINVAL;
1561
1562         /* skip past delimiter */
1563         ++pos;
1564
1565         /* now go until next delimiter or end of string */
1566         len = strcspn(pos, delims);
1567
1568         /* move "pos" up to delimiter or NULL */
1569         pos += len;
1570         vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1571         if (!vol->UNC)
1572                 return -ENOMEM;
1573
1574         convert_delimiter(vol->UNC, '\\');
1575
1576         /* skip any delimiter */
1577         if (*pos == '/' || *pos == '\\')
1578                 pos++;
1579
1580         /* If pos is NULL then no prepath */
1581         if (!*pos)
1582                 return 0;
1583
1584         vol->prepath = kstrdup(pos, GFP_KERNEL);
1585         if (!vol->prepath)
1586                 return -ENOMEM;
1587
1588         return 0;
1589 }
1590
1591 static int
1592 cifs_parse_mount_options(const char *mountdata, const char *devname,
1593                          struct smb_vol *vol, bool is_smb3)
1594 {
1595         char *data, *end;
1596         char *mountdata_copy = NULL, *options;
1597         unsigned int  temp_len, i, j;
1598         char separator[2];
1599         short int override_uid = -1;
1600         short int override_gid = -1;
1601         bool uid_specified = false;
1602         bool gid_specified = false;
1603         bool sloppy = false;
1604         char *invalid = NULL;
1605         char *nodename = utsname()->nodename;
1606         char *string = NULL;
1607         char *tmp_end, *value;
1608         char delim;
1609         bool got_ip = false;
1610         bool got_version = false;
1611         unsigned short port = 0;
1612         struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1613
1614         separator[0] = ',';
1615         separator[1] = 0;
1616         delim = separator[0];
1617
1618         /* ensure we always start with zeroed-out smb_vol */
1619         memset(vol, 0, sizeof(*vol));
1620
1621         /*
1622          * does not have to be perfect mapping since field is
1623          * informational, only used for servers that do not support
1624          * port 445 and it can be overridden at mount time
1625          */
1626         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1627         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1628                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1629
1630         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1631         /* null target name indicates to use *SMBSERVR default called name
1632            if we end up sending RFC1001 session initialize */
1633         vol->target_rfc1001_name[0] = 0;
1634         vol->cred_uid = current_uid();
1635         vol->linux_uid = current_uid();
1636         vol->linux_gid = current_gid();
1637         vol->bsize = 1024 * 1024; /* can improve cp performance significantly */
1638         /*
1639          * default to SFM style remapping of seven reserved characters
1640          * unless user overrides it or we negotiate CIFS POSIX where
1641          * it is unnecessary.  Can not simultaneously use more than one mapping
1642          * since then readdir could list files that open could not open
1643          */
1644         vol->remap = true;
1645
1646         /* default to only allowing write access to owner of the mount */
1647         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1648
1649         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1650         /* default is always to request posix paths. */
1651         vol->posix_paths = 1;
1652         /* default to using server inode numbers where available */
1653         vol->server_ino = 1;
1654
1655         /* default is to use strict cifs caching semantics */
1656         vol->strict_io = true;
1657
1658         vol->actimeo = CIFS_DEF_ACTIMEO;
1659
1660         /* Most clients set timeout to 0, allows server to use its default */
1661         vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1662
1663         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1664         vol->ops = &smb30_operations;
1665         vol->vals = &smbdefault_values;
1666
1667         vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1668
1669         /* default to no multichannel (single server connection) */
1670         vol->multichannel = false;
1671         vol->max_channels = 1;
1672
1673         if (!mountdata)
1674                 goto cifs_parse_mount_err;
1675
1676         mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1677         if (!mountdata_copy)
1678                 goto cifs_parse_mount_err;
1679
1680         options = mountdata_copy;
1681         end = options + strlen(options);
1682
1683         if (strncmp(options, "sep=", 4) == 0) {
1684                 if (options[4] != 0) {
1685                         separator[0] = options[4];
1686                         options += 5;
1687                 } else {
1688                         cifs_dbg(FYI, "Null separator not allowed\n");
1689                 }
1690         }
1691         vol->backupuid_specified = false; /* no backup intent for a user */
1692         vol->backupgid_specified = false; /* no backup intent for a group */
1693
1694         switch (cifs_parse_devname(devname, vol)) {
1695         case 0:
1696                 break;
1697         case -ENOMEM:
1698                 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1699                 goto cifs_parse_mount_err;
1700         case -EINVAL:
1701                 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1702                 goto cifs_parse_mount_err;
1703         default:
1704                 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1705                 goto cifs_parse_mount_err;
1706         }
1707
1708         while ((data = strsep(&options, separator)) != NULL) {
1709                 substring_t args[MAX_OPT_ARGS];
1710                 unsigned long option;
1711                 int token;
1712
1713                 if (!*data)
1714                         continue;
1715
1716                 token = match_token(data, cifs_mount_option_tokens, args);
1717
1718                 switch (token) {
1719
1720                 /* Ingnore the following */
1721                 case Opt_ignore:
1722                         break;
1723
1724                 /* Boolean values */
1725                 case Opt_user_xattr:
1726                         vol->no_xattr = 0;
1727                         break;
1728                 case Opt_nouser_xattr:
1729                         vol->no_xattr = 1;
1730                         break;
1731                 case Opt_forceuid:
1732                         override_uid = 1;
1733                         break;
1734                 case Opt_noforceuid:
1735                         override_uid = 0;
1736                         break;
1737                 case Opt_forcegid:
1738                         override_gid = 1;
1739                         break;
1740                 case Opt_noforcegid:
1741                         override_gid = 0;
1742                         break;
1743                 case Opt_noblocksend:
1744                         vol->noblocksnd = 1;
1745                         break;
1746                 case Opt_noautotune:
1747                         vol->noautotune = 1;
1748                         break;
1749                 case Opt_nolease:
1750                         vol->no_lease = 1;
1751                         break;
1752                 case Opt_hard:
1753                         vol->retry = 1;
1754                         break;
1755                 case Opt_soft:
1756                         vol->retry = 0;
1757                         break;
1758                 case Opt_perm:
1759                         vol->noperm = 0;
1760                         break;
1761                 case Opt_noperm:
1762                         vol->noperm = 1;
1763                         break;
1764                 case Opt_mapchars:
1765                         vol->sfu_remap = true;
1766                         vol->remap = false; /* disable SFM mapping */
1767                         break;
1768                 case Opt_nomapchars:
1769                         vol->sfu_remap = false;
1770                         break;
1771                 case Opt_mapposix:
1772                         vol->remap = true;
1773                         vol->sfu_remap = false; /* disable SFU mapping */
1774                         break;
1775                 case Opt_nomapposix:
1776                         vol->remap = false;
1777                         break;
1778                 case Opt_sfu:
1779                         vol->sfu_emul = 1;
1780                         break;
1781                 case Opt_nosfu:
1782                         vol->sfu_emul = 0;
1783                         break;
1784                 case Opt_nodfs:
1785                         vol->nodfs = 1;
1786                         break;
1787                 case Opt_rootfs:
1788 #ifdef CONFIG_CIFS_ROOT
1789                         vol->rootfs = true;
1790 #endif
1791                         break;
1792                 case Opt_posixpaths:
1793                         vol->posix_paths = 1;
1794                         break;
1795                 case Opt_noposixpaths:
1796                         vol->posix_paths = 0;
1797                         break;
1798                 case Opt_nounix:
1799                         if (vol->linux_ext)
1800                                 cifs_dbg(VFS,
1801                                         "conflicting unix mount options\n");
1802                         vol->no_linux_ext = 1;
1803                         break;
1804                 case Opt_unix:
1805                         if (vol->no_linux_ext)
1806                                 cifs_dbg(VFS,
1807                                         "conflicting unix mount options\n");
1808                         vol->linux_ext = 1;
1809                         break;
1810                 case Opt_nocase:
1811                         vol->nocase = 1;
1812                         break;
1813                 case Opt_brl:
1814                         vol->nobrl =  0;
1815                         break;
1816                 case Opt_nobrl:
1817                         vol->nobrl =  1;
1818                         /*
1819                          * turn off mandatory locking in mode
1820                          * if remote locking is turned off since the
1821                          * local vfs will do advisory
1822                          */
1823                         if (vol->file_mode ==
1824                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1825                                 vol->file_mode = S_IALLUGO;
1826                         break;
1827                 case Opt_nohandlecache:
1828                         vol->nohandlecache = 1;
1829                         break;
1830                 case Opt_handlecache:
1831                         vol->nohandlecache = 0;
1832                         break;
1833                 case Opt_forcemandatorylock:
1834                         vol->mand_lock = 1;
1835                         break;
1836                 case Opt_setuids:
1837                         vol->setuids = 1;
1838                         break;
1839                 case Opt_nosetuids:
1840                         vol->setuids = 0;
1841                         break;
1842                 case Opt_setuidfromacl:
1843                         vol->setuidfromacl = 1;
1844                         break;
1845                 case Opt_dynperm:
1846                         vol->dynperm = true;
1847                         break;
1848                 case Opt_nodynperm:
1849                         vol->dynperm = false;
1850                         break;
1851                 case Opt_nohard:
1852                         vol->retry = 0;
1853                         break;
1854                 case Opt_nosoft:
1855                         vol->retry = 1;
1856                         break;
1857                 case Opt_nointr:
1858                         vol->intr = 0;
1859                         break;
1860                 case Opt_intr:
1861                         vol->intr = 1;
1862                         break;
1863                 case Opt_nostrictsync:
1864                         vol->nostrictsync = 1;
1865                         break;
1866                 case Opt_strictsync:
1867                         vol->nostrictsync = 0;
1868                         break;
1869                 case Opt_serverino:
1870                         vol->server_ino = 1;
1871                         break;
1872                 case Opt_noserverino:
1873                         vol->server_ino = 0;
1874                         break;
1875                 case Opt_rwpidforward:
1876                         vol->rwpidforward = 1;
1877                         break;
1878                 case Opt_modesid:
1879                         vol->mode_ace = 1;
1880                         break;
1881                 case Opt_cifsacl:
1882                         vol->cifs_acl = 1;
1883                         break;
1884                 case Opt_nocifsacl:
1885                         vol->cifs_acl = 0;
1886                         break;
1887                 case Opt_acl:
1888                         vol->no_psx_acl = 0;
1889                         break;
1890                 case Opt_noacl:
1891                         vol->no_psx_acl = 1;
1892                         break;
1893                 case Opt_locallease:
1894                         vol->local_lease = 1;
1895                         break;
1896                 case Opt_sign:
1897                         vol->sign = true;
1898                         break;
1899                 case Opt_ignore_signature:
1900                         vol->sign = true;
1901                         vol->ignore_signature = true;
1902                         break;
1903                 case Opt_seal:
1904                         /* we do not do the following in secFlags because seal
1905                          * is a per tree connection (mount) not a per socket
1906                          * or per-smb connection option in the protocol
1907                          * vol->secFlg |= CIFSSEC_MUST_SEAL;
1908                          */
1909                         vol->seal = 1;
1910                         break;
1911                 case Opt_noac:
1912                         pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1913                         break;
1914                 case Opt_fsc:
1915 #ifndef CONFIG_CIFS_FSCACHE
1916                         cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1917                         goto cifs_parse_mount_err;
1918 #endif
1919                         vol->fsc = true;
1920                         break;
1921                 case Opt_mfsymlinks:
1922                         vol->mfsymlinks = true;
1923                         break;
1924                 case Opt_multiuser:
1925                         vol->multiuser = true;
1926                         break;
1927                 case Opt_sloppy:
1928                         sloppy = true;
1929                         break;
1930                 case Opt_nosharesock:
1931                         vol->nosharesock = true;
1932                         break;
1933                 case Opt_nopersistent:
1934                         vol->nopersistent = true;
1935                         if (vol->persistent) {
1936                                 cifs_dbg(VFS,
1937                                   "persistenthandles mount options conflict\n");
1938                                 goto cifs_parse_mount_err;
1939                         }
1940                         break;
1941                 case Opt_persistent:
1942                         vol->persistent = true;
1943                         if ((vol->nopersistent) || (vol->resilient)) {
1944                                 cifs_dbg(VFS,
1945                                   "persistenthandles mount options conflict\n");
1946                                 goto cifs_parse_mount_err;
1947                         }
1948                         break;
1949                 case Opt_resilient:
1950                         vol->resilient = true;
1951                         if (vol->persistent) {
1952                                 cifs_dbg(VFS,
1953                                   "persistenthandles mount options conflict\n");
1954                                 goto cifs_parse_mount_err;
1955                         }
1956                         break;
1957                 case Opt_noresilient:
1958                         vol->resilient = false; /* already the default */
1959                         break;
1960                 case Opt_domainauto:
1961                         vol->domainauto = true;
1962                         break;
1963                 case Opt_rdma:
1964                         vol->rdma = true;
1965                         break;
1966                 case Opt_multichannel:
1967                         vol->multichannel = true;
1968                         break;
1969                 case Opt_nomultichannel:
1970                         vol->multichannel = false;
1971                         break;
1972                 case Opt_compress:
1973                         vol->compression = UNKNOWN_TYPE;
1974                         cifs_dbg(VFS,
1975                                 "SMB3 compression support is experimental\n");
1976                         break;
1977
1978                 /* Numeric Values */
1979                 case Opt_backupuid:
1980                         if (get_option_uid(args, &vol->backupuid)) {
1981                                 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1982                                          __func__);
1983                                 goto cifs_parse_mount_err;
1984                         }
1985                         vol->backupuid_specified = true;
1986                         break;
1987                 case Opt_backupgid:
1988                         if (get_option_gid(args, &vol->backupgid)) {
1989                                 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1990                                          __func__);
1991                                 goto cifs_parse_mount_err;
1992                         }
1993                         vol->backupgid_specified = true;
1994                         break;
1995                 case Opt_uid:
1996                         if (get_option_uid(args, &vol->linux_uid)) {
1997                                 cifs_dbg(VFS, "%s: Invalid uid value\n",
1998                                          __func__);
1999                                 goto cifs_parse_mount_err;
2000                         }
2001                         uid_specified = true;
2002                         break;
2003                 case Opt_cruid:
2004                         if (get_option_uid(args, &vol->cred_uid)) {
2005                                 cifs_dbg(VFS, "%s: Invalid cruid value\n",
2006                                          __func__);
2007                                 goto cifs_parse_mount_err;
2008                         }
2009                         break;
2010                 case Opt_gid:
2011                         if (get_option_gid(args, &vol->linux_gid)) {
2012                                 cifs_dbg(VFS, "%s: Invalid gid value\n",
2013                                          __func__);
2014                                 goto cifs_parse_mount_err;
2015                         }
2016                         gid_specified = true;
2017                         break;
2018                 case Opt_file_mode:
2019                         if (get_option_ul(args, &option)) {
2020                                 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
2021                                          __func__);
2022                                 goto cifs_parse_mount_err;
2023                         }
2024                         vol->file_mode = option;
2025                         break;
2026                 case Opt_dirmode:
2027                         if (get_option_ul(args, &option)) {
2028                                 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
2029                                          __func__);
2030                                 goto cifs_parse_mount_err;
2031                         }
2032                         vol->dir_mode = option;
2033                         break;
2034                 case Opt_port:
2035                         if (get_option_ul(args, &option) ||
2036                             option > USHRT_MAX) {
2037                                 cifs_dbg(VFS, "%s: Invalid port value\n",
2038                                          __func__);
2039                                 goto cifs_parse_mount_err;
2040                         }
2041                         port = (unsigned short)option;
2042                         break;
2043                 case Opt_min_enc_offload:
2044                         if (get_option_ul(args, &option)) {
2045                                 cifs_dbg(VFS, "Invalid minimum encrypted read offload size (esize)\n");
2046                                 goto cifs_parse_mount_err;
2047                         }
2048                         vol->min_offload = option;
2049                         break;
2050                 case Opt_blocksize:
2051                         if (get_option_ul(args, &option)) {
2052                                 cifs_dbg(VFS, "%s: Invalid blocksize value\n",
2053                                         __func__);
2054                                 goto cifs_parse_mount_err;
2055                         }
2056                         /*
2057                          * inode blocksize realistically should never need to be
2058                          * less than 16K or greater than 16M and default is 1MB.
2059                          * Note that small inode block sizes (e.g. 64K) can lead
2060                          * to very poor performance of common tools like cp and scp
2061                          */
2062                         if ((option < CIFS_MAX_MSGSIZE) ||
2063                            (option > (4 * SMB3_DEFAULT_IOSIZE))) {
2064                                 cifs_dbg(VFS, "%s: Invalid blocksize\n",
2065                                         __func__);
2066                                 goto cifs_parse_mount_err;
2067                         }
2068                         vol->bsize = option;
2069                         break;
2070                 case Opt_rsize:
2071                         if (get_option_ul(args, &option)) {
2072                                 cifs_dbg(VFS, "%s: Invalid rsize value\n",
2073                                          __func__);
2074                                 goto cifs_parse_mount_err;
2075                         }
2076                         vol->rsize = option;
2077                         break;
2078                 case Opt_wsize:
2079                         if (get_option_ul(args, &option)) {
2080                                 cifs_dbg(VFS, "%s: Invalid wsize value\n",
2081                                          __func__);
2082                                 goto cifs_parse_mount_err;
2083                         }
2084                         vol->wsize = option;
2085                         break;
2086                 case Opt_actimeo:
2087                         if (get_option_ul(args, &option)) {
2088                                 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
2089                                          __func__);
2090                                 goto cifs_parse_mount_err;
2091                         }
2092                         vol->actimeo = HZ * option;
2093                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
2094                                 cifs_dbg(VFS, "attribute cache timeout too large\n");
2095                                 goto cifs_parse_mount_err;
2096                         }
2097                         break;
2098                 case Opt_handletimeout:
2099                         if (get_option_ul(args, &option)) {
2100                                 cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
2101                                          __func__);
2102                                 goto cifs_parse_mount_err;
2103                         }
2104                         vol->handle_timeout = option;
2105                         if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
2106                                 cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
2107                                 goto cifs_parse_mount_err;
2108                         }
2109                         break;
2110                 case Opt_echo_interval:
2111                         if (get_option_ul(args, &option)) {
2112                                 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
2113                                          __func__);
2114                                 goto cifs_parse_mount_err;
2115                         }
2116                         vol->echo_interval = option;
2117                         break;
2118                 case Opt_snapshot:
2119                         if (get_option_ul(args, &option)) {
2120                                 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
2121                                          __func__);
2122                                 goto cifs_parse_mount_err;
2123                         }
2124                         vol->snapshot_time = option;
2125                         break;
2126                 case Opt_max_credits:
2127                         if (get_option_ul(args, &option) || (option < 20) ||
2128                             (option > 60000)) {
2129                                 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
2130                                          __func__);
2131                                 goto cifs_parse_mount_err;
2132                         }
2133                         vol->max_credits = option;
2134                         break;
2135                 case Opt_max_channels:
2136                         if (get_option_ul(args, &option) || option < 1 ||
2137                                 option > CIFS_MAX_CHANNELS) {
2138                                 cifs_dbg(VFS, "%s: Invalid max_channels value, needs to be 1-%d\n",
2139                                          __func__, CIFS_MAX_CHANNELS);
2140                                 goto cifs_parse_mount_err;
2141                         }
2142                         vol->max_channels = option;
2143                         break;
2144
2145                 /* String Arguments */
2146
2147                 case Opt_blank_user:
2148                         /* null user, ie. anonymous authentication */
2149                         vol->nullauth = 1;
2150                         vol->username = NULL;
2151                         break;
2152                 case Opt_user:
2153                         string = match_strdup(args);
2154                         if (string == NULL)
2155                                 goto out_nomem;
2156
2157                         if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
2158                                                         CIFS_MAX_USERNAME_LEN) {
2159                                 pr_warn("CIFS: username too long\n");
2160                                 goto cifs_parse_mount_err;
2161                         }
2162
2163                         kfree(vol->username);
2164                         vol->username = kstrdup(string, GFP_KERNEL);
2165                         if (!vol->username)
2166                                 goto cifs_parse_mount_err;
2167                         break;
2168                 case Opt_blank_pass:
2169                         /* passwords have to be handled differently
2170                          * to allow the character used for deliminator
2171                          * to be passed within them
2172                          */
2173
2174                         /*
2175                          * Check if this is a case where the  password
2176                          * starts with a delimiter
2177                          */
2178                         tmp_end = strchr(data, '=');
2179                         tmp_end++;
2180                         if (!(tmp_end < end && tmp_end[1] == delim)) {
2181                                 /* No it is not. Set the password to NULL */
2182                                 kzfree(vol->password);
2183                                 vol->password = NULL;
2184                                 break;
2185                         }
2186                         /* Fallthrough - to Opt_pass below.*/
2187                 case Opt_pass:
2188                         /* Obtain the value string */
2189                         value = strchr(data, '=');
2190                         value++;
2191
2192                         /* Set tmp_end to end of the string */
2193                         tmp_end = (char *) value + strlen(value);
2194
2195                         /* Check if following character is the deliminator
2196                          * If yes, we have encountered a double deliminator
2197                          * reset the NULL character to the deliminator
2198                          */
2199                         if (tmp_end < end && tmp_end[1] == delim) {
2200                                 tmp_end[0] = delim;
2201
2202                                 /* Keep iterating until we get to a single
2203                                  * deliminator OR the end
2204                                  */
2205                                 while ((tmp_end = strchr(tmp_end, delim))
2206                                         != NULL && (tmp_end[1] == delim)) {
2207                                                 tmp_end = (char *) &tmp_end[2];
2208                                 }
2209
2210                                 /* Reset var options to point to next element */
2211                                 if (tmp_end) {
2212                                         tmp_end[0] = '\0';
2213                                         options = (char *) &tmp_end[1];
2214                                 } else
2215                                         /* Reached the end of the mount option
2216                                          * string */
2217                                         options = end;
2218                         }
2219
2220                         kzfree(vol->password);
2221                         /* Now build new password string */
2222                         temp_len = strlen(value);
2223                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
2224                         if (vol->password == NULL) {
2225                                 pr_warn("CIFS: no memory for password\n");
2226                                 goto cifs_parse_mount_err;
2227                         }
2228
2229                         for (i = 0, j = 0; i < temp_len; i++, j++) {
2230                                 vol->password[j] = value[i];
2231                                 if ((value[i] == delim) &&
2232                                      value[i+1] == delim)
2233                                         /* skip the second deliminator */
2234                                         i++;
2235                         }
2236                         vol->password[j] = '\0';
2237                         break;
2238                 case Opt_blank_ip:
2239                         /* FIXME: should this be an error instead? */
2240                         got_ip = false;
2241                         break;
2242                 case Opt_ip:
2243                         string = match_strdup(args);
2244                         if (string == NULL)
2245                                 goto out_nomem;
2246
2247                         if (!cifs_convert_address(dstaddr, string,
2248                                         strlen(string))) {
2249                                 pr_err("CIFS: bad ip= option (%s).\n", string);
2250                                 goto cifs_parse_mount_err;
2251                         }
2252                         got_ip = true;
2253                         break;
2254                 case Opt_domain:
2255                         string = match_strdup(args);
2256                         if (string == NULL)
2257                                 goto out_nomem;
2258
2259                         if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
2260                                         == CIFS_MAX_DOMAINNAME_LEN) {
2261                                 pr_warn("CIFS: domain name too long\n");
2262                                 goto cifs_parse_mount_err;
2263                         }
2264
2265                         kfree(vol->domainname);
2266                         vol->domainname = kstrdup(string, GFP_KERNEL);
2267                         if (!vol->domainname) {
2268                                 pr_warn("CIFS: no memory for domainname\n");
2269                                 goto cifs_parse_mount_err;
2270                         }
2271                         cifs_dbg(FYI, "Domain name set\n");
2272                         break;
2273                 case Opt_srcaddr:
2274                         string = match_strdup(args);
2275                         if (string == NULL)
2276                                 goto out_nomem;
2277
2278                         if (!cifs_convert_address(
2279                                         (struct sockaddr *)&vol->srcaddr,
2280                                         string, strlen(string))) {
2281                                 pr_warn("CIFS: Could not parse srcaddr: %s\n",
2282                                         string);
2283                                 goto cifs_parse_mount_err;
2284                         }
2285                         break;
2286                 case Opt_iocharset:
2287                         string = match_strdup(args);
2288                         if (string == NULL)
2289                                 goto out_nomem;
2290
2291                         if (strnlen(string, 1024) >= 65) {
2292                                 pr_warn("CIFS: iocharset name too long.\n");
2293                                 goto cifs_parse_mount_err;
2294                         }
2295
2296                          if (strncasecmp(string, "default", 7) != 0) {
2297                                 kfree(vol->iocharset);
2298                                 vol->iocharset = kstrdup(string,
2299                                                          GFP_KERNEL);
2300                                 if (!vol->iocharset) {
2301                                         pr_warn("CIFS: no memory for charset\n");
2302                                         goto cifs_parse_mount_err;
2303                                 }
2304                         }
2305                         /* if iocharset not set then load_nls_default
2306                          * is used by caller
2307                          */
2308                          cifs_dbg(FYI, "iocharset set to %s\n", string);
2309                         break;
2310                 case Opt_netbiosname:
2311                         string = match_strdup(args);
2312                         if (string == NULL)
2313                                 goto out_nomem;
2314
2315                         memset(vol->source_rfc1001_name, 0x20,
2316                                 RFC1001_NAME_LEN);
2317                         /*
2318                          * FIXME: are there cases in which a comma can
2319                          * be valid in workstation netbios name (and
2320                          * need special handling)?
2321                          */
2322                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
2323                                 /* don't ucase netbiosname for user */
2324                                 if (string[i] == 0)
2325                                         break;
2326                                 vol->source_rfc1001_name[i] = string[i];
2327                         }
2328                         /* The string has 16th byte zero still from
2329                          * set at top of the function
2330                          */
2331                         if (i == RFC1001_NAME_LEN && string[i] != 0)
2332                                 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
2333                         break;
2334                 case Opt_servern:
2335                         /* servernetbiosname specified override *SMBSERVER */
2336                         string = match_strdup(args);
2337                         if (string == NULL)
2338                                 goto out_nomem;
2339
2340                         /* last byte, type, is 0x20 for servr type */
2341                         memset(vol->target_rfc1001_name, 0x20,
2342                                 RFC1001_NAME_LEN_WITH_NULL);
2343
2344                         /* BB are there cases in which a comma can be
2345                            valid in this workstation netbios name
2346                            (and need special handling)? */
2347
2348                         /* user or mount helper must uppercase the
2349                            netbios name */
2350                         for (i = 0; i < 15; i++) {
2351                                 if (string[i] == 0)
2352                                         break;
2353                                 vol->target_rfc1001_name[i] = string[i];
2354                         }
2355                         /* The string has 16th byte zero still from
2356                            set at top of the function  */
2357                         if (i == RFC1001_NAME_LEN && string[i] != 0)
2358                                 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2359                         break;
2360                 case Opt_ver:
2361                         /* version of mount userspace tools, not dialect */
2362                         string = match_strdup(args);
2363                         if (string == NULL)
2364                                 goto out_nomem;
2365
2366                         /* If interface changes in mount.cifs bump to new ver */
2367                         if (strncasecmp(string, "1", 1) == 0) {
2368                                 if (strlen(string) > 1) {
2369                                         pr_warn("Bad mount helper ver=%s. Did "
2370                                                 "you want SMB1 (CIFS) dialect "
2371                                                 "and mean to type vers=1.0 "
2372                                                 "instead?\n", string);
2373                                         goto cifs_parse_mount_err;
2374                                 }
2375                                 /* This is the default */
2376                                 break;
2377                         }
2378                         /* For all other value, error */
2379                         pr_warn("CIFS: Invalid mount helper version specified\n");
2380                         goto cifs_parse_mount_err;
2381                 case Opt_vers:
2382                         /* protocol version (dialect) */
2383                         string = match_strdup(args);
2384                         if (string == NULL)
2385                                 goto out_nomem;
2386
2387                         if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2388                                 goto cifs_parse_mount_err;
2389                         got_version = true;
2390                         break;
2391                 case Opt_sec:
2392                         string = match_strdup(args);
2393                         if (string == NULL)
2394                                 goto out_nomem;
2395
2396                         if (cifs_parse_security_flavors(string, vol) != 0)
2397                                 goto cifs_parse_mount_err;
2398                         break;
2399                 case Opt_cache:
2400                         string = match_strdup(args);
2401                         if (string == NULL)
2402                                 goto out_nomem;
2403
2404                         if (cifs_parse_cache_flavor(string, vol) != 0)
2405                                 goto cifs_parse_mount_err;
2406                         break;
2407                 default:
2408                         /*
2409                          * An option we don't recognize. Save it off for later
2410                          * if we haven't already found one
2411                          */
2412                         if (!invalid)
2413                                 invalid = data;
2414                         break;
2415                 }
2416                 /* Free up any allocated string */
2417                 kfree(string);
2418                 string = NULL;
2419         }
2420
2421         if (!sloppy && invalid) {
2422                 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2423                 goto cifs_parse_mount_err;
2424         }
2425
2426         if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2427                 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2428                 goto cifs_parse_mount_err;
2429         }
2430
2431 #ifndef CONFIG_KEYS
2432         /* Muliuser mounts require CONFIG_KEYS support */
2433         if (vol->multiuser) {
2434                 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2435                 goto cifs_parse_mount_err;
2436         }
2437 #endif
2438         if (!vol->UNC) {
2439                 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2440                 goto cifs_parse_mount_err;
2441         }
2442
2443         /* make sure UNC has a share name */
2444         if (!strchr(vol->UNC + 3, '\\')) {
2445                 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2446                 goto cifs_parse_mount_err;
2447         }
2448
2449         if (!got_ip) {
2450                 int len;
2451                 const char *slash;
2452
2453                 /* No ip= option specified? Try to get it from UNC */
2454                 /* Use the address part of the UNC. */
2455                 slash = strchr(&vol->UNC[2], '\\');
2456                 len = slash - &vol->UNC[2];
2457                 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2458                         pr_err("Unable to determine destination address.\n");
2459                         goto cifs_parse_mount_err;
2460                 }
2461         }
2462
2463         /* set the port that we got earlier */
2464         cifs_set_port(dstaddr, port);
2465
2466         if (uid_specified)
2467                 vol->override_uid = override_uid;
2468         else if (override_uid == 1)
2469                 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2470
2471         if (gid_specified)
2472                 vol->override_gid = override_gid;
2473         else if (override_gid == 1)
2474                 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2475
2476         if (got_version == false)
2477                 pr_warn_once("No dialect specified on mount. Default has changed"
2478                         " to a more secure dialect, SMB2.1 or later (e.g. "
2479                         "SMB3.1.1), from CIFS (SMB1). To use the less secure "
2480                         "SMB1 dialect to access old servers which do not "
2481                         "support SMB3.1.1 (or even SMB3 or SMB2.1) specify "
2482                         "vers=1.0 on mount.\n");
2483
2484         kfree(mountdata_copy);
2485         return 0;
2486
2487 out_nomem:
2488         pr_warn("Could not allocate temporary buffer\n");
2489 cifs_parse_mount_err:
2490         kfree(string);
2491         kfree(mountdata_copy);
2492         return 1;
2493 }
2494
2495 /** Returns true if srcaddr isn't specified and rhs isn't
2496  * specified, or if srcaddr is specified and
2497  * matches the IP address of the rhs argument.
2498  */
2499 static bool
2500 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2501 {
2502         switch (srcaddr->sa_family) {
2503         case AF_UNSPEC:
2504                 return (rhs->sa_family == AF_UNSPEC);
2505         case AF_INET: {
2506                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2507                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2508                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2509         }
2510         case AF_INET6: {
2511                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2512                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2513                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2514         }
2515         default:
2516                 WARN_ON(1);
2517                 return false; /* don't expect to be here */
2518         }
2519 }
2520
2521 /*
2522  * If no port is specified in addr structure, we try to match with 445 port
2523  * and if it fails - with 139 ports. It should be called only if address
2524  * families of server and addr are equal.
2525  */
2526 static bool
2527 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2528 {
2529         __be16 port, *sport;
2530
2531         /* SMBDirect manages its own ports, don't match it here */
2532         if (server->rdma)
2533                 return true;
2534
2535         switch (addr->sa_family) {
2536         case AF_INET:
2537                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2538                 port = ((struct sockaddr_in *) addr)->sin_port;
2539                 break;
2540         case AF_INET6:
2541                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2542                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2543                 break;
2544         default:
2545                 WARN_ON(1);
2546                 return false;
2547         }
2548
2549         if (!port) {
2550                 port = htons(CIFS_PORT);
2551                 if (port == *sport)
2552                         return true;
2553
2554                 port = htons(RFC1001_PORT);
2555         }
2556
2557         return port == *sport;
2558 }
2559
2560 static bool
2561 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2562               struct sockaddr *srcaddr)
2563 {
2564         switch (addr->sa_family) {
2565         case AF_INET: {
2566                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2567                 struct sockaddr_in *srv_addr4 =
2568                                         (struct sockaddr_in *)&server->dstaddr;
2569
2570                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2571                         return false;
2572                 break;
2573         }
2574         case AF_INET6: {
2575                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2576                 struct sockaddr_in6 *srv_addr6 =
2577                                         (struct sockaddr_in6 *)&server->dstaddr;
2578
2579                 if (!ipv6_addr_equal(&addr6->sin6_addr,
2580                                      &srv_addr6->sin6_addr))
2581                         return false;
2582                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2583                         return false;
2584                 break;
2585         }
2586         default:
2587                 WARN_ON(1);
2588                 return false; /* don't expect to be here */
2589         }
2590
2591         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2592                 return false;
2593
2594         return true;
2595 }
2596
2597 static bool
2598 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2599 {
2600         /*
2601          * The select_sectype function should either return the vol->sectype
2602          * that was specified, or "Unspecified" if that sectype was not
2603          * compatible with the given NEGOTIATE request.
2604          */
2605         if (server->ops->select_sectype(server, vol->sectype)
2606              == Unspecified)
2607                 return false;
2608
2609         /*
2610          * Now check if signing mode is acceptable. No need to check
2611          * global_secflags at this point since if MUST_SIGN is set then
2612          * the server->sign had better be too.
2613          */
2614         if (vol->sign && !server->sign)
2615                 return false;
2616
2617         return true;
2618 }
2619
2620 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2621 {
2622         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2623
2624         if (vol->nosharesock)
2625                 return 0;
2626
2627         /* If multidialect negotiation see if existing sessions match one */
2628         if (strcmp(vol->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
2629                 if (server->vals->protocol_id < SMB30_PROT_ID)
2630                         return 0;
2631         } else if (strcmp(vol->vals->version_string,
2632                    SMBDEFAULT_VERSION_STRING) == 0) {
2633                 if (server->vals->protocol_id < SMB21_PROT_ID)
2634                         return 0;
2635         } else if ((server->vals != vol->vals) || (server->ops != vol->ops))
2636                 return 0;
2637
2638         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2639                 return 0;
2640
2641         if (!match_address(server, addr,
2642                            (struct sockaddr *)&vol->srcaddr))
2643                 return 0;
2644
2645         if (!match_port(server, addr))
2646                 return 0;
2647
2648         if (!match_security(server, vol))
2649                 return 0;
2650
2651         if (server->echo_interval != vol->echo_interval * HZ)
2652                 return 0;
2653
2654         if (server->rdma != vol->rdma)
2655                 return 0;
2656
2657         if (server->ignore_signature != vol->ignore_signature)
2658                 return 0;
2659
2660         if (server->min_offload != vol->min_offload)
2661                 return 0;
2662
2663         return 1;
2664 }
2665
2666 struct TCP_Server_Info *
2667 cifs_find_tcp_session(struct smb_vol *vol)
2668 {
2669         struct TCP_Server_Info *server;
2670
2671         spin_lock(&cifs_tcp_ses_lock);
2672         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2673                 /*
2674                  * Skip ses channels since they're only handled in lower layers
2675                  * (e.g. cifs_send_recv).
2676                  */
2677                 if (server->is_channel || !match_server(server, vol))
2678                         continue;
2679
2680                 ++server->srv_count;
2681                 spin_unlock(&cifs_tcp_ses_lock);
2682                 cifs_dbg(FYI, "Existing tcp session with server found\n");
2683                 return server;
2684         }
2685         spin_unlock(&cifs_tcp_ses_lock);
2686         return NULL;
2687 }
2688
2689 void
2690 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2691 {
2692         struct task_struct *task;
2693
2694         spin_lock(&cifs_tcp_ses_lock);
2695         if (--server->srv_count > 0) {
2696                 spin_unlock(&cifs_tcp_ses_lock);
2697                 return;
2698         }
2699
2700         put_net(cifs_net_ns(server));
2701
2702         list_del_init(&server->tcp_ses_list);
2703         spin_unlock(&cifs_tcp_ses_lock);
2704
2705         cancel_delayed_work_sync(&server->echo);
2706
2707         if (from_reconnect)
2708                 /*
2709                  * Avoid deadlock here: reconnect work calls
2710                  * cifs_put_tcp_session() at its end. Need to be sure
2711                  * that reconnect work does nothing with server pointer after
2712                  * that step.
2713                  */
2714                 cancel_delayed_work(&server->reconnect);
2715         else
2716                 cancel_delayed_work_sync(&server->reconnect);
2717
2718         spin_lock(&GlobalMid_Lock);
2719         server->tcpStatus = CifsExiting;
2720         spin_unlock(&GlobalMid_Lock);
2721
2722         cifs_crypto_secmech_release(server);
2723         cifs_fscache_release_client_cookie(server);
2724
2725         kfree(server->session_key.response);
2726         server->session_key.response = NULL;
2727         server->session_key.len = 0;
2728
2729         task = xchg(&server->tsk, NULL);
2730         if (task)
2731                 send_sig(SIGKILL, task, 1);
2732 }
2733
2734 struct TCP_Server_Info *
2735 cifs_get_tcp_session(struct smb_vol *volume_info)
2736 {
2737         struct TCP_Server_Info *tcp_ses = NULL;
2738         int rc;
2739
2740         cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2741
2742         /* see if we already have a matching tcp_ses */
2743         tcp_ses = cifs_find_tcp_session(volume_info);
2744         if (tcp_ses)
2745                 return tcp_ses;
2746
2747         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2748         if (!tcp_ses) {
2749                 rc = -ENOMEM;
2750                 goto out_err;
2751         }
2752
2753         tcp_ses->ops = volume_info->ops;
2754         tcp_ses->vals = volume_info->vals;
2755         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2756         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2757         if (IS_ERR(tcp_ses->hostname)) {
2758                 rc = PTR_ERR(tcp_ses->hostname);
2759                 goto out_err_crypto_release;
2760         }
2761
2762         tcp_ses->noblockcnt = volume_info->rootfs;
2763         tcp_ses->noblocksnd = volume_info->noblocksnd || volume_info->rootfs;
2764         tcp_ses->noautotune = volume_info->noautotune;
2765         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2766         tcp_ses->rdma = volume_info->rdma;
2767         tcp_ses->in_flight = 0;
2768         tcp_ses->max_in_flight = 0;
2769         tcp_ses->credits = 1;
2770         init_waitqueue_head(&tcp_ses->response_q);
2771         init_waitqueue_head(&tcp_ses->request_q);
2772         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2773         mutex_init(&tcp_ses->srv_mutex);
2774         memcpy(tcp_ses->workstation_RFC1001_name,
2775                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2776         memcpy(tcp_ses->server_RFC1001_name,
2777                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2778         tcp_ses->session_estab = false;
2779         tcp_ses->sequence_number = 0;
2780         tcp_ses->reconnect_instance = 1;
2781         tcp_ses->lstrp = jiffies;
2782         tcp_ses->compress_algorithm = cpu_to_le16(volume_info->compression);
2783         spin_lock_init(&tcp_ses->req_lock);
2784         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2785         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2786         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2787         INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2788         mutex_init(&tcp_ses->reconnect_mutex);
2789         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2790                sizeof(tcp_ses->srcaddr));
2791         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2792                 sizeof(tcp_ses->dstaddr));
2793         if (volume_info->use_client_guid)
2794                 memcpy(tcp_ses->client_guid, volume_info->client_guid,
2795                        SMB2_CLIENT_GUID_SIZE);
2796         else
2797                 generate_random_uuid(tcp_ses->client_guid);
2798         /*
2799          * at this point we are the only ones with the pointer
2800          * to the struct since the kernel thread not created yet
2801          * no need to spinlock this init of tcpStatus or srv_count
2802          */
2803         tcp_ses->tcpStatus = CifsNew;
2804         ++tcp_ses->srv_count;
2805
2806         if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2807                 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2808                 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2809         else
2810                 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2811         if (tcp_ses->rdma) {
2812 #ifndef CONFIG_CIFS_SMB_DIRECT
2813                 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2814                 rc = -ENOENT;
2815                 goto out_err_crypto_release;
2816 #endif
2817                 tcp_ses->smbd_conn = smbd_get_connection(
2818                         tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2819                 if (tcp_ses->smbd_conn) {
2820                         cifs_dbg(VFS, "RDMA transport established\n");
2821                         rc = 0;
2822                         goto smbd_connected;
2823                 } else {
2824                         rc = -ENOENT;
2825                         goto out_err_crypto_release;
2826                 }
2827         }
2828         rc = ip_connect(tcp_ses);
2829         if (rc < 0) {
2830                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2831                 goto out_err_crypto_release;
2832         }
2833 smbd_connected:
2834         /*
2835          * since we're in a cifs function already, we know that
2836          * this will succeed. No need for try_module_get().
2837          */
2838         __module_get(THIS_MODULE);
2839         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2840                                   tcp_ses, "cifsd");
2841         if (IS_ERR(tcp_ses->tsk)) {
2842                 rc = PTR_ERR(tcp_ses->tsk);
2843                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2844                 module_put(THIS_MODULE);
2845                 goto out_err_crypto_release;
2846         }
2847         tcp_ses->min_offload = volume_info->min_offload;
2848         tcp_ses->tcpStatus = CifsNeedNegotiate;
2849
2850         tcp_ses->nr_targets = 1;
2851         tcp_ses->ignore_signature = volume_info->ignore_signature;
2852         /* thread spawned, put it on the list */
2853         spin_lock(&cifs_tcp_ses_lock);
2854         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2855         spin_unlock(&cifs_tcp_ses_lock);
2856
2857         cifs_fscache_get_client_cookie(tcp_ses);
2858
2859         /* queue echo request delayed work */
2860         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2861
2862         return tcp_ses;
2863
2864 out_err_crypto_release:
2865         cifs_crypto_secmech_release(tcp_ses);
2866
2867         put_net(cifs_net_ns(tcp_ses));
2868
2869 out_err:
2870         if (tcp_ses) {
2871                 if (!IS_ERR(tcp_ses->hostname))
2872                         kfree(tcp_ses->hostname);
2873                 if (tcp_ses->ssocket)
2874                         sock_release(tcp_ses->ssocket);
2875                 kfree(tcp_ses);
2876         }
2877         return ERR_PTR(rc);
2878 }
2879
2880 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2881 {
2882         if (vol->sectype != Unspecified &&
2883             vol->sectype != ses->sectype)
2884                 return 0;
2885
2886         /*
2887          * If an existing session is limited to less channels than
2888          * requested, it should not be reused
2889          */
2890         if (ses->chan_max < vol->max_channels)
2891                 return 0;
2892
2893         switch (ses->sectype) {
2894         case Kerberos:
2895                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2896                         return 0;
2897                 break;
2898         default:
2899                 /* NULL username means anonymous session */
2900                 if (ses->user_name == NULL) {
2901                         if (!vol->nullauth)
2902                                 return 0;
2903                         break;
2904                 }
2905
2906                 /* anything else takes username/password */
2907                 if (strncmp(ses->user_name,
2908                             vol->username ? vol->username : "",
2909                             CIFS_MAX_USERNAME_LEN))
2910                         return 0;
2911                 if ((vol->username && strlen(vol->username) != 0) &&
2912                     ses->password != NULL &&
2913                     strncmp(ses->password,
2914                             vol->password ? vol->password : "",
2915                             CIFS_MAX_PASSWORD_LEN))
2916                         return 0;
2917         }
2918         return 1;
2919 }
2920
2921 /**
2922  * cifs_setup_ipc - helper to setup the IPC tcon for the session
2923  *
2924  * A new IPC connection is made and stored in the session
2925  * tcon_ipc. The IPC tcon has the same lifetime as the session.
2926  */
2927 static int
2928 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2929 {
2930         int rc = 0, xid;
2931         struct cifs_tcon *tcon;
2932         struct nls_table *nls_codepage;
2933         char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2934         bool seal = false;
2935         struct TCP_Server_Info *server = ses->server;
2936
2937         /*
2938          * If the mount request that resulted in the creation of the
2939          * session requires encryption, force IPC to be encrypted too.
2940          */
2941         if (volume_info->seal) {
2942                 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2943                         seal = true;
2944                 else {
2945                         cifs_server_dbg(VFS,
2946                                  "IPC: server doesn't support encryption\n");
2947                         return -EOPNOTSUPP;
2948                 }
2949         }
2950
2951         tcon = tconInfoAlloc();
2952         if (tcon == NULL)
2953                 return -ENOMEM;
2954
2955         scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
2956
2957         /* cannot fail */
2958         nls_codepage = load_nls_default();
2959
2960         xid = get_xid();
2961         tcon->ses = ses;
2962         tcon->ipc = true;
2963         tcon->seal = seal;
2964         rc = server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
2965         free_xid(xid);
2966
2967         if (rc) {
2968                 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
2969                 tconInfoFree(tcon);
2970                 goto out;
2971         }
2972
2973         cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
2974
2975         ses->tcon_ipc = tcon;
2976 out:
2977         unload_nls(nls_codepage);
2978         return rc;
2979 }
2980
2981 /**
2982  * cifs_free_ipc - helper to release the session IPC tcon
2983  *
2984  * Needs to be called everytime a session is destroyed
2985  */
2986 static int
2987 cifs_free_ipc(struct cifs_ses *ses)
2988 {
2989         int rc = 0, xid;
2990         struct cifs_tcon *tcon = ses->tcon_ipc;
2991
2992         if (tcon == NULL)
2993                 return 0;
2994
2995         if (ses->server->ops->tree_disconnect) {
2996                 xid = get_xid();
2997                 rc = ses->server->ops->tree_disconnect(xid, tcon);
2998                 free_xid(xid);
2999         }
3000
3001         if (rc)
3002                 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
3003
3004         tconInfoFree(tcon);
3005         ses->tcon_ipc = NULL;
3006         return rc;
3007 }
3008
3009 static struct cifs_ses *
3010 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
3011 {
3012         struct cifs_ses *ses;
3013
3014         spin_lock(&cifs_tcp_ses_lock);
3015         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
3016                 if (ses->status == CifsExiting)
3017                         continue;
3018                 if (!match_session(ses, vol))
3019                         continue;
3020                 ++ses->ses_count;
3021                 spin_unlock(&cifs_tcp_ses_lock);
3022                 return ses;
3023         }
3024         spin_unlock(&cifs_tcp_ses_lock);
3025         return NULL;
3026 }
3027
3028 void cifs_put_smb_ses(struct cifs_ses *ses)
3029 {
3030         unsigned int rc, xid;
3031         struct TCP_Server_Info *server = ses->server;
3032
3033         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
3034
3035         spin_lock(&cifs_tcp_ses_lock);
3036         if (ses->status == CifsExiting) {
3037                 spin_unlock(&cifs_tcp_ses_lock);
3038                 return;
3039         }
3040         if (--ses->ses_count > 0) {
3041                 spin_unlock(&cifs_tcp_ses_lock);
3042                 return;
3043         }
3044         if (ses->status == CifsGood)
3045                 ses->status = CifsExiting;
3046         spin_unlock(&cifs_tcp_ses_lock);
3047
3048         cifs_free_ipc(ses);
3049
3050         if (ses->status == CifsExiting && server->ops->logoff) {
3051                 xid = get_xid();
3052                 rc = server->ops->logoff(xid, ses);
3053                 if (rc)
3054                         cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
3055                                 __func__, rc);
3056                 _free_xid(xid);
3057         }
3058
3059         spin_lock(&cifs_tcp_ses_lock);
3060         list_del_init(&ses->smb_ses_list);
3061         spin_unlock(&cifs_tcp_ses_lock);
3062
3063         /* close any extra channels */
3064         if (ses->chan_count > 1) {
3065                 int i;
3066
3067                 for (i = 1; i < ses->chan_count; i++)
3068                         cifs_put_tcp_session(ses->chans[i].server, 0);
3069         }
3070
3071         sesInfoFree(ses);
3072         cifs_put_tcp_session(server, 0);
3073 }
3074
3075 #ifdef CONFIG_KEYS
3076
3077 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
3078 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
3079
3080 /* Populate username and pw fields from keyring if possible */
3081 static int
3082 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
3083 {
3084         int rc = 0;
3085         int is_domain = 0;
3086         const char *delim, *payload;
3087         char *desc;
3088         ssize_t len;
3089         struct key *key;
3090         struct TCP_Server_Info *server = ses->server;
3091         struct sockaddr_in *sa;
3092         struct sockaddr_in6 *sa6;
3093         const struct user_key_payload *upayload;
3094
3095         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
3096         if (!desc)
3097                 return -ENOMEM;
3098
3099         /* try to find an address key first */
3100         switch (server->dstaddr.ss_family) {
3101         case AF_INET:
3102                 sa = (struct sockaddr_in *)&server->dstaddr;
3103                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
3104                 break;
3105         case AF_INET6:
3106                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
3107                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
3108                 break;
3109         default:
3110                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
3111                          server->dstaddr.ss_family);
3112                 rc = -EINVAL;
3113                 goto out_err;
3114         }
3115
3116         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3117         key = request_key(&key_type_logon, desc, "");
3118         if (IS_ERR(key)) {
3119                 if (!ses->domainName) {
3120                         cifs_dbg(FYI, "domainName is NULL\n");
3121                         rc = PTR_ERR(key);
3122                         goto out_err;
3123                 }
3124
3125                 /* didn't work, try to find a domain key */
3126                 sprintf(desc, "cifs:d:%s", ses->domainName);
3127                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3128                 key = request_key(&key_type_logon, desc, "");
3129                 if (IS_ERR(key)) {
3130                         rc = PTR_ERR(key);
3131                         goto out_err;
3132                 }
3133                 is_domain = 1;
3134         }
3135
3136         down_read(&key->sem);
3137         upayload = user_key_payload_locked(key);
3138         if (IS_ERR_OR_NULL(upayload)) {
3139                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3140                 goto out_key_put;
3141         }
3142
3143         /* find first : in payload */
3144         payload = upayload->data;
3145         delim = strnchr(payload, upayload->datalen, ':');
3146         cifs_dbg(FYI, "payload=%s\n", payload);
3147         if (!delim) {
3148                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3149                          upayload->datalen);
3150                 rc = -EINVAL;
3151                 goto out_key_put;
3152         }
3153
3154         len = delim - payload;
3155         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3156                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3157                          len);
3158                 rc = -EINVAL;
3159                 goto out_key_put;
3160         }
3161
3162         vol->username = kstrndup(payload, len, GFP_KERNEL);
3163         if (!vol->username) {
3164                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3165                          len);
3166                 rc = -ENOMEM;
3167                 goto out_key_put;
3168         }
3169         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3170
3171         len = key->datalen - (len + 1);
3172         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3173                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3174                 rc = -EINVAL;
3175                 kfree(vol->username);
3176                 vol->username = NULL;
3177                 goto out_key_put;
3178         }
3179
3180         ++delim;
3181         vol->password = kstrndup(delim, len, GFP_KERNEL);
3182         if (!vol->password) {
3183                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3184                          len);
3185                 rc = -ENOMEM;
3186                 kfree(vol->username);
3187                 vol->username = NULL;
3188                 goto out_key_put;
3189         }
3190
3191         /*
3192          * If we have a domain key then we must set the domainName in the
3193          * for the request.
3194          */
3195         if (is_domain && ses->domainName) {
3196                 vol->domainname = kstrndup(ses->domainName,
3197                                            strlen(ses->domainName),
3198                                            GFP_KERNEL);
3199                 if (!vol->domainname) {
3200                         cifs_dbg(FYI, "Unable to allocate %zd bytes for "
3201                                  "domain\n", len);
3202                         rc = -ENOMEM;
3203                         kfree(vol->username);
3204                         vol->username = NULL;
3205                         kzfree(vol->password);
3206                         vol->password = NULL;
3207                         goto out_key_put;
3208                 }
3209         }
3210
3211 out_key_put:
3212         up_read(&key->sem);
3213         key_put(key);
3214 out_err:
3215         kfree(desc);
3216         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3217         return rc;
3218 }
3219 #else /* ! CONFIG_KEYS */
3220 static inline int
3221 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3222                    struct cifs_ses *ses __attribute__((unused)))
3223 {
3224         return -ENOSYS;
3225 }
3226 #endif /* CONFIG_KEYS */
3227
3228 /**
3229  * cifs_get_smb_ses - get a session matching @volume_info data from @server
3230  *
3231  * This function assumes it is being called from cifs_mount() where we
3232  * already got a server reference (server refcount +1). See
3233  * cifs_get_tcon() for refcount explanations.
3234  */
3235 struct cifs_ses *
3236 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3237 {
3238         int rc = -ENOMEM;
3239         unsigned int xid;
3240         struct cifs_ses *ses;
3241         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3242         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3243
3244         xid = get_xid();
3245
3246         ses = cifs_find_smb_ses(server, volume_info);
3247         if (ses) {
3248                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3249                          ses->status);
3250
3251                 mutex_lock(&ses->session_mutex);
3252                 rc = cifs_negotiate_protocol(xid, ses);
3253                 if (rc) {
3254                         mutex_unlock(&ses->session_mutex);
3255                         /* problem -- put our ses reference */
3256                         cifs_put_smb_ses(ses);
3257                         free_xid(xid);
3258                         return ERR_PTR(rc);
3259                 }
3260                 if (ses->need_reconnect) {
3261                         cifs_dbg(FYI, "Session needs reconnect\n");
3262                         rc = cifs_setup_session(xid, ses,
3263                                                 volume_info->local_nls);
3264                         if (rc) {
3265                                 mutex_unlock(&ses->session_mutex);
3266                                 /* problem -- put our reference */
3267                                 cifs_put_smb_ses(ses);
3268                                 free_xid(xid);
3269                                 return ERR_PTR(rc);
3270                         }
3271                 }
3272                 mutex_unlock(&ses->session_mutex);
3273
3274                 /* existing SMB ses has a server reference already */
3275                 cifs_put_tcp_session(server, 0);
3276                 free_xid(xid);
3277                 return ses;
3278         }
3279
3280         cifs_dbg(FYI, "Existing smb sess not found\n");
3281         ses = sesInfoAlloc();
3282         if (ses == NULL)
3283                 goto get_ses_fail;
3284
3285         /* new SMB session uses our server ref */
3286         ses->server = server;
3287         if (server->dstaddr.ss_family == AF_INET6)
3288                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3289         else
3290                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3291
3292         if (volume_info->username) {
3293                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3294                 if (!ses->user_name)
3295                         goto get_ses_fail;
3296         }
3297
3298         /* volume_info->password freed at unmount */
3299         if (volume_info->password) {
3300                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3301                 if (!ses->password)
3302                         goto get_ses_fail;
3303         }
3304         if (volume_info->domainname) {
3305                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3306                 if (!ses->domainName)
3307                         goto get_ses_fail;
3308         }
3309         if (volume_info->domainauto)
3310                 ses->domainAuto = volume_info->domainauto;
3311         ses->cred_uid = volume_info->cred_uid;
3312         ses->linux_uid = volume_info->linux_uid;
3313
3314         ses->sectype = volume_info->sectype;
3315         ses->sign = volume_info->sign;
3316         mutex_lock(&ses->session_mutex);
3317
3318         /* add server as first channel */
3319         ses->chans[0].server = server;
3320         ses->chan_count = 1;
3321         ses->chan_max = volume_info->multichannel ? volume_info->max_channels:1;
3322
3323         rc = cifs_negotiate_protocol(xid, ses);
3324         if (!rc)
3325                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3326
3327         /* each channel uses a different signing key */
3328         memcpy(ses->chans[0].signkey, ses->smb3signingkey,
3329                sizeof(ses->smb3signingkey));
3330
3331         mutex_unlock(&ses->session_mutex);
3332         if (rc)
3333                 goto get_ses_fail;
3334
3335         /* success, put it on the list and add it as first channel */
3336         spin_lock(&cifs_tcp_ses_lock);
3337         list_add(&ses->smb_ses_list, &server->smb_ses_list);
3338         spin_unlock(&cifs_tcp_ses_lock);
3339
3340         free_xid(xid);
3341
3342         cifs_setup_ipc(ses, volume_info);
3343
3344         return ses;
3345
3346 get_ses_fail:
3347         sesInfoFree(ses);
3348         free_xid(xid);
3349         return ERR_PTR(rc);
3350 }
3351
3352 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3353 {
3354         if (tcon->tidStatus == CifsExiting)
3355                 return 0;
3356         if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3357                 return 0;
3358         if (tcon->seal != volume_info->seal)
3359                 return 0;
3360         if (tcon->snapshot_time != volume_info->snapshot_time)
3361                 return 0;
3362         if (tcon->handle_timeout != volume_info->handle_timeout)
3363                 return 0;
3364         if (tcon->no_lease != volume_info->no_lease)
3365                 return 0;
3366         return 1;
3367 }
3368
3369 static struct cifs_tcon *
3370 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3371 {
3372         struct list_head *tmp;
3373         struct cifs_tcon *tcon;
3374
3375         spin_lock(&cifs_tcp_ses_lock);
3376         list_for_each(tmp, &ses->tcon_list) {
3377                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3378 #ifdef CONFIG_CIFS_DFS_UPCALL
3379                 if (tcon->dfs_path)
3380                         continue;
3381 #endif
3382                 if (!match_tcon(tcon, volume_info))
3383                         continue;
3384                 ++tcon->tc_count;
3385                 spin_unlock(&cifs_tcp_ses_lock);
3386                 return tcon;
3387         }
3388         spin_unlock(&cifs_tcp_ses_lock);
3389         return NULL;
3390 }
3391
3392 void
3393 cifs_put_tcon(struct cifs_tcon *tcon)
3394 {
3395         unsigned int xid;
3396         struct cifs_ses *ses;
3397
3398         /*
3399          * IPC tcon share the lifetime of their session and are
3400          * destroyed in the session put function
3401          */
3402         if (tcon == NULL || tcon->ipc)
3403                 return;
3404
3405         ses = tcon->ses;
3406         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3407         spin_lock(&cifs_tcp_ses_lock);
3408         if (--tcon->tc_count > 0) {
3409                 spin_unlock(&cifs_tcp_ses_lock);
3410                 return;
3411         }
3412
3413         list_del_init(&tcon->tcon_list);
3414         spin_unlock(&cifs_tcp_ses_lock);
3415
3416         xid = get_xid();
3417         if (ses->server->ops->tree_disconnect)
3418                 ses->server->ops->tree_disconnect(xid, tcon);
3419         _free_xid(xid);
3420
3421         cifs_fscache_release_super_cookie(tcon);
3422         tconInfoFree(tcon);
3423         cifs_put_smb_ses(ses);
3424 }
3425
3426 /**
3427  * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3428  *
3429  * - tcon refcount is the number of mount points using the tcon.
3430  * - ses refcount is the number of tcon using the session.
3431  *
3432  * 1. This function assumes it is being called from cifs_mount() where
3433  *    we already got a session reference (ses refcount +1).
3434  *
3435  * 2. Since we're in the context of adding a mount point, the end
3436  *    result should be either:
3437  *
3438  * a) a new tcon already allocated with refcount=1 (1 mount point) and
3439  *    its session refcount incremented (1 new tcon). This +1 was
3440  *    already done in (1).
3441  *
3442  * b) an existing tcon with refcount+1 (add a mount point to it) and
3443  *    identical ses refcount (no new tcon). Because of (1) we need to
3444  *    decrement the ses refcount.
3445  */
3446 static struct cifs_tcon *
3447 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3448 {
3449         int rc, xid;
3450         struct cifs_tcon *tcon;
3451
3452         tcon = cifs_find_tcon(ses, volume_info);
3453         if (tcon) {
3454                 /*
3455                  * tcon has refcount already incremented but we need to
3456                  * decrement extra ses reference gotten by caller (case b)
3457                  */
3458                 cifs_dbg(FYI, "Found match on UNC path\n");
3459                 cifs_put_smb_ses(ses);
3460                 return tcon;
3461         }
3462
3463         if (!ses->server->ops->tree_connect) {
3464                 rc = -ENOSYS;
3465                 goto out_fail;
3466         }
3467
3468         tcon = tconInfoAlloc();
3469         if (tcon == NULL) {
3470                 rc = -ENOMEM;
3471                 goto out_fail;
3472         }
3473
3474         if (volume_info->snapshot_time) {
3475                 if (ses->server->vals->protocol_id == 0) {
3476                         cifs_dbg(VFS,
3477                              "Use SMB2 or later for snapshot mount option\n");
3478                         rc = -EOPNOTSUPP;
3479                         goto out_fail;
3480                 } else
3481                         tcon->snapshot_time = volume_info->snapshot_time;
3482         }
3483
3484         if (volume_info->handle_timeout) {
3485                 if (ses->server->vals->protocol_id == 0) {
3486                         cifs_dbg(VFS,
3487                              "Use SMB2.1 or later for handle timeout option\n");
3488                         rc = -EOPNOTSUPP;
3489                         goto out_fail;
3490                 } else
3491                         tcon->handle_timeout = volume_info->handle_timeout;
3492         }
3493
3494         tcon->ses = ses;
3495         if (volume_info->password) {
3496                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3497                 if (!tcon->password) {
3498                         rc = -ENOMEM;
3499                         goto out_fail;
3500                 }
3501         }
3502
3503         if (volume_info->seal) {
3504                 if (ses->server->vals->protocol_id == 0) {
3505                         cifs_dbg(VFS,
3506                                  "SMB3 or later required for encryption\n");
3507                         rc = -EOPNOTSUPP;
3508                         goto out_fail;
3509                 } else if (tcon->ses->server->capabilities &
3510                                         SMB2_GLOBAL_CAP_ENCRYPTION)
3511                         tcon->seal = true;
3512                 else {
3513                         cifs_dbg(VFS, "Encryption is not supported on share\n");
3514                         rc = -EOPNOTSUPP;
3515                         goto out_fail;
3516                 }
3517         }
3518
3519         if (volume_info->linux_ext) {
3520                 if (ses->server->posix_ext_supported) {
3521                         tcon->posix_extensions = true;
3522                         printk_once(KERN_WARNING
3523                                 "SMB3.11 POSIX Extensions are experimental\n");
3524                 } else {
3525                         cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3526                         rc = -EOPNOTSUPP;
3527                         goto out_fail;
3528                 }
3529         }
3530
3531         /*
3532          * BB Do we need to wrap session_mutex around this TCon call and Unix
3533          * SetFS as we do on SessSetup and reconnect?
3534          */
3535         xid = get_xid();
3536         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3537                                             volume_info->local_nls);
3538         free_xid(xid);
3539         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3540         if (rc)
3541                 goto out_fail;
3542
3543         tcon->use_persistent = false;
3544         /* check if SMB2 or later, CIFS does not support persistent handles */
3545         if (volume_info->persistent) {
3546                 if (ses->server->vals->protocol_id == 0) {
3547                         cifs_dbg(VFS,
3548                              "SMB3 or later required for persistent handles\n");
3549                         rc = -EOPNOTSUPP;
3550                         goto out_fail;
3551                 } else if (ses->server->capabilities &
3552                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3553                         tcon->use_persistent = true;
3554                 else /* persistent handles requested but not supported */ {
3555                         cifs_dbg(VFS,
3556                                 "Persistent handles not supported on share\n");
3557                         rc = -EOPNOTSUPP;
3558                         goto out_fail;
3559                 }
3560         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3561              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3562              && (volume_info->nopersistent == false)) {
3563                 cifs_dbg(FYI, "enabling persistent handles\n");
3564                 tcon->use_persistent = true;
3565         } else if (volume_info->resilient) {
3566                 if (ses->server->vals->protocol_id == 0) {
3567                         cifs_dbg(VFS,
3568                              "SMB2.1 or later required for resilient handles\n");
3569                         rc = -EOPNOTSUPP;
3570                         goto out_fail;
3571                 }
3572                 tcon->use_resilient = true;
3573         }
3574
3575         /* If the user really knows what they are doing they can override */
3576         if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
3577                 if (volume_info->cache_ro)
3578                         cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
3579                 else if (volume_info->cache_rw)
3580                         cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
3581         }
3582
3583         /*
3584          * We can have only one retry value for a connection to a share so for
3585          * resources mounted more than once to the same server share the last
3586          * value passed in for the retry flag is used.
3587          */
3588         tcon->retry = volume_info->retry;
3589         tcon->nocase = volume_info->nocase;
3590         tcon->nohandlecache = volume_info->nohandlecache;
3591         tcon->local_lease = volume_info->local_lease;
3592         tcon->no_lease = volume_info->no_lease;
3593         INIT_LIST_HEAD(&tcon->pending_opens);
3594
3595         spin_lock(&cifs_tcp_ses_lock);
3596         list_add(&tcon->tcon_list, &ses->tcon_list);
3597         spin_unlock(&cifs_tcp_ses_lock);
3598
3599         cifs_fscache_get_super_cookie(tcon);
3600
3601         return tcon;
3602
3603 out_fail:
3604         tconInfoFree(tcon);
3605         return ERR_PTR(rc);
3606 }
3607
3608 void
3609 cifs_put_tlink(struct tcon_link *tlink)
3610 {
3611         if (!tlink || IS_ERR(tlink))
3612                 return;
3613
3614         if (!atomic_dec_and_test(&tlink->tl_count) ||
3615             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3616                 tlink->tl_time = jiffies;
3617                 return;
3618         }
3619
3620         if (!IS_ERR(tlink_tcon(tlink)))
3621                 cifs_put_tcon(tlink_tcon(tlink));
3622         kfree(tlink);
3623         return;
3624 }
3625
3626 static int
3627 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3628 {
3629         struct cifs_sb_info *old = CIFS_SB(sb);
3630         struct cifs_sb_info *new = mnt_data->cifs_sb;
3631         unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
3632         unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
3633
3634         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3635                 return 0;
3636
3637         if (old->mnt_cifs_serverino_autodisabled)
3638                 newflags &= ~CIFS_MOUNT_SERVER_INUM;
3639
3640         if (oldflags != newflags)
3641                 return 0;
3642
3643         /*
3644          * We want to share sb only if we don't specify an r/wsize or
3645          * specified r/wsize is greater than or equal to existing one.
3646          */
3647         if (new->wsize && new->wsize < old->wsize)
3648                 return 0;
3649
3650         if (new->rsize && new->rsize < old->rsize)
3651                 return 0;
3652
3653         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3654                 return 0;
3655
3656         if (old->mnt_file_mode != new->mnt_file_mode ||
3657             old->mnt_dir_mode != new->mnt_dir_mode)
3658                 return 0;
3659
3660         if (strcmp(old->local_nls->charset, new->local_nls->charset))
3661                 return 0;
3662
3663         if (old->actimeo != new->actimeo)
3664                 return 0;
3665
3666         return 1;
3667 }
3668
3669 static int
3670 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3671 {
3672         struct cifs_sb_info *old = CIFS_SB(sb);
3673         struct cifs_sb_info *new = mnt_data->cifs_sb;
3674         bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
3675                 old->prepath;
3676         bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
3677                 new->prepath;
3678
3679         if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3680                 return 1;
3681         else if (!old_set && !new_set)
3682                 return 1;
3683
3684         return 0;
3685 }
3686
3687 int
3688 cifs_match_super(struct super_block *sb, void *data)
3689 {
3690         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3691         struct smb_vol *volume_info;
3692         struct cifs_sb_info *cifs_sb;
3693         struct TCP_Server_Info *tcp_srv;
3694         struct cifs_ses *ses;
3695         struct cifs_tcon *tcon;
3696         struct tcon_link *tlink;
3697         int rc = 0;
3698
3699         spin_lock(&cifs_tcp_ses_lock);
3700         cifs_sb = CIFS_SB(sb);
3701         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3702         if (IS_ERR(tlink)) {
3703                 spin_unlock(&cifs_tcp_ses_lock);
3704                 return rc;
3705         }
3706         tcon = tlink_tcon(tlink);
3707         ses = tcon->ses;
3708         tcp_srv = ses->server;
3709
3710         volume_info = mnt_data->vol;
3711
3712         if (!match_server(tcp_srv, volume_info) ||
3713             !match_session(ses, volume_info) ||
3714             !match_tcon(tcon, volume_info) ||
3715             !match_prepath(sb, mnt_data)) {
3716                 rc = 0;
3717                 goto out;
3718         }
3719
3720         rc = compare_mount_options(sb, mnt_data);
3721 out:
3722         spin_unlock(&cifs_tcp_ses_lock);
3723         cifs_put_tlink(tlink);
3724         return rc;
3725 }
3726
3727 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3728 static struct lock_class_key cifs_key[2];
3729 static struct lock_class_key cifs_slock_key[2];
3730
3731 static inline void
3732 cifs_reclassify_socket4(struct socket *sock)
3733 {
3734         struct sock *sk = sock->sk;
3735         BUG_ON(!sock_allow_reclassification(sk));
3736         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3737                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3738 }
3739
3740 static inline void
3741 cifs_reclassify_socket6(struct socket *sock)
3742 {
3743         struct sock *sk = sock->sk;
3744         BUG_ON(!sock_allow_reclassification(sk));
3745         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3746                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3747 }
3748 #else
3749 static inline void
3750 cifs_reclassify_socket4(struct socket *sock)
3751 {
3752 }
3753
3754 static inline void
3755 cifs_reclassify_socket6(struct socket *sock)
3756 {
3757 }
3758 #endif
3759
3760 /* See RFC1001 section 14 on representation of Netbios names */
3761 static void rfc1002mangle(char *target, char *source, unsigned int length)
3762 {
3763         unsigned int i, j;
3764
3765         for (i = 0, j = 0; i < (length); i++) {
3766                 /* mask a nibble at a time and encode */
3767                 target[j] = 'A' + (0x0F & (source[i] >> 4));
3768                 target[j+1] = 'A' + (0x0F & source[i]);
3769                 j += 2;
3770         }
3771
3772 }
3773
3774 static int
3775 bind_socket(struct TCP_Server_Info *server)
3776 {
3777         int rc = 0;
3778         if (server->srcaddr.ss_family != AF_UNSPEC) {
3779                 /* Bind to the specified local IP address */
3780                 struct socket *socket = server->ssocket;
3781                 rc = socket->ops->bind(socket,
3782                                        (struct sockaddr *) &server->srcaddr,
3783                                        sizeof(server->srcaddr));
3784                 if (rc < 0) {
3785                         struct sockaddr_in *saddr4;
3786                         struct sockaddr_in6 *saddr6;
3787                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
3788                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3789                         if (saddr6->sin6_family == AF_INET6)
3790                                 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3791                                          &saddr6->sin6_addr, rc);
3792                         else
3793                                 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3794                                          &saddr4->sin_addr.s_addr, rc);
3795                 }
3796         }
3797         return rc;
3798 }
3799
3800 static int
3801 ip_rfc1001_connect(struct TCP_Server_Info *server)
3802 {
3803         int rc = 0;
3804         /*
3805          * some servers require RFC1001 sessinit before sending
3806          * negprot - BB check reconnection in case where second
3807          * sessinit is sent but no second negprot
3808          */
3809         struct rfc1002_session_packet *ses_init_buf;
3810         struct smb_hdr *smb_buf;
3811         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3812                                GFP_KERNEL);
3813         if (ses_init_buf) {
3814                 ses_init_buf->trailer.session_req.called_len = 32;
3815
3816                 if (server->server_RFC1001_name[0] != 0)
3817                         rfc1002mangle(ses_init_buf->trailer.
3818                                       session_req.called_name,
3819                                       server->server_RFC1001_name,
3820                                       RFC1001_NAME_LEN_WITH_NULL);
3821                 else
3822                         rfc1002mangle(ses_init_buf->trailer.
3823                                       session_req.called_name,
3824                                       DEFAULT_CIFS_CALLED_NAME,
3825                                       RFC1001_NAME_LEN_WITH_NULL);
3826
3827                 ses_init_buf->trailer.session_req.calling_len = 32;
3828
3829                 /*
3830                  * calling name ends in null (byte 16) from old smb
3831                  * convention.
3832                  */
3833                 if (server->workstation_RFC1001_name[0] != 0)
3834                         rfc1002mangle(ses_init_buf->trailer.
3835                                       session_req.calling_name,
3836                                       server->workstation_RFC1001_name,
3837                                       RFC1001_NAME_LEN_WITH_NULL);
3838                 else
3839                         rfc1002mangle(ses_init_buf->trailer.
3840                                       session_req.calling_name,
3841                                       "LINUX_CIFS_CLNT",
3842                                       RFC1001_NAME_LEN_WITH_NULL);
3843
3844                 ses_init_buf->trailer.session_req.scope1 = 0;
3845                 ses_init_buf->trailer.session_req.scope2 = 0;
3846                 smb_buf = (struct smb_hdr *)ses_init_buf;
3847
3848                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3849                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3850                 rc = smb_send(server, smb_buf, 0x44);
3851                 kfree(ses_init_buf);
3852                 /*
3853                  * RFC1001 layer in at least one server
3854                  * requires very short break before negprot
3855                  * presumably because not expecting negprot
3856                  * to follow so fast.  This is a simple
3857                  * solution that works without
3858                  * complicating the code and causes no
3859                  * significant slowing down on mount
3860                  * for everyone else
3861                  */
3862                 usleep_range(1000, 2000);
3863         }
3864         /*
3865          * else the negprot may still work without this
3866          * even though malloc failed
3867          */
3868
3869         return rc;
3870 }
3871
3872 static int
3873 generic_ip_connect(struct TCP_Server_Info *server)
3874 {
3875         int rc = 0;
3876         __be16 sport;
3877         int slen, sfamily;
3878         struct socket *socket = server->ssocket;
3879         struct sockaddr *saddr;
3880
3881         saddr = (struct sockaddr *) &server->dstaddr;
3882
3883         if (server->dstaddr.ss_family == AF_INET6) {
3884                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3885                 slen = sizeof(struct sockaddr_in6);
3886                 sfamily = AF_INET6;
3887         } else {
3888                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3889                 slen = sizeof(struct sockaddr_in);
3890                 sfamily = AF_INET;
3891         }
3892
3893         if (socket == NULL) {
3894                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3895                                    IPPROTO_TCP, &socket, 1);
3896                 if (rc < 0) {
3897                         cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
3898                         server->ssocket = NULL;
3899                         return rc;
3900                 }
3901
3902                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3903                 cifs_dbg(FYI, "Socket created\n");
3904                 server->ssocket = socket;
3905                 socket->sk->sk_allocation = GFP_NOFS;
3906                 if (sfamily == AF_INET6)
3907                         cifs_reclassify_socket6(socket);
3908                 else
3909                         cifs_reclassify_socket4(socket);
3910         }
3911
3912         rc = bind_socket(server);
3913         if (rc < 0)
3914                 return rc;
3915
3916         /*
3917          * Eventually check for other socket options to change from
3918          * the default. sock_setsockopt not used because it expects
3919          * user space buffer
3920          */
3921         socket->sk->sk_rcvtimeo = 7 * HZ;
3922         socket->sk->sk_sndtimeo = 5 * HZ;
3923
3924         /* make the bufsizes depend on wsize/rsize and max requests */
3925         if (server->noautotune) {
3926                 if (socket->sk->sk_sndbuf < (200 * 1024))
3927                         socket->sk->sk_sndbuf = 200 * 1024;
3928                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3929                         socket->sk->sk_rcvbuf = 140 * 1024;
3930         }
3931
3932         if (server->tcp_nodelay)
3933                 tcp_sock_set_nodelay(socket->sk);
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 }