fs/cifs/fs_context.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Copyright (C) 2020, Microsoft Corporation.
   4  *
   5  *   Author(s): Steve French <stfrench@microsoft.com>
   6  *              David Howells <dhowells@redhat.com>
   7  */
   8
   9 /*
  10 #include <linux/module.h>
  11 #include <linux/nsproxy.h>
  12 #include <linux/slab.h>
  13 #include <linux/magic.h>
  14 #include <linux/security.h>
  15 #include <net/net_namespace.h>
  16 #ifdef CONFIG_CIFS_DFS_UPCALL
  17 #include "dfs_cache.h"
  18 #endif
  19 */
  20
  21 #include <linux/ctype.h>
  22 #include <linux/fs_context.h>
  23 #include <linux/fs_parser.h>
  24 #include <linux/fs.h>
  25 #include <linux/mount.h>
  26 #include <linux/parser.h>
  27 #include <linux/utsname.h>
  28 #include "cifsfs.h"
  29 #include "cifspdu.h"
  30 #include "cifsglob.h"
  31 #include "cifsproto.h"
  32 #include "cifs_unicode.h"
  33 #include "cifs_debug.h"
  34 #include "cifs_fs_sb.h"
  35 #include "ntlmssp.h"
  36 #include "nterr.h"
  37 #include "rfc1002pdu.h"
  38 #include "fs_context.h"
  39
  40 static DEFINE_MUTEX(cifs_mount_mutex);
  41
  42 static const match_table_t cifs_smb_version_tokens = {
  43         { Smb_1, SMB1_VERSION_STRING },
  44         { Smb_20, SMB20_VERSION_STRING},
  45         { Smb_21, SMB21_VERSION_STRING },
  46         { Smb_30, SMB30_VERSION_STRING },
  47         { Smb_302, SMB302_VERSION_STRING },
  48         { Smb_302, ALT_SMB302_VERSION_STRING },
  49         { Smb_311, SMB311_VERSION_STRING },
  50         { Smb_311, ALT_SMB311_VERSION_STRING },
  51         { Smb_3any, SMB3ANY_VERSION_STRING },
  52         { Smb_default, SMBDEFAULT_VERSION_STRING },
  53         { Smb_version_err, NULL }
  54 };
  55
  56 static const match_table_t cifs_secflavor_tokens = {
  57         { Opt_sec_krb5, "krb5" },
  58         { Opt_sec_krb5i, "krb5i" },
  59         { Opt_sec_krb5p, "krb5p" },
  60         { Opt_sec_ntlmsspi, "ntlmsspi" },
  61         { Opt_sec_ntlmssp, "ntlmssp" },
  62         { Opt_sec_ntlmv2, "nontlm" },
  63         { Opt_sec_ntlmv2, "ntlmv2" },
  64         { Opt_sec_ntlmv2i, "ntlmv2i" },
  65         { Opt_sec_none, "none" },
  66
  67         { Opt_sec_err, NULL }
  68 };
  69
  70 const struct fs_parameter_spec smb3_fs_parameters[] = {
  71         /* Mount options that take no arguments */
  72         fsparam_flag_no("user_xattr", Opt_user_xattr),
  73         fsparam_flag_no("forceuid", Opt_forceuid),
  74         fsparam_flag_no("multichannel", Opt_multichannel),
  75         fsparam_flag_no("forcegid", Opt_forcegid),
  76         fsparam_flag("noblocksend", Opt_noblocksend),
  77         fsparam_flag("noautotune", Opt_noautotune),
  78         fsparam_flag("nolease", Opt_nolease),
  79         fsparam_flag_no("hard", Opt_hard),
  80         fsparam_flag_no("soft", Opt_soft),
  81         fsparam_flag_no("perm", Opt_perm),
  82         fsparam_flag("nodelete", Opt_nodelete),
  83         fsparam_flag_no("mapposix", Opt_mapposix),
  84         fsparam_flag("mapchars", Opt_mapchars),
  85         fsparam_flag("nomapchars", Opt_nomapchars),
  86         fsparam_flag_no("sfu", Opt_sfu),
  87         fsparam_flag("nodfs", Opt_nodfs),
  88         fsparam_flag_no("posixpaths", Opt_posixpaths),
  89         fsparam_flag_no("unix", Opt_unix),
  90         fsparam_flag_no("linux", Opt_unix),
  91         fsparam_flag_no("posix", Opt_unix),
  92         fsparam_flag("nocase", Opt_nocase),
  93         fsparam_flag("ignorecase", Opt_nocase),
  94         fsparam_flag_no("brl", Opt_brl),
  95         fsparam_flag_no("handlecache", Opt_handlecache),
  96         fsparam_flag("forcemandatorylock", Opt_forcemandatorylock),
  97         fsparam_flag("forcemand", Opt_forcemandatorylock),
  98         fsparam_flag("setuidfromacl", Opt_setuidfromacl),
  99         fsparam_flag("idsfromsid", Opt_setuidfromacl),
 100         fsparam_flag_no("setuids", Opt_setuids),
 101         fsparam_flag_no("dynperm", Opt_dynperm),
 102         fsparam_flag_no("intr", Opt_intr),
 103         fsparam_flag_no("strictsync", Opt_strictsync),
 104         fsparam_flag_no("serverino", Opt_serverino),
 105         fsparam_flag("rwpidforward", Opt_rwpidforward),
 106         fsparam_flag("cifsacl", Opt_cifsacl),
 107         fsparam_flag_no("acl", Opt_acl),
 108         fsparam_flag("locallease", Opt_locallease),
 109         fsparam_flag("sign", Opt_sign),
 110         fsparam_flag("ignore_signature", Opt_ignore_signature),
 111         fsparam_flag("signloosely", Opt_ignore_signature),
 112         fsparam_flag("seal", Opt_seal),
 113         fsparam_flag("noac", Opt_noac),
 114         fsparam_flag("fsc", Opt_fsc),
 115         fsparam_flag("mfsymlinks", Opt_mfsymlinks),
 116         fsparam_flag("multiuser", Opt_multiuser),
 117         fsparam_flag("sloppy", Opt_sloppy),
 118         fsparam_flag("nosharesock", Opt_nosharesock),
 119         fsparam_flag_no("persistenthandles", Opt_persistent),
 120         fsparam_flag_no("resilienthandles", Opt_resilient),
 121         fsparam_flag_no("tcpnodelay", Opt_tcp_nodelay),
 122         fsparam_flag("nosparse", Opt_nosparse),
 123         fsparam_flag("domainauto", Opt_domainauto),
 124         fsparam_flag("rdma", Opt_rdma),
 125         fsparam_flag("modesid", Opt_modesid),
 126         fsparam_flag("modefromsid", Opt_modesid),
 127         fsparam_flag("rootfs", Opt_rootfs),
 128         fsparam_flag("compress", Opt_compress),
 129         fsparam_flag("witness", Opt_witness),
 130
 131         /* Mount options which take numeric value */
 132         fsparam_u32("backupuid", Opt_backupuid),
 133         fsparam_u32("backupgid", Opt_backupgid),
 134         fsparam_u32("uid", Opt_uid),
 135         fsparam_u32("cruid", Opt_cruid),
 136         fsparam_u32("gid", Opt_gid),
 137         fsparam_u32("file_mode", Opt_file_mode),
 138         fsparam_u32("dirmode", Opt_dirmode),
 139         fsparam_u32("dir_mode", Opt_dirmode),
 140         fsparam_u32("port", Opt_port),
 141         fsparam_u32("min_enc_offload", Opt_min_enc_offload),
 142         fsparam_u32("esize", Opt_min_enc_offload),
 143         fsparam_u32("bsize", Opt_blocksize),
 144         fsparam_u32("rasize", Opt_rasize),
 145         fsparam_u32("rsize", Opt_rsize),
 146         fsparam_u32("wsize", Opt_wsize),
 147         fsparam_u32("actimeo", Opt_actimeo),
 148         fsparam_u32("acdirmax", Opt_acdirmax),
 149         fsparam_u32("acregmax", Opt_acregmax),
 150         fsparam_u32("closetimeo", Opt_closetimeo),
 151         fsparam_u32("echo_interval", Opt_echo_interval),
 152         fsparam_u32("max_credits", Opt_max_credits),
 153         fsparam_u32("handletimeout", Opt_handletimeout),
 154         fsparam_u64("snapshot", Opt_snapshot),
 155         fsparam_u32("max_channels", Opt_max_channels),
 156
 157         /* Mount options which take string value */
 158         fsparam_string("source", Opt_source),
 159         fsparam_string("user", Opt_user),
 160         fsparam_string("username", Opt_user),
 161         fsparam_string("pass", Opt_pass),
 162         fsparam_string("password", Opt_pass),
 163         fsparam_string("ip", Opt_ip),
 164         fsparam_string("addr", Opt_ip),
 165         fsparam_string("domain", Opt_domain),
 166         fsparam_string("dom", Opt_domain),
 167         fsparam_string("srcaddr", Opt_srcaddr),
 168         fsparam_string("iocharset", Opt_iocharset),
 169         fsparam_string("netbiosname", Opt_netbiosname),
 170         fsparam_string("servern", Opt_servern),
 171         fsparam_string("ver", Opt_ver),
 172         fsparam_string("vers", Opt_vers),
 173         fsparam_string("sec", Opt_sec),
 174         fsparam_string("cache", Opt_cache),
 175
 176         /* Arguments that should be ignored */
 177         fsparam_flag("guest", Opt_ignore),
 178         fsparam_flag("noatime", Opt_ignore),
 179         fsparam_flag("relatime", Opt_ignore),
 180         fsparam_flag("_netdev", Opt_ignore),
 181         fsparam_flag_no("suid", Opt_ignore),
 182         fsparam_flag_no("exec", Opt_ignore),
 183         fsparam_flag_no("dev", Opt_ignore),
 184         fsparam_flag_no("mand", Opt_ignore),
 185         fsparam_flag_no("auto", Opt_ignore),
 186         fsparam_string("cred", Opt_ignore),
 187         fsparam_string("credentials", Opt_ignore),
 188         /*
 189          * UNC and prefixpath is now extracted from Opt_source
 190          * in the new mount API so we can just ignore them going forward.
 191          */
 192         fsparam_string("unc", Opt_ignore),
 193         fsparam_string("prefixpath", Opt_ignore),
 194         {}
 195 };
 196
 197 static int
 198 cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
 199 {
 200
 201         substring_t args[MAX_OPT_ARGS];
 202
 203         /*
 204          * With mount options, the last one should win. Reset any existing
 205          * settings back to default.
 206          */
 207         ctx->sectype = Unspecified;
 208         ctx->sign = false;
 209
 210         switch (match_token(value, cifs_secflavor_tokens, args)) {
 211         case Opt_sec_krb5p:
 212                 cifs_errorf(fc, "sec=krb5p is not supported!\n");
 213                 return 1;
 214         case Opt_sec_krb5i:
 215                 ctx->sign = true;
 216                 fallthrough;
 217         case Opt_sec_krb5:
 218                 ctx->sectype = Kerberos;
 219                 break;
 220         case Opt_sec_ntlmsspi:
 221                 ctx->sign = true;
 222                 fallthrough;
 223         case Opt_sec_ntlmssp:
 224                 ctx->sectype = RawNTLMSSP;
 225                 break;
 226         case Opt_sec_ntlmv2i:
 227                 ctx->sign = true;
 228                 fallthrough;
 229         case Opt_sec_ntlmv2:
 230                 ctx->sectype = NTLMv2;
 231                 break;
 232         case Opt_sec_none:
 233                 ctx->nullauth = 1;
 234                 break;
 235         default:
 236                 cifs_errorf(fc, "bad security option: %s\n", value);
 237                 return 1;
 238         }
 239
 240         return 0;
 241 }
 242
 243 static const match_table_t cifs_cacheflavor_tokens = {
 244         { Opt_cache_loose, "loose" },
 245         { Opt_cache_strict, "strict" },
 246         { Opt_cache_none, "none" },
 247         { Opt_cache_ro, "ro" },
 248         { Opt_cache_rw, "singleclient" },
 249         { Opt_cache_err, NULL }
 250 };
 251
 252 static int
 253 cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
 254 {
 255         substring_t args[MAX_OPT_ARGS];
 256
 257         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
 258         case Opt_cache_loose:
 259                 ctx->direct_io = false;
 260                 ctx->strict_io = false;
 261                 ctx->cache_ro = false;
 262                 ctx->cache_rw = false;
 263                 break;
 264         case Opt_cache_strict:
 265                 ctx->direct_io = false;
 266                 ctx->strict_io = true;
 267                 ctx->cache_ro = false;
 268                 ctx->cache_rw = false;
 269                 break;
 270         case Opt_cache_none:
 271                 ctx->direct_io = true;
 272                 ctx->strict_io = false;
 273                 ctx->cache_ro = false;
 274                 ctx->cache_rw = false;
 275                 break;
 276         case Opt_cache_ro:
 277                 ctx->direct_io = false;
 278                 ctx->strict_io = false;
 279                 ctx->cache_ro = true;
 280                 ctx->cache_rw = false;
 281                 break;
 282         case Opt_cache_rw:
 283                 ctx->direct_io = false;
 284                 ctx->strict_io = false;
 285                 ctx->cache_ro = false;
 286                 ctx->cache_rw = true;
 287                 break;
 288         default:
 289                 cifs_errorf(fc, "bad cache= option: %s\n", value);
 290                 return 1;
 291         }
 292         return 0;
 293 }
 294
 295 #define DUP_CTX_STR(field)                                              \
 296 do {                                                                    \
 297         if (ctx->field) {                                               \
 298                 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC);       \
 299                 if (new_ctx->field == NULL) {                           \
 300                         smb3_cleanup_fs_context_contents(new_ctx);      \
 301                         return -ENOMEM;                                 \
 302                 }                                                       \
 303         }                                                               \
 304 } while (0)
 305
 306 int
 307 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
 308 {
 309         memcpy(new_ctx, ctx, sizeof(*ctx));
 310         new_ctx->prepath = NULL;
 311         new_ctx->mount_options = NULL;
 312         new_ctx->nodename = NULL;
 313         new_ctx->username = NULL;
 314         new_ctx->password = NULL;
 315         new_ctx->server_hostname = NULL;
 316         new_ctx->domainname = NULL;
 317         new_ctx->UNC = NULL;
 318         new_ctx->source = NULL;
 319         new_ctx->iocharset = NULL;
 320         /*
 321          * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
 322          */
 323         DUP_CTX_STR(prepath);
 324         DUP_CTX_STR(mount_options);
 325         DUP_CTX_STR(username);
 326         DUP_CTX_STR(password);
 327         DUP_CTX_STR(server_hostname);
 328         DUP_CTX_STR(UNC);
 329         DUP_CTX_STR(source);
 330         DUP_CTX_STR(domainname);
 331         DUP_CTX_STR(nodename);
 332         DUP_CTX_STR(iocharset);
 333
 334         return 0;
 335 }
 336
 337 static int
 338 cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_context *ctx, bool is_smb3)
 339 {
 340         substring_t args[MAX_OPT_ARGS];
 341
 342         switch (match_token(value, cifs_smb_version_tokens, args)) {
 343 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 344         case Smb_1:
 345                 if (disable_legacy_dialects) {
 346                         cifs_errorf(fc, "mount with legacy dialect disabled\n");
 347                         return 1;
 348                 }
 349                 if (is_smb3) {
 350                         cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
 351                         return 1;
 352                 }
 353                 cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
 354                 ctx->ops = &smb1_operations;
 355                 ctx->vals = &smb1_values;
 356                 break;
 357         case Smb_20:
 358                 if (disable_legacy_dialects) {
 359                         cifs_errorf(fc, "mount with legacy dialect disabled\n");
 360                         return 1;
 361                 }
 362                 if (is_smb3) {
 363                         cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
 364                         return 1;
 365                 }
 366                 ctx->ops = &smb20_operations;
 367                 ctx->vals = &smb20_values;
 368                 break;
 369 #else
 370         case Smb_1:
 371                 cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
 372                 return 1;
 373         case Smb_20:
 374                 cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
 375                 return 1;
 376 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
 377         case Smb_21:
 378                 ctx->ops = &smb21_operations;
 379                 ctx->vals = &smb21_values;
 380                 break;
 381         case Smb_30:
 382                 ctx->ops = &smb30_operations;
 383                 ctx->vals = &smb30_values;
 384                 break;
 385         case Smb_302:
 386                 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
 387                 ctx->vals = &smb302_values;
 388                 break;
 389         case Smb_311:
 390                 ctx->ops = &smb311_operations;
 391                 ctx->vals = &smb311_values;
 392                 break;
 393         case Smb_3any:
 394                 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
 395                 ctx->vals = &smb3any_values;
 396                 break;
 397         case Smb_default:
 398                 ctx->ops = &smb30_operations;
 399                 ctx->vals = &smbdefault_values;
 400                 break;
 401         default:
 402                 cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
 403                 return 1;
 404         }
 405         return 0;
 406 }
 407
 408 int smb3_parse_opt(const char *options, const char *key, char **val)
 409 {
 410         int rc = -ENOENT;
 411         char *opts, *orig, *p;
 412
 413         orig = opts = kstrdup(options, GFP_KERNEL);
 414         if (!opts)
 415                 return -ENOMEM;
 416
 417         while ((p = strsep(&opts, ","))) {
 418                 char *nval;
 419
 420                 if (!*p)
 421                         continue;
 422                 if (strncasecmp(p, key, strlen(key)))
 423                         continue;
 424                 nval = strchr(p, '=');
 425                 if (nval) {
 426                         if (nval == p)
 427                                 continue;
 428                         *nval++ = 0;
 429                         *val = kstrdup(nval, GFP_KERNEL);
 430                         rc = !*val ? -ENOMEM : 0;
 431                         goto out;
 432                 }
 433         }
 434 out:
 435         kfree(orig);
 436         return rc;
 437 }
 438
 439 /*
 440  * Remove duplicate path delimiters. Windows is supposed to do that
 441  * but there are some bugs that prevent rename from working if there are
 442  * multiple delimiters.
 443  *
 444  * Returns a sanitized duplicate of @path. @gfp indicates the GFP_* flags
 445  * for kstrdup.
 446  * The caller is responsible for freeing the original.
 447  */
 448 #define IS_DELIM(c) ((c) == '/' || (c) == '\\')
 449 char *cifs_sanitize_prepath(char *prepath, gfp_t gfp)
 450 {
 451         char *cursor1 = prepath, *cursor2 = prepath;
 452
 453         /* skip all prepended delimiters */
 454         while (IS_DELIM(*cursor1))
 455                 cursor1++;
 456
 457         /* copy the first letter */
 458         *cursor2 = *cursor1;
 459
 460         /* copy the remainder... */
 461         while (*(cursor1++)) {
 462                 /* ... skipping all duplicated delimiters */
 463                 if (IS_DELIM(*cursor1) && IS_DELIM(*cursor2))
 464                         continue;
 465                 *(++cursor2) = *cursor1;
 466         }
 467
 468         /* if the last character is a delimiter, skip it */
 469         if (IS_DELIM(*(cursor2 - 1)))
 470                 cursor2--;
 471
 472         *(cursor2) = '\0';
 473         return kstrdup(prepath, gfp);
 474 }
 475
 476 /*
 477  * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
 478  * fields with the result. Returns 0 on success and an error otherwise
 479  * (e.g. ENOMEM or EINVAL)
 480  */
 481 int
 482 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
 483 {
 484         char *pos;
 485         const char *delims = "/\\";
 486         size_t len;
 487
 488         if (unlikely(!devname || !*devname)) {
 489                 cifs_dbg(VFS, "Device name not specified\n");
 490                 return -EINVAL;
 491         }
 492
 493         /* make sure we have a valid UNC double delimiter prefix */
 494         len = strspn(devname, delims);
 495         if (len != 2)
 496                 return -EINVAL;
 497
 498         /* find delimiter between host and sharename */
 499         pos = strpbrk(devname + 2, delims);
 500         if (!pos)
 501                 return -EINVAL;
 502
 503         /* record the server hostname */
 504         kfree(ctx->server_hostname);
 505         ctx->server_hostname = kstrndup(devname + 2, pos - devname - 2, GFP_KERNEL);
 506         if (!ctx->server_hostname)
 507                 return -ENOMEM;
 508
 509         /* skip past delimiter */
 510         ++pos;
 511
 512         /* now go until next delimiter or end of string */
 513         len = strcspn(pos, delims);
 514
 515         /* move "pos" up to delimiter or NULL */
 516         pos += len;
 517         kfree(ctx->UNC);
 518         ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
 519         if (!ctx->UNC)
 520                 return -ENOMEM;
 521
 522         convert_delimiter(ctx->UNC, '\\');
 523
 524         /* skip any delimiter */
 525         if (*pos == '/' || *pos == '\\')
 526                 pos++;
 527
 528         kfree(ctx->prepath);
 529         ctx->prepath = NULL;
 530
 531         /* If pos is NULL then no prepath */
 532         if (!*pos)
 533                 return 0;
 534
 535         ctx->prepath = cifs_sanitize_prepath(pos, GFP_KERNEL);
 536         if (!ctx->prepath)
 537                 return -ENOMEM;
 538
 539         return 0;
 540 }
 541
 542 static void smb3_fs_context_free(struct fs_context *fc);
 543 static int smb3_fs_context_parse_param(struct fs_context *fc,
 544                                        struct fs_parameter *param);
 545 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 546                                             void *data);
 547 static int smb3_get_tree(struct fs_context *fc);
 548 static int smb3_reconfigure(struct fs_context *fc);
 549
 550 static const struct fs_context_operations smb3_fs_context_ops = {
 551         .free                   = smb3_fs_context_free,
 552         .parse_param            = smb3_fs_context_parse_param,
 553         .parse_monolithic       = smb3_fs_context_parse_monolithic,
 554         .get_tree               = smb3_get_tree,
 555         .reconfigure            = smb3_reconfigure,
 556 };
 557
 558 /*
 559  * Parse a monolithic block of data from sys_mount().
 560  * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
 561  * @ctx: The superblock configuration to fill in.
 562  * @data: The data to parse
 563  *
 564  * Parse a blob of data that's in key[=val][,key[=val]]* form.  This can be
 565  * called from the ->monolithic_mount_data() fs_context operation.
 566  *
 567  * Returns 0 on success or the error returned by the ->parse_option() fs_context
 568  * operation on failure.
 569  */
 570 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 571                                            void *data)
 572 {
 573         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 574         char *options = data, *key;
 575         int ret = 0;
 576
 577         if (!options)
 578                 return 0;
 579
 580         ctx->mount_options = kstrdup(data, GFP_KERNEL);
 581         if (ctx->mount_options == NULL)
 582                 return -ENOMEM;
 583
 584         ret = security_sb_eat_lsm_opts(options, &fc->security);
 585         if (ret)
 586                 return ret;
 587
 588         /* BB Need to add support for sep= here TBD */
 589         while ((key = strsep(&options, ",")) != NULL) {
 590                 size_t len;
 591                 char *value;
 592
 593                 if (*key == 0)
 594                         break;
 595
 596                 /* Check if following character is the deliminator If yes,
 597                  * we have encountered a double deliminator reset the NULL
 598                  * character to the deliminator
 599                  */
 600                 while (options && options[0] == ',') {
 601                         len = strlen(key);
 602                         strcpy(key + len, options);
 603                         options = strchr(options, ',');
 604                         if (options)
 605                                 *options++ = 0;
 606                 }
 607
 608
 609                 len = 0;
 610                 value = strchr(key, '=');
 611                 if (value) {
 612                         if (value == key)
 613                                 continue;
 614                         *value++ = 0;
 615                         len = strlen(value);
 616                 }
 617
 618                 ret = vfs_parse_fs_string(fc, key, value, len);
 619                 if (ret < 0)
 620                         break;
 621         }
 622
 623         return ret;
 624 }
 625
 626 /*
 627  * Validate the preparsed information in the config.
 628  */
 629 static int smb3_fs_context_validate(struct fs_context *fc)
 630 {
 631         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 632
 633         if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
 634                 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
 635                 return -EOPNOTSUPP;
 636         }
 637
 638 #ifndef CONFIG_KEYS
 639         /* Muliuser mounts require CONFIG_KEYS support */
 640         if (ctx->multiuser) {
 641                 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
 642                 return -1;
 643         }
 644 #endif
 645
 646         if (ctx->got_version == false)
 647                 pr_warn_once("No dialect specified on mount. Default has changed to a more secure dialect, SMB2.1 or later (e.g. SMB3.1.1), from CIFS (SMB1). To use the less secure SMB1 dialect to access old servers which do not support SMB3.1.1 (or even SMB3 or SMB2.1) specify vers=1.0 on mount.\n");
 648
 649
 650         if (!ctx->UNC) {
 651                 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
 652                 return -1;
 653         }
 654
 655         /* make sure UNC has a share name */
 656         if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
 657                 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
 658                 return -ENOENT;
 659         }
 660
 661         if (!ctx->got_ip) {
 662                 int len;
 663                 const char *slash;
 664
 665                 /* No ip= option specified? Try to get it from UNC */
 666                 /* Use the address part of the UNC. */
 667                 slash = strchr(&ctx->UNC[2], '\\');
 668                 len = slash - &ctx->UNC[2];
 669                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
 670                                           &ctx->UNC[2], len)) {
 671                         pr_err("Unable to determine destination address\n");
 672                         return -EHOSTUNREACH;
 673                 }
 674         }
 675
 676         /* set the port that we got earlier */
 677         cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
 678
 679         if (ctx->override_uid && !ctx->uid_specified) {
 680                 ctx->override_uid = 0;
 681                 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
 682         }
 683
 684         if (ctx->override_gid && !ctx->gid_specified) {
 685                 ctx->override_gid = 0;
 686                 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
 687         }
 688
 689         return 0;
 690 }
 691
 692 static int smb3_get_tree_common(struct fs_context *fc)
 693 {
 694         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 695         struct dentry *root;
 696         int rc = 0;
 697
 698         root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
 699         if (IS_ERR(root))
 700                 return PTR_ERR(root);
 701
 702         fc->root = root;
 703
 704         return rc;
 705 }
 706
 707 /*
 708  * Create an SMB3 superblock from the parameters passed.
 709  */
 710 static int smb3_get_tree(struct fs_context *fc)
 711 {
 712         int err = smb3_fs_context_validate(fc);
 713         int ret;
 714
 715         if (err)
 716                 return err;
 717         mutex_lock(&cifs_mount_mutex);
 718         ret = smb3_get_tree_common(fc);
 719         mutex_unlock(&cifs_mount_mutex);
 720         return ret;
 721 }
 722
 723 static void smb3_fs_context_free(struct fs_context *fc)
 724 {
 725         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 726
 727         smb3_cleanup_fs_context(ctx);
 728 }
 729
 730 /*
 731  * Compare the old and new proposed context during reconfigure
 732  * and check if the changes are compatible.
 733  */
 734 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
 735                                        struct smb3_fs_context *new_ctx,
 736                                        struct smb3_fs_context *old_ctx)
 737 {
 738         if (new_ctx->posix_paths != old_ctx->posix_paths) {
 739                 cifs_errorf(fc, "can not change posixpaths during remount\n");
 740                 return -EINVAL;
 741         }
 742         if (new_ctx->sectype != old_ctx->sectype) {
 743                 cifs_errorf(fc, "can not change sec during remount\n");
 744                 return -EINVAL;
 745         }
 746         if (new_ctx->multiuser != old_ctx->multiuser) {
 747                 cifs_errorf(fc, "can not change multiuser during remount\n");
 748                 return -EINVAL;
 749         }
 750         if (new_ctx->UNC &&
 751             (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
 752                 cifs_errorf(fc, "can not change UNC during remount\n");
 753                 return -EINVAL;
 754         }
 755         if (new_ctx->username &&
 756             (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
 757                 cifs_errorf(fc, "can not change username during remount\n");
 758                 return -EINVAL;
 759         }
 760         if (new_ctx->password &&
 761             (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
 762                 cifs_errorf(fc, "can not change password during remount\n");
 763                 return -EINVAL;
 764         }
 765         if (new_ctx->domainname &&
 766             (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
 767                 cifs_errorf(fc, "can not change domainname during remount\n");
 768                 return -EINVAL;
 769         }
 770         if (strcmp(new_ctx->workstation_name, old_ctx->workstation_name)) {
 771                 cifs_errorf(fc, "can not change workstation_name during remount\n");
 772                 return -EINVAL;
 773         }
 774         if (new_ctx->nodename &&
 775             (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
 776                 cifs_errorf(fc, "can not change nodename during remount\n");
 777                 return -EINVAL;
 778         }
 779         if (new_ctx->iocharset &&
 780             (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
 781                 cifs_errorf(fc, "can not change iocharset during remount\n");
 782                 return -EINVAL;
 783         }
 784
 785         return 0;
 786 }
 787
 788 #define STEAL_STRING(cifs_sb, ctx, field)                               \
 789 do {                                                                    \
 790         kfree(ctx->field);                                              \
 791         ctx->field = cifs_sb->ctx->field;                               \
 792         cifs_sb->ctx->field = NULL;                                     \
 793 } while (0)
 794
 795 #define STEAL_STRING_SENSITIVE(cifs_sb, ctx, field)                     \
 796 do {                                                                    \
 797         kfree_sensitive(ctx->field);                                    \
 798         ctx->field = cifs_sb->ctx->field;                               \
 799         cifs_sb->ctx->field = NULL;                                     \
 800 } while (0)
 801
 802 static int smb3_reconfigure(struct fs_context *fc)
 803 {
 804         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 805         struct dentry *root = fc->root;
 806         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 807         int rc;
 808
 809         rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx);
 810         if (rc)
 811                 return rc;
 812
 813         /*
 814          * We can not change UNC/username/password/domainname/
 815          * workstation_name/nodename/iocharset
 816          * during reconnect so ignore what we have in the new context and
 817          * just use what we already have in cifs_sb->ctx.
 818          */
 819         STEAL_STRING(cifs_sb, ctx, UNC);
 820         STEAL_STRING(cifs_sb, ctx, source);
 821         STEAL_STRING(cifs_sb, ctx, username);
 822         STEAL_STRING_SENSITIVE(cifs_sb, ctx, password);
 823         STEAL_STRING(cifs_sb, ctx, domainname);
 824         STEAL_STRING(cifs_sb, ctx, nodename);
 825         STEAL_STRING(cifs_sb, ctx, iocharset);
 826
 827         /* if rsize or wsize not passed in on remount, use previous values */
 828         if (ctx->rsize == 0)
 829                 ctx->rsize = cifs_sb->ctx->rsize;
 830         if (ctx->wsize == 0)
 831                 ctx->wsize = cifs_sb->ctx->wsize;
 832
 833
 834         smb3_cleanup_fs_context_contents(cifs_sb->ctx);
 835         rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
 836         smb3_update_mnt_flags(cifs_sb);
 837 #ifdef CONFIG_CIFS_DFS_UPCALL
 838         if (!rc)
 839                 rc = dfs_cache_remount_fs(cifs_sb);
 840 #endif
 841
 842         return rc;
 843 }
 844
 845 static int smb3_fs_context_parse_param(struct fs_context *fc,
 846                                       struct fs_parameter *param)
 847 {
 848         struct fs_parse_result result;
 849         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 850         int i, opt;
 851         bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
 852         bool skip_parsing = false;
 853         kuid_t uid;
 854         kgid_t gid;
 855
 856         cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
 857
 858         /*
 859          * fs_parse can not handle string options with an empty value so
 860          * we will need special handling of them.
 861          */
 862         if (param->type == fs_value_is_string && param->string[0] == 0) {
 863                 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
 864                         skip_parsing = true;
 865                         opt = Opt_pass;
 866                 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
 867                         skip_parsing = true;
 868                         opt = Opt_user;
 869                 }
 870         }
 871
 872         if (!skip_parsing) {
 873                 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
 874                 if (opt < 0)
 875                         return ctx->sloppy ? 1 : opt;
 876         }
 877
 878         switch (opt) {
 879         case Opt_compress:
 880                 ctx->compression = UNKNOWN_TYPE;
 881                 cifs_dbg(VFS,
 882                         "SMB3 compression support is experimental\n");
 883                 break;
 884         case Opt_nodfs:
 885                 ctx->nodfs = 1;
 886                 break;
 887         case Opt_hard:
 888                 if (result.negated)
 889                         ctx->retry = 0;
 890                 else
 891                         ctx->retry = 1;
 892                 break;
 893         case Opt_soft:
 894                 if (result.negated)
 895                         ctx->retry = 1;
 896                 else
 897                         ctx->retry = 0;
 898                 break;
 899         case Opt_mapposix:
 900                 if (result.negated)
 901                         ctx->remap = false;
 902                 else {
 903                         ctx->remap = true;
 904                         ctx->sfu_remap = false; /* disable SFU mapping */
 905                 }
 906                 break;
 907         case Opt_user_xattr:
 908                 if (result.negated)
 909                         ctx->no_xattr = 1;
 910                 else
 911                         ctx->no_xattr = 0;
 912                 break;
 913         case Opt_forceuid:
 914                 if (result.negated)
 915                         ctx->override_uid = 0;
 916                 else
 917                         ctx->override_uid = 1;
 918                 break;
 919         case Opt_forcegid:
 920                 if (result.negated)
 921                         ctx->override_gid = 0;
 922                 else
 923                         ctx->override_gid = 1;
 924                 break;
 925         case Opt_perm:
 926                 if (result.negated)
 927                         ctx->noperm = 1;
 928                 else
 929                         ctx->noperm = 0;
 930                 break;
 931         case Opt_dynperm:
 932                 if (result.negated)
 933                         ctx->dynperm = 0;
 934                 else
 935                         ctx->dynperm = 1;
 936                 break;
 937         case Opt_sfu:
 938                 if (result.negated)
 939                         ctx->sfu_emul = 0;
 940                 else
 941                         ctx->sfu_emul = 1;
 942                 break;
 943         case Opt_noblocksend:
 944                 ctx->noblocksnd = 1;
 945                 break;
 946         case Opt_noautotune:
 947                 ctx->noautotune = 1;
 948                 break;
 949         case Opt_nolease:
 950                 ctx->no_lease = 1;
 951                 break;
 952         case Opt_nosparse:
 953                 ctx->no_sparse = 1;
 954                 break;
 955         case Opt_nodelete:
 956                 ctx->nodelete = 1;
 957                 break;
 958         case Opt_multichannel:
 959                 if (result.negated) {
 960                         ctx->multichannel = false;
 961                         ctx->max_channels = 1;
 962                 } else {
 963                         ctx->multichannel = true;
 964                         /* if number of channels not specified, default to 2 */
 965                         if (ctx->max_channels < 2)
 966                                 ctx->max_channels = 2;
 967                 }
 968                 break;
 969         case Opt_uid:
 970                 uid = make_kuid(current_user_ns(), result.uint_32);
 971                 if (!uid_valid(uid))
 972                         goto cifs_parse_mount_err;
 973                 ctx->linux_uid = uid;
 974                 ctx->uid_specified = true;
 975                 break;
 976         case Opt_cruid:
 977                 uid = make_kuid(current_user_ns(), result.uint_32);
 978                 if (!uid_valid(uid))
 979                         goto cifs_parse_mount_err;
 980                 ctx->cred_uid = uid;
 981                 ctx->cruid_specified = true;
 982                 break;
 983         case Opt_backupuid:
 984                 uid = make_kuid(current_user_ns(), result.uint_32);
 985                 if (!uid_valid(uid))
 986                         goto cifs_parse_mount_err;
 987                 ctx->backupuid = uid;
 988                 ctx->backupuid_specified = true;
 989                 break;
 990         case Opt_backupgid:
 991                 gid = make_kgid(current_user_ns(), result.uint_32);
 992                 if (!gid_valid(gid))
 993                         goto cifs_parse_mount_err;
 994                 ctx->backupgid = gid;
 995                 ctx->backupgid_specified = true;
 996                 break;
 997         case Opt_gid:
 998                 gid = make_kgid(current_user_ns(), result.uint_32);
 999                 if (!gid_valid(gid))
1000                         goto cifs_parse_mount_err;
1001                 ctx->linux_gid = gid;
1002                 ctx->gid_specified = true;
1003                 break;
1004         case Opt_port:
1005                 ctx->port = result.uint_32;
1006                 break;
1007         case Opt_file_mode:
1008                 ctx->file_mode = result.uint_32;
1009                 break;
1010         case Opt_dirmode:
1011                 ctx->dir_mode = result.uint_32;
1012                 break;
1013         case Opt_min_enc_offload:
1014                 ctx->min_offload = result.uint_32;
1015                 break;
1016         case Opt_blocksize:
1017                 /*
1018                  * inode blocksize realistically should never need to be
1019                  * less than 16K or greater than 16M and default is 1MB.
1020                  * Note that small inode block sizes (e.g. 64K) can lead
1021                  * to very poor performance of common tools like cp and scp
1022                  */
1023                 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
1024                    (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
1025                         cifs_errorf(fc, "%s: Invalid blocksize\n",
1026                                 __func__);
1027                         goto cifs_parse_mount_err;
1028                 }
1029                 ctx->bsize = result.uint_32;
1030                 ctx->got_bsize = true;
1031                 break;
1032         case Opt_rasize:
1033                 /*
1034                  * readahead size realistically should never need to be
1035                  * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
1036                  * (perhaps an exception should be considered in the
1037                  * for the case of a large number of channels
1038                  * when multichannel is negotiated) since that would lead
1039                  * to plenty of parallel I/O in flight to the server.
1040                  * Note that smaller read ahead sizes would
1041                  * hurt performance of common tools like cp and scp
1042                  * which often trigger sequential i/o with read ahead
1043                  */
1044                 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
1045                     (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
1046                         cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
1047                                 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
1048                         goto cifs_parse_mount_err;
1049                 }
1050                 ctx->rasize = result.uint_32;
1051                 break;
1052         case Opt_rsize:
1053                 ctx->rsize = result.uint_32;
1054                 ctx->got_rsize = true;
1055                 break;
1056         case Opt_wsize:
1057                 ctx->wsize = result.uint_32;
1058                 ctx->got_wsize = true;
1059                 break;
1060         case Opt_acregmax:
1061                 ctx->acregmax = HZ * result.uint_32;
1062                 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1063                         cifs_errorf(fc, "acregmax too large\n");
1064                         goto cifs_parse_mount_err;
1065                 }
1066                 break;
1067         case Opt_acdirmax:
1068                 ctx->acdirmax = HZ * result.uint_32;
1069                 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1070                         cifs_errorf(fc, "acdirmax too large\n");
1071                         goto cifs_parse_mount_err;
1072                 }
1073                 break;
1074         case Opt_actimeo:
1075                 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1076                         cifs_errorf(fc, "timeout too large\n");
1077                         goto cifs_parse_mount_err;
1078                 }
1079                 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1080                     (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1081                         cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1082                         break;
1083                 }
1084                 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1085                 break;
1086         case Opt_closetimeo:
1087                 ctx->closetimeo = HZ * result.uint_32;
1088                 if (ctx->closetimeo > SMB3_MAX_DCLOSETIMEO) {
1089                         cifs_errorf(fc, "closetimeo too large\n");
1090                         goto cifs_parse_mount_err;
1091                 }
1092                 break;
1093         case Opt_echo_interval:
1094                 ctx->echo_interval = result.uint_32;
1095                 break;
1096         case Opt_snapshot:
1097                 ctx->snapshot_time = result.uint_64;
1098                 break;
1099         case Opt_max_credits:
1100                 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1101                         cifs_errorf(fc, "%s: Invalid max_credits value\n",
1102                                  __func__);
1103                         goto cifs_parse_mount_err;
1104                 }
1105                 ctx->max_credits = result.uint_32;
1106                 break;
1107         case Opt_max_channels:
1108                 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1109                         cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1110                                  __func__, CIFS_MAX_CHANNELS);
1111                         goto cifs_parse_mount_err;
1112                 }
1113                 ctx->max_channels = result.uint_32;
1114                 /* If more than one channel requested ... they want multichan */
1115                 if (result.uint_32 > 1)
1116                         ctx->multichannel = true;
1117                 break;
1118         case Opt_handletimeout:
1119                 ctx->handle_timeout = result.uint_32;
1120                 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1121                         cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1122                         goto cifs_parse_mount_err;
1123                 }
1124                 break;
1125         case Opt_source:
1126                 kfree(ctx->UNC);
1127                 ctx->UNC = NULL;
1128                 switch (smb3_parse_devname(param->string, ctx)) {
1129                 case 0:
1130                         break;
1131                 case -ENOMEM:
1132                         cifs_errorf(fc, "Unable to allocate memory for devname\n");
1133                         goto cifs_parse_mount_err;
1134                 case -EINVAL:
1135                         cifs_errorf(fc, "Malformed UNC in devname\n");
1136                         goto cifs_parse_mount_err;
1137                 default:
1138                         cifs_errorf(fc, "Unknown error parsing devname\n");
1139                         goto cifs_parse_mount_err;
1140                 }
1141                 ctx->source = kstrdup(param->string, GFP_KERNEL);
1142                 if (ctx->source == NULL) {
1143                         cifs_errorf(fc, "OOM when copying UNC string\n");
1144                         goto cifs_parse_mount_err;
1145                 }
1146                 fc->source = kstrdup(param->string, GFP_KERNEL);
1147                 if (fc->source == NULL) {
1148                         cifs_errorf(fc, "OOM when copying UNC string\n");
1149                         goto cifs_parse_mount_err;
1150                 }
1151                 break;
1152         case Opt_user:
1153                 kfree(ctx->username);
1154                 ctx->username = NULL;
1155                 if (strlen(param->string) == 0) {
1156                         /* null user, ie. anonymous authentication */
1157                         ctx->nullauth = 1;
1158                         break;
1159                 }
1160
1161                 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1162                     CIFS_MAX_USERNAME_LEN) {
1163                         pr_warn("username too long\n");
1164                         goto cifs_parse_mount_err;
1165                 }
1166                 ctx->username = kstrdup(param->string, GFP_KERNEL);
1167                 if (ctx->username == NULL) {
1168                         cifs_errorf(fc, "OOM when copying username string\n");
1169                         goto cifs_parse_mount_err;
1170                 }
1171                 break;
1172         case Opt_pass:
1173                 kfree_sensitive(ctx->password);
1174                 ctx->password = NULL;
1175                 if (strlen(param->string) == 0)
1176                         break;
1177
1178                 ctx->password = kstrdup(param->string, GFP_KERNEL);
1179                 if (ctx->password == NULL) {
1180                         cifs_errorf(fc, "OOM when copying password string\n");
1181                         goto cifs_parse_mount_err;
1182                 }
1183                 break;
1184         case Opt_ip:
1185                 if (strlen(param->string) == 0) {
1186                         ctx->got_ip = false;
1187                         break;
1188                 }
1189                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1190                                           param->string,
1191                                           strlen(param->string))) {
1192                         pr_err("bad ip= option (%s)\n", param->string);
1193                         goto cifs_parse_mount_err;
1194                 }
1195                 ctx->got_ip = true;
1196                 break;
1197         case Opt_domain:
1198                 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1199                                 == CIFS_MAX_DOMAINNAME_LEN) {
1200                         pr_warn("domain name too long\n");
1201                         goto cifs_parse_mount_err;
1202                 }
1203
1204                 kfree(ctx->domainname);
1205                 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1206                 if (ctx->domainname == NULL) {
1207                         cifs_errorf(fc, "OOM when copying domainname string\n");
1208                         goto cifs_parse_mount_err;
1209                 }
1210                 cifs_dbg(FYI, "Domain name set\n");
1211                 break;
1212         case Opt_srcaddr:
1213                 if (!cifs_convert_address(
1214                                 (struct sockaddr *)&ctx->srcaddr,
1215                                 param->string, strlen(param->string))) {
1216                         pr_warn("Could not parse srcaddr: %s\n",
1217                                 param->string);
1218                         goto cifs_parse_mount_err;
1219                 }
1220                 break;
1221         case Opt_iocharset:
1222                 if (strnlen(param->string, 1024) >= 65) {
1223                         pr_warn("iocharset name too long\n");
1224                         goto cifs_parse_mount_err;
1225                 }
1226
1227                 if (strncasecmp(param->string, "default", 7) != 0) {
1228                         kfree(ctx->iocharset);
1229                         ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1230                         if (ctx->iocharset == NULL) {
1231                                 cifs_errorf(fc, "OOM when copying iocharset string\n");
1232                                 goto cifs_parse_mount_err;
1233                         }
1234                 }
1235                 /* if iocharset not set then load_nls_default
1236                  * is used by caller
1237                  */
1238                 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1239                 break;
1240         case Opt_netbiosname:
1241                 memset(ctx->source_rfc1001_name, 0x20,
1242                         RFC1001_NAME_LEN);
1243                 /*
1244                  * FIXME: are there cases in which a comma can
1245                  * be valid in workstation netbios name (and
1246                  * need special handling)?
1247                  */
1248                 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1249                         /* don't ucase netbiosname for user */
1250                         if (param->string[i] == 0)
1251                                 break;
1252                         ctx->source_rfc1001_name[i] = param->string[i];
1253                 }
1254                 /* The string has 16th byte zero still from
1255                  * set at top of the function
1256                  */
1257                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1258                         pr_warn("netbiosname longer than 15 truncated\n");
1259                 break;
1260         case Opt_servern:
1261                 /* last byte, type, is 0x20 for servr type */
1262                 memset(ctx->target_rfc1001_name, 0x20,
1263                         RFC1001_NAME_LEN_WITH_NULL);
1264                 /*
1265                  * BB are there cases in which a comma can be valid in this
1266                  * workstation netbios name (and need special handling)?
1267                  */
1268
1269                 /* user or mount helper must uppercase the netbios name */
1270                 for (i = 0; i < 15; i++) {
1271                         if (param->string[i] == 0)
1272                                 break;
1273                         ctx->target_rfc1001_name[i] = param->string[i];
1274                 }
1275
1276                 /* The string has 16th byte zero still from set at top of function */
1277                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1278                         pr_warn("server netbiosname longer than 15 truncated\n");
1279                 break;
1280         case Opt_ver:
1281                 /* version of mount userspace tools, not dialect */
1282                 /* If interface changes in mount.cifs bump to new ver */
1283                 if (strncasecmp(param->string, "1", 1) == 0) {
1284                         if (strlen(param->string) > 1) {
1285                                 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1286                                         param->string);
1287                                 goto cifs_parse_mount_err;
1288                         }
1289                         /* This is the default */
1290                         break;
1291                 }
1292                 /* For all other value, error */
1293                 pr_warn("Invalid mount helper version specified\n");
1294                 goto cifs_parse_mount_err;
1295         case Opt_vers:
1296                 /* protocol version (dialect) */
1297                 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1298                         goto cifs_parse_mount_err;
1299                 ctx->got_version = true;
1300                 break;
1301         case Opt_sec:
1302                 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1303                         goto cifs_parse_mount_err;
1304                 break;
1305         case Opt_cache:
1306                 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1307                         goto cifs_parse_mount_err;
1308                 break;
1309         case Opt_witness:
1310 #ifndef CONFIG_CIFS_SWN_UPCALL
1311                 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1312                         goto cifs_parse_mount_err;
1313 #endif
1314                 ctx->witness = true;
1315                 pr_warn_once("Witness protocol support is experimental\n");
1316                 break;
1317         case Opt_rootfs:
1318 #ifndef CONFIG_CIFS_ROOT
1319                 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1320                 goto cifs_parse_mount_err;
1321 #endif
1322                 ctx->rootfs = true;
1323                 break;
1324         case Opt_posixpaths:
1325                 if (result.negated)
1326                         ctx->posix_paths = 0;
1327                 else
1328                         ctx->posix_paths = 1;
1329                 break;
1330         case Opt_unix:
1331                 if (result.negated) {
1332                         if (ctx->linux_ext == 1)
1333                                 pr_warn_once("conflicting posix mount options specified\n");
1334                         ctx->linux_ext = 0;
1335                         ctx->no_linux_ext = 1;
1336                 } else {
1337                         if (ctx->no_linux_ext == 1)
1338                                 pr_warn_once("conflicting posix mount options specified\n");
1339                         ctx->linux_ext = 1;
1340                         ctx->no_linux_ext = 0;
1341                 }
1342                 break;
1343         case Opt_nocase:
1344                 ctx->nocase = 1;
1345                 break;
1346         case Opt_brl:
1347                 if (result.negated) {
1348                         /*
1349                          * turn off mandatory locking in mode
1350                          * if remote locking is turned off since the
1351                          * local vfs will do advisory
1352                          */
1353                         if (ctx->file_mode ==
1354                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1355                                 ctx->file_mode = S_IALLUGO;
1356                         ctx->nobrl =  1;
1357                 } else
1358                         ctx->nobrl =  0;
1359                 break;
1360         case Opt_handlecache:
1361                 if (result.negated)
1362                         ctx->nohandlecache = 1;
1363                 else
1364                         ctx->nohandlecache = 0;
1365                 break;
1366         case Opt_forcemandatorylock:
1367                 ctx->mand_lock = 1;
1368                 break;
1369         case Opt_setuids:
1370                 ctx->setuids = result.negated;
1371                 break;
1372         case Opt_intr:
1373                 ctx->intr = !result.negated;
1374                 break;
1375         case Opt_setuidfromacl:
1376                 ctx->setuidfromacl = 1;
1377                 break;
1378         case Opt_strictsync:
1379                 ctx->nostrictsync = result.negated;
1380                 break;
1381         case Opt_serverino:
1382                 ctx->server_ino = !result.negated;
1383                 break;
1384         case Opt_rwpidforward:
1385                 ctx->rwpidforward = 1;
1386                 break;
1387         case Opt_modesid:
1388                 ctx->mode_ace = 1;
1389                 break;
1390         case Opt_cifsacl:
1391                 ctx->cifs_acl = !result.negated;
1392                 break;
1393         case Opt_acl:
1394                 ctx->no_psx_acl = result.negated;
1395                 break;
1396         case Opt_locallease:
1397                 ctx->local_lease = 1;
1398                 break;
1399         case Opt_sign:
1400                 ctx->sign = true;
1401                 break;
1402         case Opt_ignore_signature:
1403                 ctx->sign = true;
1404                 ctx->ignore_signature = true;
1405                 break;
1406         case Opt_seal:
1407                 /* we do not do the following in secFlags because seal
1408                  * is a per tree connection (mount) not a per socket
1409                  * or per-smb connection option in the protocol
1410                  * vol->secFlg |= CIFSSEC_MUST_SEAL;
1411                  */
1412                 ctx->seal = 1;
1413                 break;
1414         case Opt_noac:
1415                 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1416                 break;
1417         case Opt_fsc:
1418 #ifndef CONFIG_CIFS_FSCACHE
1419                 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1420                 goto cifs_parse_mount_err;
1421 #endif
1422                 ctx->fsc = true;
1423                 break;
1424         case Opt_mfsymlinks:
1425                 ctx->mfsymlinks = true;
1426                 break;
1427         case Opt_multiuser:
1428                 ctx->multiuser = true;
1429                 break;
1430         case Opt_sloppy:
1431                 ctx->sloppy = true;
1432                 break;
1433         case Opt_nosharesock:
1434                 ctx->nosharesock = true;
1435                 break;
1436         case Opt_persistent:
1437                 if (result.negated) {
1438                         ctx->nopersistent = true;
1439                         if (ctx->persistent) {
1440                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1441                                 goto cifs_parse_mount_err;
1442                         }
1443                 } else {
1444                         ctx->persistent = true;
1445                         if ((ctx->nopersistent) || (ctx->resilient)) {
1446                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1447                                 goto cifs_parse_mount_err;
1448                         }
1449                 }
1450                 break;
1451         case Opt_resilient:
1452                 if (result.negated) {
1453                         ctx->resilient = false; /* already the default */
1454                 } else {
1455                         ctx->resilient = true;
1456                         if (ctx->persistent) {
1457                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1458                                 goto cifs_parse_mount_err;
1459                         }
1460                 }
1461                 break;
1462         case Opt_tcp_nodelay:
1463                 /* tcp nodelay should not usually be needed since we CORK/UNCORK the socket */
1464                 if (result.negated)
1465                         ctx->sockopt_tcp_nodelay = false;
1466                 else
1467                         ctx->sockopt_tcp_nodelay = true;
1468                 break;
1469         case Opt_domainauto:
1470                 ctx->domainauto = true;
1471                 break;
1472         case Opt_rdma:
1473                 ctx->rdma = true;
1474                 break;
1475         }
1476         /* case Opt_ignore: - is ignored as expected ... */
1477
1478         return 0;
1479
1480  cifs_parse_mount_err:
1481         kfree_sensitive(ctx->password);
1482         return -EINVAL;
1483 }
1484
1485 int smb3_init_fs_context(struct fs_context *fc)
1486 {
1487         struct smb3_fs_context *ctx;
1488         char *nodename = utsname()->nodename;
1489         int i;
1490
1491         ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1492         if (unlikely(!ctx))
1493                 return -ENOMEM;
1494
1495         strscpy(ctx->workstation_name, nodename, sizeof(ctx->workstation_name));
1496
1497         /*
1498          * does not have to be perfect mapping since field is
1499          * informational, only used for servers that do not support
1500          * port 445 and it can be overridden at mount time
1501          */
1502         memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1503         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1504                 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1505
1506         ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1507         /*
1508          * null target name indicates to use *SMBSERVR default called name
1509          *  if we end up sending RFC1001 session initialize
1510          */
1511         ctx->target_rfc1001_name[0] = 0;
1512         ctx->cred_uid = current_uid();
1513         ctx->linux_uid = current_uid();
1514         ctx->linux_gid = current_gid();
1515         /* By default 4MB read ahead size, 1MB block size */
1516         ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1517         ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1518
1519         /*
1520          * default to SFM style remapping of seven reserved characters
1521          * unless user overrides it or we negotiate CIFS POSIX where
1522          * it is unnecessary.  Can not simultaneously use more than one mapping
1523          * since then readdir could list files that open could not open
1524          */
1525         ctx->remap = true;
1526
1527         /* default to only allowing write access to owner of the mount */
1528         ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1529
1530         /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1531         /* default is always to request posix paths. */
1532         ctx->posix_paths = 1;
1533         /* default to using server inode numbers where available */
1534         ctx->server_ino = 1;
1535
1536         /* default is to use strict cifs caching semantics */
1537         ctx->strict_io = true;
1538
1539         ctx->acregmax = CIFS_DEF_ACTIMEO;
1540         ctx->acdirmax = CIFS_DEF_ACTIMEO;
1541         ctx->closetimeo = SMB3_DEF_DCLOSETIMEO;
1542
1543         /* Most clients set timeout to 0, allows server to use its default */
1544         ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1545
1546         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1547         ctx->ops = &smb30_operations;
1548         ctx->vals = &smbdefault_values;
1549
1550         ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1551
1552         /* default to no multichannel (single server connection) */
1553         ctx->multichannel = false;
1554         ctx->max_channels = 1;
1555
1556         ctx->backupuid_specified = false; /* no backup intent for a user */
1557         ctx->backupgid_specified = false; /* no backup intent for a group */
1558
1559 /*
1560  *      short int override_uid = -1;
1561  *      short int override_gid = -1;
1562  *      char *nodename = strdup(utsname()->nodename);
1563  *      struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1564  */
1565
1566         fc->fs_private = ctx;
1567         fc->ops = &smb3_fs_context_ops;
1568         return 0;
1569 }
1570
1571 void
1572 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1573 {
1574         if (ctx == NULL)
1575                 return;
1576
1577         /*
1578          * Make sure this stays in sync with smb3_fs_context_dup()
1579          */
1580         kfree(ctx->mount_options);
1581         ctx->mount_options = NULL;
1582         kfree(ctx->username);
1583         ctx->username = NULL;
1584         kfree_sensitive(ctx->password);
1585         ctx->password = NULL;
1586         kfree(ctx->server_hostname);
1587         ctx->server_hostname = NULL;
1588         kfree(ctx->UNC);
1589         ctx->UNC = NULL;
1590         kfree(ctx->source);
1591         ctx->source = NULL;
1592         kfree(ctx->domainname);
1593         ctx->domainname = NULL;
1594         kfree(ctx->nodename);
1595         ctx->nodename = NULL;
1596         kfree(ctx->iocharset);
1597         ctx->iocharset = NULL;
1598         kfree(ctx->prepath);
1599         ctx->prepath = NULL;
1600 }
1601
1602 void
1603 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1604 {
1605         if (!ctx)
1606                 return;
1607         smb3_cleanup_fs_context_contents(ctx);
1608         kfree(ctx);
1609 }
1610
1611 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1612 {
1613         struct smb3_fs_context *ctx = cifs_sb->ctx;
1614
1615         if (ctx->nodfs)
1616                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1617         else
1618                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1619
1620         if (ctx->noperm)
1621                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1622         else
1623                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1624
1625         if (ctx->setuids)
1626                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1627         else
1628                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1629
1630         if (ctx->setuidfromacl)
1631                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1632         else
1633                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1634
1635         if (ctx->server_ino)
1636                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1637         else
1638                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1639
1640         if (ctx->remap)
1641                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1642         else
1643                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1644
1645         if (ctx->sfu_remap)
1646                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1647         else
1648                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1649
1650         if (ctx->no_xattr)
1651                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1652         else
1653                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1654
1655         if (ctx->sfu_emul)
1656                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1657         else
1658                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1659
1660         if (ctx->nobrl)
1661                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1662         else
1663                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1664
1665         if (ctx->nohandlecache)
1666                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1667         else
1668                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1669
1670         if (ctx->nostrictsync)
1671                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1672         else
1673                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1674
1675         if (ctx->mand_lock)
1676                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1677         else
1678                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1679
1680         if (ctx->rwpidforward)
1681                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1682         else
1683                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1684
1685         if (ctx->mode_ace)
1686                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1687         else
1688                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1689
1690         if (ctx->cifs_acl)
1691                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1692         else
1693                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1694
1695         if (ctx->backupuid_specified)
1696                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1697         else
1698                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1699
1700         if (ctx->backupgid_specified)
1701                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1702         else
1703                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1704
1705         if (ctx->override_uid)
1706                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1707         else
1708                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1709
1710         if (ctx->override_gid)
1711                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1712         else
1713                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1714
1715         if (ctx->dynperm)
1716                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1717         else
1718                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1719
1720         if (ctx->fsc)
1721                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1722         else
1723                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1724
1725         if (ctx->multiuser)
1726                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1727                                             CIFS_MOUNT_NO_PERM);
1728         else
1729                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1730
1731
1732         if (ctx->strict_io)
1733                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1734         else
1735                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1736
1737         if (ctx->direct_io)
1738                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1739         else
1740                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1741
1742         if (ctx->mfsymlinks)
1743                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1744         else
1745                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1746         if (ctx->mfsymlinks) {
1747                 if (ctx->sfu_emul) {
1748                         /*
1749                          * Our SFU ("Services for Unix" emulation does not allow
1750                          * creating symlinks but does allow reading existing SFU
1751                          * symlinks (it does allow both creating and reading SFU
1752                          * style mknod and FIFOs though). When "mfsymlinks" and
1753                          * "sfu" are both enabled at the same time, it allows
1754                          * reading both types of symlinks, but will only create
1755                          * them with mfsymlinks format. This allows better
1756                          * Apple compatibility (probably better for Samba too)
1757                          * while still recognizing old Windows style symlinks.
1758                          */
1759                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1760                 }
1761         }
1762         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;
1763
1764         return;
1765 }