fs/cifs/connect.c

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