fs/cifs/connect.c

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