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. The caller is responsible for
 445  * cleaning up the original.
 446  */
 447 #define IS_DELIM(c) ((c) == '/' || (c) == '\\')
 448 static char *sanitize_path(char *path)
 449 {
 450         char *cursor1 = path, *cursor2 = path;
 451
 452         /* skip all prepended delimiters */
 453         while (IS_DELIM(*cursor1))
 454                 cursor1++;
 455
 456         /* copy the first letter */
 457         *cursor2 = *cursor1;
 458
 459         /* copy the remainder... */
 460         while (*(cursor1++)) {
 461                 /* ... skipping all duplicated delimiters */
 462                 if (IS_DELIM(*cursor1) && IS_DELIM(*cursor2))
 463                         continue;
 464                 *(++cursor2) = *cursor1;
 465         }
 466
 467         /* if the last character is a delimiter, skip it */
 468         if (IS_DELIM(*(cursor2 - 1)))
 469                 cursor2--;
 470
 471         *(cursor2) = '\0';
 472         return kstrdup(path, GFP_KERNEL);
 473 }
 474
 475 /*
 476  * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
 477  * fields with the result. Returns 0 on success and an error otherwise
 478  * (e.g. ENOMEM or EINVAL)
 479  */
 480 int
 481 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
 482 {
 483         char *pos;
 484         const char *delims = "/\\";
 485         size_t len;
 486
 487         if (unlikely(!devname || !*devname)) {
 488                 cifs_dbg(VFS, "Device name not specified\n");
 489                 return -EINVAL;
 490         }
 491
 492         /* make sure we have a valid UNC double delimiter prefix */
 493         len = strspn(devname, delims);
 494         if (len != 2)
 495                 return -EINVAL;
 496
 497         /* find delimiter between host and sharename */
 498         pos = strpbrk(devname + 2, delims);
 499         if (!pos)
 500                 return -EINVAL;
 501
 502         /* record the server hostname */
 503         kfree(ctx->server_hostname);
 504         ctx->server_hostname = kstrndup(devname + 2, pos - devname - 2, GFP_KERNEL);
 505         if (!ctx->server_hostname)
 506                 return -ENOMEM;
 507
 508         /* skip past delimiter */
 509         ++pos;
 510
 511         /* now go until next delimiter or end of string */
 512         len = strcspn(pos, delims);
 513
 514         /* move "pos" up to delimiter or NULL */
 515         pos += len;
 516         kfree(ctx->UNC);
 517         ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
 518         if (!ctx->UNC)
 519                 return -ENOMEM;
 520
 521         convert_delimiter(ctx->UNC, '\\');
 522
 523         /* skip any delimiter */
 524         if (*pos == '/' || *pos == '\\')
 525                 pos++;
 526
 527         kfree(ctx->prepath);
 528         ctx->prepath = NULL;
 529
 530         /* If pos is NULL then no prepath */
 531         if (!*pos)
 532                 return 0;
 533
 534         ctx->prepath = sanitize_path(pos);
 535         if (!ctx->prepath)
 536                 return -ENOMEM;
 537
 538         return 0;
 539 }
 540
 541 static void smb3_fs_context_free(struct fs_context *fc);
 542 static int smb3_fs_context_parse_param(struct fs_context *fc,
 543                                        struct fs_parameter *param);
 544 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 545                                             void *data);
 546 static int smb3_get_tree(struct fs_context *fc);
 547 static int smb3_reconfigure(struct fs_context *fc);
 548
 549 static const struct fs_context_operations smb3_fs_context_ops = {
 550         .free                   = smb3_fs_context_free,
 551         .parse_param            = smb3_fs_context_parse_param,
 552         .parse_monolithic       = smb3_fs_context_parse_monolithic,
 553         .get_tree               = smb3_get_tree,
 554         .reconfigure            = smb3_reconfigure,
 555 };
 556
 557 /*
 558  * Parse a monolithic block of data from sys_mount().
 559  * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
 560  * @ctx: The superblock configuration to fill in.
 561  * @data: The data to parse
 562  *
 563  * Parse a blob of data that's in key[=val][,key[=val]]* form.  This can be
 564  * called from the ->monolithic_mount_data() fs_context operation.
 565  *
 566  * Returns 0 on success or the error returned by the ->parse_option() fs_context
 567  * operation on failure.
 568  */
 569 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 570                                            void *data)
 571 {
 572         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 573         char *options = data, *key;
 574         int ret = 0;
 575
 576         if (!options)
 577                 return 0;
 578
 579         ctx->mount_options = kstrdup(data, GFP_KERNEL);
 580         if (ctx->mount_options == NULL)
 581                 return -ENOMEM;
 582
 583         ret = security_sb_eat_lsm_opts(options, &fc->security);
 584         if (ret)
 585                 return ret;
 586
 587         /* BB Need to add support for sep= here TBD */
 588         while ((key = strsep(&options, ",")) != NULL) {
 589                 size_t len;
 590                 char *value;
 591
 592                 if (*key == 0)
 593                         break;
 594
 595                 /* Check if following character is the deliminator If yes,
 596                  * we have encountered a double deliminator reset the NULL
 597                  * character to the deliminator
 598                  */
 599                 while (options && options[0] == ',') {
 600                         len = strlen(key);
 601                         strcpy(key + len, options);
 602                         options = strchr(options, ',');
 603                         if (options)
 604                                 *options++ = 0;
 605                 }
 606
 607
 608                 len = 0;
 609                 value = strchr(key, '=');
 610                 if (value) {
 611                         if (value == key)
 612                                 continue;
 613                         *value++ = 0;
 614                         len = strlen(value);
 615                 }
 616
 617                 ret = vfs_parse_fs_string(fc, key, value, len);
 618                 if (ret < 0)
 619                         break;
 620         }
 621
 622         return ret;
 623 }
 624
 625 /*
 626  * Validate the preparsed information in the config.
 627  */
 628 static int smb3_fs_context_validate(struct fs_context *fc)
 629 {
 630         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 631
 632         if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
 633                 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
 634                 return -EOPNOTSUPP;
 635         }
 636
 637 #ifndef CONFIG_KEYS
 638         /* Muliuser mounts require CONFIG_KEYS support */
 639         if (ctx->multiuser) {
 640                 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
 641                 return -1;
 642         }
 643 #endif
 644
 645         if (ctx->got_version == false)
 646                 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");
 647
 648
 649         if (!ctx->UNC) {
 650                 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
 651                 return -1;
 652         }
 653
 654         /* make sure UNC has a share name */
 655         if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
 656                 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
 657                 return -ENOENT;
 658         }
 659
 660         if (!ctx->got_ip) {
 661                 int len;
 662                 const char *slash;
 663
 664                 /* No ip= option specified? Try to get it from UNC */
 665                 /* Use the address part of the UNC. */
 666                 slash = strchr(&ctx->UNC[2], '\\');
 667                 len = slash - &ctx->UNC[2];
 668                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
 669                                           &ctx->UNC[2], len)) {
 670                         pr_err("Unable to determine destination address\n");
 671                         return -EHOSTUNREACH;
 672                 }
 673         }
 674
 675         /* set the port that we got earlier */
 676         cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
 677
 678         if (ctx->override_uid && !ctx->uid_specified) {
 679                 ctx->override_uid = 0;
 680                 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
 681         }
 682
 683         if (ctx->override_gid && !ctx->gid_specified) {
 684                 ctx->override_gid = 0;
 685                 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
 686         }
 687
 688         return 0;
 689 }
 690
 691 static int smb3_get_tree_common(struct fs_context *fc)
 692 {
 693         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 694         struct dentry *root;
 695         int rc = 0;
 696
 697         root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
 698         if (IS_ERR(root))
 699                 return PTR_ERR(root);
 700
 701         fc->root = root;
 702
 703         return rc;
 704 }
 705
 706 /*
 707  * Create an SMB3 superblock from the parameters passed.
 708  */
 709 static int smb3_get_tree(struct fs_context *fc)
 710 {
 711         int err = smb3_fs_context_validate(fc);
 712         int ret;
 713
 714         if (err)
 715                 return err;
 716         mutex_lock(&cifs_mount_mutex);
 717         ret = smb3_get_tree_common(fc);
 718         mutex_unlock(&cifs_mount_mutex);
 719         return ret;
 720 }
 721
 722 static void smb3_fs_context_free(struct fs_context *fc)
 723 {
 724         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 725
 726         smb3_cleanup_fs_context(ctx);
 727 }
 728
 729 /*
 730  * Compare the old and new proposed context during reconfigure
 731  * and check if the changes are compatible.
 732  */
 733 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
 734                                        struct smb3_fs_context *new_ctx,
 735                                        struct smb3_fs_context *old_ctx)
 736 {
 737         if (new_ctx->posix_paths != old_ctx->posix_paths) {
 738                 cifs_errorf(fc, "can not change posixpaths during remount\n");
 739                 return -EINVAL;
 740         }
 741         if (new_ctx->sectype != old_ctx->sectype) {
 742                 cifs_errorf(fc, "can not change sec during remount\n");
 743                 return -EINVAL;
 744         }
 745         if (new_ctx->multiuser != old_ctx->multiuser) {
 746                 cifs_errorf(fc, "can not change multiuser during remount\n");
 747                 return -EINVAL;
 748         }
 749         if (new_ctx->UNC &&
 750             (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
 751                 cifs_errorf(fc, "can not change UNC during remount\n");
 752                 return -EINVAL;
 753         }
 754         if (new_ctx->username &&
 755             (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
 756                 cifs_errorf(fc, "can not change username during remount\n");
 757                 return -EINVAL;
 758         }
 759         if (new_ctx->password &&
 760             (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
 761                 cifs_errorf(fc, "can not change password during remount\n");
 762                 return -EINVAL;
 763         }
 764         if (new_ctx->domainname &&
 765             (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
 766                 cifs_errorf(fc, "can not change domainname during remount\n");
 767                 return -EINVAL;
 768         }
 769         if (strcmp(new_ctx->workstation_name, old_ctx->workstation_name)) {
 770                 cifs_errorf(fc, "can not change workstation_name during remount\n");
 771                 return -EINVAL;
 772         }
 773         if (new_ctx->nodename &&
 774             (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
 775                 cifs_errorf(fc, "can not change nodename during remount\n");
 776                 return -EINVAL;
 777         }
 778         if (new_ctx->iocharset &&
 779             (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
 780                 cifs_errorf(fc, "can not change iocharset during remount\n");
 781                 return -EINVAL;
 782         }
 783
 784         return 0;
 785 }
 786
 787 #define STEAL_STRING(cifs_sb, ctx, field)                               \
 788 do {                                                                    \
 789         kfree(ctx->field);                                              \
 790         ctx->field = cifs_sb->ctx->field;                               \
 791         cifs_sb->ctx->field = NULL;                                     \
 792 } while (0)
 793
 794 static int smb3_reconfigure(struct fs_context *fc)
 795 {
 796         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 797         struct dentry *root = fc->root;
 798         struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
 799         int rc;
 800
 801         rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx);
 802         if (rc)
 803                 return rc;
 804
 805         /*
 806          * We can not change UNC/username/password/domainname/
 807          * workstation_name/nodename/iocharset
 808          * during reconnect so ignore what we have in the new context and
 809          * just use what we already have in cifs_sb->ctx.
 810          */
 811         STEAL_STRING(cifs_sb, ctx, UNC);
 812         STEAL_STRING(cifs_sb, ctx, source);
 813         STEAL_STRING(cifs_sb, ctx, username);
 814         STEAL_STRING(cifs_sb, ctx, password);
 815         STEAL_STRING(cifs_sb, ctx, domainname);
 816         STEAL_STRING(cifs_sb, ctx, nodename);
 817         STEAL_STRING(cifs_sb, ctx, iocharset);
 818
 819         /* if rsize or wsize not passed in on remount, use previous values */
 820         if (ctx->rsize == 0)
 821                 ctx->rsize = cifs_sb->ctx->rsize;
 822         if (ctx->wsize == 0)
 823                 ctx->wsize = cifs_sb->ctx->wsize;
 824
 825
 826         smb3_cleanup_fs_context_contents(cifs_sb->ctx);
 827         rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
 828         smb3_update_mnt_flags(cifs_sb);
 829 #ifdef CONFIG_CIFS_DFS_UPCALL
 830         if (!rc)
 831                 rc = dfs_cache_remount_fs(cifs_sb);
 832 #endif
 833
 834         return rc;
 835 }
 836
 837 static int smb3_fs_context_parse_param(struct fs_context *fc,
 838                                       struct fs_parameter *param)
 839 {
 840         struct fs_parse_result result;
 841         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 842         int i, opt;
 843         bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
 844         bool skip_parsing = false;
 845         kuid_t uid;
 846         kgid_t gid;
 847
 848         cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
 849
 850         /*
 851          * fs_parse can not handle string options with an empty value so
 852          * we will need special handling of them.
 853          */
 854         if (param->type == fs_value_is_string && param->string[0] == 0) {
 855                 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
 856                         skip_parsing = true;
 857                         opt = Opt_pass;
 858                 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
 859                         skip_parsing = true;
 860                         opt = Opt_user;
 861                 }
 862         }
 863
 864         if (!skip_parsing) {
 865                 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
 866                 if (opt < 0)
 867                         return ctx->sloppy ? 1 : opt;
 868         }
 869
 870         switch (opt) {
 871         case Opt_compress:
 872                 ctx->compression = UNKNOWN_TYPE;
 873                 cifs_dbg(VFS,
 874                         "SMB3 compression support is experimental\n");
 875                 break;
 876         case Opt_nodfs:
 877                 ctx->nodfs = 1;
 878                 break;
 879         case Opt_hard:
 880                 if (result.negated)
 881                         ctx->retry = 0;
 882                 else
 883                         ctx->retry = 1;
 884                 break;
 885         case Opt_soft:
 886                 if (result.negated)
 887                         ctx->retry = 1;
 888                 else
 889                         ctx->retry = 0;
 890                 break;
 891         case Opt_mapposix:
 892                 if (result.negated)
 893                         ctx->remap = false;
 894                 else {
 895                         ctx->remap = true;
 896                         ctx->sfu_remap = false; /* disable SFU mapping */
 897                 }
 898                 break;
 899         case Opt_user_xattr:
 900                 if (result.negated)
 901                         ctx->no_xattr = 1;
 902                 else
 903                         ctx->no_xattr = 0;
 904                 break;
 905         case Opt_forceuid:
 906                 if (result.negated)
 907                         ctx->override_uid = 0;
 908                 else
 909                         ctx->override_uid = 1;
 910                 break;
 911         case Opt_forcegid:
 912                 if (result.negated)
 913                         ctx->override_gid = 0;
 914                 else
 915                         ctx->override_gid = 1;
 916                 break;
 917         case Opt_perm:
 918                 if (result.negated)
 919                         ctx->noperm = 1;
 920                 else
 921                         ctx->noperm = 0;
 922                 break;
 923         case Opt_dynperm:
 924                 if (result.negated)
 925                         ctx->dynperm = 0;
 926                 else
 927                         ctx->dynperm = 1;
 928                 break;
 929         case Opt_sfu:
 930                 if (result.negated)
 931                         ctx->sfu_emul = 0;
 932                 else
 933                         ctx->sfu_emul = 1;
 934                 break;
 935         case Opt_noblocksend:
 936                 ctx->noblocksnd = 1;
 937                 break;
 938         case Opt_noautotune:
 939                 ctx->noautotune = 1;
 940                 break;
 941         case Opt_nolease:
 942                 ctx->no_lease = 1;
 943                 break;
 944         case Opt_nosparse:
 945                 ctx->no_sparse = 1;
 946                 break;
 947         case Opt_nodelete:
 948                 ctx->nodelete = 1;
 949                 break;
 950         case Opt_multichannel:
 951                 if (result.negated) {
 952                         ctx->multichannel = false;
 953                         ctx->max_channels = 1;
 954                 } else {
 955                         ctx->multichannel = true;
 956                         /* if number of channels not specified, default to 2 */
 957                         if (ctx->max_channels < 2)
 958                                 ctx->max_channels = 2;
 959                 }
 960                 break;
 961         case Opt_uid:
 962                 uid = make_kuid(current_user_ns(), result.uint_32);
 963                 if (!uid_valid(uid))
 964                         goto cifs_parse_mount_err;
 965                 ctx->linux_uid = uid;
 966                 ctx->uid_specified = true;
 967                 break;
 968         case Opt_cruid:
 969                 uid = make_kuid(current_user_ns(), result.uint_32);
 970                 if (!uid_valid(uid))
 971                         goto cifs_parse_mount_err;
 972                 ctx->cred_uid = uid;
 973                 ctx->cruid_specified = true;
 974                 break;
 975         case Opt_backupuid:
 976                 uid = make_kuid(current_user_ns(), result.uint_32);
 977                 if (!uid_valid(uid))
 978                         goto cifs_parse_mount_err;
 979                 ctx->backupuid = uid;
 980                 ctx->backupuid_specified = true;
 981                 break;
 982         case Opt_backupgid:
 983                 gid = make_kgid(current_user_ns(), result.uint_32);
 984                 if (!gid_valid(gid))
 985                         goto cifs_parse_mount_err;
 986                 ctx->backupgid = gid;
 987                 ctx->backupgid_specified = true;
 988                 break;
 989         case Opt_gid:
 990                 gid = make_kgid(current_user_ns(), result.uint_32);
 991                 if (!gid_valid(gid))
 992                         goto cifs_parse_mount_err;
 993                 ctx->linux_gid = gid;
 994                 ctx->gid_specified = true;
 995                 break;
 996         case Opt_port:
 997                 ctx->port = result.uint_32;
 998                 break;
 999         case Opt_file_mode:
1000                 ctx->file_mode = result.uint_32;
1001                 break;
1002         case Opt_dirmode:
1003                 ctx->dir_mode = result.uint_32;
1004                 break;
1005         case Opt_min_enc_offload:
1006                 ctx->min_offload = result.uint_32;
1007                 break;
1008         case Opt_blocksize:
1009                 /*
1010                  * inode blocksize realistically should never need to be
1011                  * less than 16K or greater than 16M and default is 1MB.
1012                  * Note that small inode block sizes (e.g. 64K) can lead
1013                  * to very poor performance of common tools like cp and scp
1014                  */
1015                 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
1016                    (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
1017                         cifs_errorf(fc, "%s: Invalid blocksize\n",
1018                                 __func__);
1019                         goto cifs_parse_mount_err;
1020                 }
1021                 ctx->bsize = result.uint_32;
1022                 ctx->got_bsize = true;
1023                 break;
1024         case Opt_rasize:
1025                 /*
1026                  * readahead size realistically should never need to be
1027                  * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
1028                  * (perhaps an exception should be considered in the
1029                  * for the case of a large number of channels
1030                  * when multichannel is negotiated) since that would lead
1031                  * to plenty of parallel I/O in flight to the server.
1032                  * Note that smaller read ahead sizes would
1033                  * hurt performance of common tools like cp and scp
1034                  * which often trigger sequential i/o with read ahead
1035                  */
1036                 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
1037                     (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
1038                         cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
1039                                 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
1040                         goto cifs_parse_mount_err;
1041                 }
1042                 ctx->rasize = result.uint_32;
1043                 break;
1044         case Opt_rsize:
1045                 ctx->rsize = result.uint_32;
1046                 ctx->got_rsize = true;
1047                 break;
1048         case Opt_wsize:
1049                 ctx->wsize = result.uint_32;
1050                 ctx->got_wsize = true;
1051                 break;
1052         case Opt_acregmax:
1053                 ctx->acregmax = HZ * result.uint_32;
1054                 if (ctx->acregmax > CIFS_MAX_ACTIMEO) {
1055                         cifs_errorf(fc, "acregmax too large\n");
1056                         goto cifs_parse_mount_err;
1057                 }
1058                 break;
1059         case Opt_acdirmax:
1060                 ctx->acdirmax = HZ * result.uint_32;
1061                 if (ctx->acdirmax > CIFS_MAX_ACTIMEO) {
1062                         cifs_errorf(fc, "acdirmax too large\n");
1063                         goto cifs_parse_mount_err;
1064                 }
1065                 break;
1066         case Opt_actimeo:
1067                 if (HZ * result.uint_32 > CIFS_MAX_ACTIMEO) {
1068                         cifs_errorf(fc, "timeout too large\n");
1069                         goto cifs_parse_mount_err;
1070                 }
1071                 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1072                     (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1073                         cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1074                         break;
1075                 }
1076                 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1077                 break;
1078         case Opt_closetimeo:
1079                 ctx->closetimeo = HZ * result.uint_32;
1080                 if (ctx->closetimeo > SMB3_MAX_DCLOSETIMEO) {
1081                         cifs_errorf(fc, "closetimeo too large\n");
1082                         goto cifs_parse_mount_err;
1083                 }
1084                 break;
1085         case Opt_echo_interval:
1086                 ctx->echo_interval = result.uint_32;
1087                 break;
1088         case Opt_snapshot:
1089                 ctx->snapshot_time = result.uint_64;
1090                 break;
1091         case Opt_max_credits:
1092                 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1093                         cifs_errorf(fc, "%s: Invalid max_credits value\n",
1094                                  __func__);
1095                         goto cifs_parse_mount_err;
1096                 }
1097                 ctx->max_credits = result.uint_32;
1098                 break;
1099         case Opt_max_channels:
1100                 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1101                         cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1102                                  __func__, CIFS_MAX_CHANNELS);
1103                         goto cifs_parse_mount_err;
1104                 }
1105                 ctx->max_channels = result.uint_32;
1106                 /* If more than one channel requested ... they want multichan */
1107                 if (result.uint_32 > 1)
1108                         ctx->multichannel = true;
1109                 break;
1110         case Opt_handletimeout:
1111                 ctx->handle_timeout = result.uint_32;
1112                 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1113                         cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1114                         goto cifs_parse_mount_err;
1115                 }
1116                 break;
1117         case Opt_source:
1118                 kfree(ctx->UNC);
1119                 ctx->UNC = NULL;
1120                 switch (smb3_parse_devname(param->string, ctx)) {
1121                 case 0:
1122                         break;
1123                 case -ENOMEM:
1124                         cifs_errorf(fc, "Unable to allocate memory for devname\n");
1125                         goto cifs_parse_mount_err;
1126                 case -EINVAL:
1127                         cifs_errorf(fc, "Malformed UNC in devname\n");
1128                         goto cifs_parse_mount_err;
1129                 default:
1130                         cifs_errorf(fc, "Unknown error parsing devname\n");
1131                         goto cifs_parse_mount_err;
1132                 }
1133                 ctx->source = kstrdup(param->string, GFP_KERNEL);
1134                 if (ctx->source == NULL) {
1135                         cifs_errorf(fc, "OOM when copying UNC string\n");
1136                         goto cifs_parse_mount_err;
1137                 }
1138                 fc->source = kstrdup(param->string, GFP_KERNEL);
1139                 if (fc->source == NULL) {
1140                         cifs_errorf(fc, "OOM when copying UNC string\n");
1141                         goto cifs_parse_mount_err;
1142                 }
1143                 break;
1144         case Opt_user:
1145                 kfree(ctx->username);
1146                 ctx->username = NULL;
1147                 if (strlen(param->string) == 0) {
1148                         /* null user, ie. anonymous authentication */
1149                         ctx->nullauth = 1;
1150                         break;
1151                 }
1152
1153                 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1154                     CIFS_MAX_USERNAME_LEN) {
1155                         pr_warn("username too long\n");
1156                         goto cifs_parse_mount_err;
1157                 }
1158                 ctx->username = kstrdup(param->string, GFP_KERNEL);
1159                 if (ctx->username == NULL) {
1160                         cifs_errorf(fc, "OOM when copying username string\n");
1161                         goto cifs_parse_mount_err;
1162                 }
1163                 break;
1164         case Opt_pass:
1165                 kfree(ctx->password);
1166                 ctx->password = NULL;
1167                 if (strlen(param->string) == 0)
1168                         break;
1169
1170                 ctx->password = kstrdup(param->string, GFP_KERNEL);
1171                 if (ctx->password == NULL) {
1172                         cifs_errorf(fc, "OOM when copying password string\n");
1173                         goto cifs_parse_mount_err;
1174                 }
1175                 break;
1176         case Opt_ip:
1177                 if (strlen(param->string) == 0) {
1178                         ctx->got_ip = false;
1179                         break;
1180                 }
1181                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1182                                           param->string,
1183                                           strlen(param->string))) {
1184                         pr_err("bad ip= option (%s)\n", param->string);
1185                         goto cifs_parse_mount_err;
1186                 }
1187                 ctx->got_ip = true;
1188                 break;
1189         case Opt_domain:
1190                 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1191                                 == CIFS_MAX_DOMAINNAME_LEN) {
1192                         pr_warn("domain name too long\n");
1193                         goto cifs_parse_mount_err;
1194                 }
1195
1196                 kfree(ctx->domainname);
1197                 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1198                 if (ctx->domainname == NULL) {
1199                         cifs_errorf(fc, "OOM when copying domainname string\n");
1200                         goto cifs_parse_mount_err;
1201                 }
1202                 cifs_dbg(FYI, "Domain name set\n");
1203                 break;
1204         case Opt_srcaddr:
1205                 if (!cifs_convert_address(
1206                                 (struct sockaddr *)&ctx->srcaddr,
1207                                 param->string, strlen(param->string))) {
1208                         pr_warn("Could not parse srcaddr: %s\n",
1209                                 param->string);
1210                         goto cifs_parse_mount_err;
1211                 }
1212                 break;
1213         case Opt_iocharset:
1214                 if (strnlen(param->string, 1024) >= 65) {
1215                         pr_warn("iocharset name too long\n");
1216                         goto cifs_parse_mount_err;
1217                 }
1218
1219                 if (strncasecmp(param->string, "default", 7) != 0) {
1220                         kfree(ctx->iocharset);
1221                         ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1222                         if (ctx->iocharset == NULL) {
1223                                 cifs_errorf(fc, "OOM when copying iocharset string\n");
1224                                 goto cifs_parse_mount_err;
1225                         }
1226                 }
1227                 /* if iocharset not set then load_nls_default
1228                  * is used by caller
1229                  */
1230                 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1231                 break;
1232         case Opt_netbiosname:
1233                 memset(ctx->source_rfc1001_name, 0x20,
1234                         RFC1001_NAME_LEN);
1235                 /*
1236                  * FIXME: are there cases in which a comma can
1237                  * be valid in workstation netbios name (and
1238                  * need special handling)?
1239                  */
1240                 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1241                         /* don't ucase netbiosname for user */
1242                         if (param->string[i] == 0)
1243                                 break;
1244                         ctx->source_rfc1001_name[i] = param->string[i];
1245                 }
1246                 /* The string has 16th byte zero still from
1247                  * set at top of the function
1248                  */
1249                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1250                         pr_warn("netbiosname longer than 15 truncated\n");
1251                 break;
1252         case Opt_servern:
1253                 /* last byte, type, is 0x20 for servr type */
1254                 memset(ctx->target_rfc1001_name, 0x20,
1255                         RFC1001_NAME_LEN_WITH_NULL);
1256                 /*
1257                  * BB are there cases in which a comma can be valid in this
1258                  * workstation netbios name (and need special handling)?
1259                  */
1260
1261                 /* user or mount helper must uppercase the netbios name */
1262                 for (i = 0; i < 15; i++) {
1263                         if (param->string[i] == 0)
1264                                 break;
1265                         ctx->target_rfc1001_name[i] = param->string[i];
1266                 }
1267
1268                 /* The string has 16th byte zero still from set at top of function */
1269                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1270                         pr_warn("server netbiosname longer than 15 truncated\n");
1271                 break;
1272         case Opt_ver:
1273                 /* version of mount userspace tools, not dialect */
1274                 /* If interface changes in mount.cifs bump to new ver */
1275                 if (strncasecmp(param->string, "1", 1) == 0) {
1276                         if (strlen(param->string) > 1) {
1277                                 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1278                                         param->string);
1279                                 goto cifs_parse_mount_err;
1280                         }
1281                         /* This is the default */
1282                         break;
1283                 }
1284                 /* For all other value, error */
1285                 pr_warn("Invalid mount helper version specified\n");
1286                 goto cifs_parse_mount_err;
1287         case Opt_vers:
1288                 /* protocol version (dialect) */
1289                 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1290                         goto cifs_parse_mount_err;
1291                 ctx->got_version = true;
1292                 break;
1293         case Opt_sec:
1294                 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1295                         goto cifs_parse_mount_err;
1296                 break;
1297         case Opt_cache:
1298                 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1299                         goto cifs_parse_mount_err;
1300                 break;
1301         case Opt_witness:
1302 #ifndef CONFIG_CIFS_SWN_UPCALL
1303                 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1304                         goto cifs_parse_mount_err;
1305 #endif
1306                 ctx->witness = true;
1307                 pr_warn_once("Witness protocol support is experimental\n");
1308                 break;
1309         case Opt_rootfs:
1310 #ifndef CONFIG_CIFS_ROOT
1311                 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1312                 goto cifs_parse_mount_err;
1313 #endif
1314                 ctx->rootfs = true;
1315                 break;
1316         case Opt_posixpaths:
1317                 if (result.negated)
1318                         ctx->posix_paths = 0;
1319                 else
1320                         ctx->posix_paths = 1;
1321                 break;
1322         case Opt_unix:
1323                 if (result.negated) {
1324                         if (ctx->linux_ext == 1)
1325                                 pr_warn_once("conflicting posix mount options specified\n");
1326                         ctx->linux_ext = 0;
1327                         ctx->no_linux_ext = 1;
1328                 } else {
1329                         if (ctx->no_linux_ext == 1)
1330                                 pr_warn_once("conflicting posix mount options specified\n");
1331                         ctx->linux_ext = 1;
1332                         ctx->no_linux_ext = 0;
1333                 }
1334                 break;
1335         case Opt_nocase:
1336                 ctx->nocase = 1;
1337                 break;
1338         case Opt_brl:
1339                 if (result.negated) {
1340                         /*
1341                          * turn off mandatory locking in mode
1342                          * if remote locking is turned off since the
1343                          * local vfs will do advisory
1344                          */
1345                         if (ctx->file_mode ==
1346                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1347                                 ctx->file_mode = S_IALLUGO;
1348                         ctx->nobrl =  1;
1349                 } else
1350                         ctx->nobrl =  0;
1351                 break;
1352         case Opt_handlecache:
1353                 if (result.negated)
1354                         ctx->nohandlecache = 1;
1355                 else
1356                         ctx->nohandlecache = 0;
1357                 break;
1358         case Opt_forcemandatorylock:
1359                 ctx->mand_lock = 1;
1360                 break;
1361         case Opt_setuids:
1362                 ctx->setuids = result.negated;
1363                 break;
1364         case Opt_intr:
1365                 ctx->intr = !result.negated;
1366                 break;
1367         case Opt_setuidfromacl:
1368                 ctx->setuidfromacl = 1;
1369                 break;
1370         case Opt_strictsync:
1371                 ctx->nostrictsync = result.negated;
1372                 break;
1373         case Opt_serverino:
1374                 ctx->server_ino = !result.negated;
1375                 break;
1376         case Opt_rwpidforward:
1377                 ctx->rwpidforward = 1;
1378                 break;
1379         case Opt_modesid:
1380                 ctx->mode_ace = 1;
1381                 break;
1382         case Opt_cifsacl:
1383                 ctx->cifs_acl = !result.negated;
1384                 break;
1385         case Opt_acl:
1386                 ctx->no_psx_acl = result.negated;
1387                 break;
1388         case Opt_locallease:
1389                 ctx->local_lease = 1;
1390                 break;
1391         case Opt_sign:
1392                 ctx->sign = true;
1393                 break;
1394         case Opt_ignore_signature:
1395                 ctx->sign = true;
1396                 ctx->ignore_signature = true;
1397                 break;
1398         case Opt_seal:
1399                 /* we do not do the following in secFlags because seal
1400                  * is a per tree connection (mount) not a per socket
1401                  * or per-smb connection option in the protocol
1402                  * vol->secFlg |= CIFSSEC_MUST_SEAL;
1403                  */
1404                 ctx->seal = 1;
1405                 break;
1406         case Opt_noac:
1407                 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1408                 break;
1409         case Opt_fsc:
1410 #ifndef CONFIG_CIFS_FSCACHE
1411                 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1412                 goto cifs_parse_mount_err;
1413 #endif
1414                 ctx->fsc = true;
1415                 break;
1416         case Opt_mfsymlinks:
1417                 ctx->mfsymlinks = true;
1418                 break;
1419         case Opt_multiuser:
1420                 ctx->multiuser = true;
1421                 break;
1422         case Opt_sloppy:
1423                 ctx->sloppy = true;
1424                 break;
1425         case Opt_nosharesock:
1426                 ctx->nosharesock = true;
1427                 break;
1428         case Opt_persistent:
1429                 if (result.negated) {
1430                         ctx->nopersistent = true;
1431                         if (ctx->persistent) {
1432                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1433                                 goto cifs_parse_mount_err;
1434                         }
1435                 } else {
1436                         ctx->persistent = true;
1437                         if ((ctx->nopersistent) || (ctx->resilient)) {
1438                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1439                                 goto cifs_parse_mount_err;
1440                         }
1441                 }
1442                 break;
1443         case Opt_resilient:
1444                 if (result.negated) {
1445                         ctx->resilient = false; /* already the default */
1446                 } else {
1447                         ctx->resilient = true;
1448                         if (ctx->persistent) {
1449                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1450                                 goto cifs_parse_mount_err;
1451                         }
1452                 }
1453                 break;
1454         case Opt_tcp_nodelay:
1455                 /* tcp nodelay should not usually be needed since we CORK/UNCORK the socket */
1456                 if (result.negated)
1457                         ctx->sockopt_tcp_nodelay = false;
1458                 else
1459                         ctx->sockopt_tcp_nodelay = true;
1460                 break;
1461         case Opt_domainauto:
1462                 ctx->domainauto = true;
1463                 break;
1464         case Opt_rdma:
1465                 ctx->rdma = true;
1466                 break;
1467         }
1468         /* case Opt_ignore: - is ignored as expected ... */
1469
1470         return 0;
1471
1472  cifs_parse_mount_err:
1473         return -EINVAL;
1474 }
1475
1476 int smb3_init_fs_context(struct fs_context *fc)
1477 {
1478         struct smb3_fs_context *ctx;
1479         char *nodename = utsname()->nodename;
1480         int i;
1481
1482         ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1483         if (unlikely(!ctx))
1484                 return -ENOMEM;
1485
1486         strscpy(ctx->workstation_name, nodename, sizeof(ctx->workstation_name));
1487
1488         /*
1489          * does not have to be perfect mapping since field is
1490          * informational, only used for servers that do not support
1491          * port 445 and it can be overridden at mount time
1492          */
1493         memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1494         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1495                 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1496
1497         ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1498         /*
1499          * null target name indicates to use *SMBSERVR default called name
1500          *  if we end up sending RFC1001 session initialize
1501          */
1502         ctx->target_rfc1001_name[0] = 0;
1503         ctx->cred_uid = current_uid();
1504         ctx->linux_uid = current_uid();
1505         ctx->linux_gid = current_gid();
1506         /* By default 4MB read ahead size, 1MB block size */
1507         ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1508         ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1509
1510         /*
1511          * default to SFM style remapping of seven reserved characters
1512          * unless user overrides it or we negotiate CIFS POSIX where
1513          * it is unnecessary.  Can not simultaneously use more than one mapping
1514          * since then readdir could list files that open could not open
1515          */
1516         ctx->remap = true;
1517
1518         /* default to only allowing write access to owner of the mount */
1519         ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1520
1521         /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1522         /* default is always to request posix paths. */
1523         ctx->posix_paths = 1;
1524         /* default to using server inode numbers where available */
1525         ctx->server_ino = 1;
1526
1527         /* default is to use strict cifs caching semantics */
1528         ctx->strict_io = true;
1529
1530         ctx->acregmax = CIFS_DEF_ACTIMEO;
1531         ctx->acdirmax = CIFS_DEF_ACTIMEO;
1532         ctx->closetimeo = SMB3_DEF_DCLOSETIMEO;
1533
1534         /* Most clients set timeout to 0, allows server to use its default */
1535         ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1536
1537         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1538         ctx->ops = &smb30_operations;
1539         ctx->vals = &smbdefault_values;
1540
1541         ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1542
1543         /* default to no multichannel (single server connection) */
1544         ctx->multichannel = false;
1545         ctx->max_channels = 1;
1546
1547         ctx->backupuid_specified = false; /* no backup intent for a user */
1548         ctx->backupgid_specified = false; /* no backup intent for a group */
1549
1550 /*
1551  *      short int override_uid = -1;
1552  *      short int override_gid = -1;
1553  *      char *nodename = strdup(utsname()->nodename);
1554  *      struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1555  */
1556
1557         fc->fs_private = ctx;
1558         fc->ops = &smb3_fs_context_ops;
1559         return 0;
1560 }
1561
1562 void
1563 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1564 {
1565         if (ctx == NULL)
1566                 return;
1567
1568         /*
1569          * Make sure this stays in sync with smb3_fs_context_dup()
1570          */
1571         kfree(ctx->mount_options);
1572         ctx->mount_options = NULL;
1573         kfree(ctx->username);
1574         ctx->username = NULL;
1575         kfree_sensitive(ctx->password);
1576         ctx->password = NULL;
1577         kfree(ctx->server_hostname);
1578         ctx->server_hostname = NULL;
1579         kfree(ctx->UNC);
1580         ctx->UNC = NULL;
1581         kfree(ctx->source);
1582         ctx->source = NULL;
1583         kfree(ctx->domainname);
1584         ctx->domainname = NULL;
1585         kfree(ctx->nodename);
1586         ctx->nodename = NULL;
1587         kfree(ctx->iocharset);
1588         ctx->iocharset = NULL;
1589         kfree(ctx->prepath);
1590         ctx->prepath = NULL;
1591 }
1592
1593 void
1594 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1595 {
1596         if (!ctx)
1597                 return;
1598         smb3_cleanup_fs_context_contents(ctx);
1599         kfree(ctx);
1600 }
1601
1602 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1603 {
1604         struct smb3_fs_context *ctx = cifs_sb->ctx;
1605
1606         if (ctx->nodfs)
1607                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1608         else
1609                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1610
1611         if (ctx->noperm)
1612                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1613         else
1614                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1615
1616         if (ctx->setuids)
1617                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1618         else
1619                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1620
1621         if (ctx->setuidfromacl)
1622                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1623         else
1624                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1625
1626         if (ctx->server_ino)
1627                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1628         else
1629                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1630
1631         if (ctx->remap)
1632                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1633         else
1634                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1635
1636         if (ctx->sfu_remap)
1637                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1638         else
1639                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1640
1641         if (ctx->no_xattr)
1642                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1643         else
1644                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1645
1646         if (ctx->sfu_emul)
1647                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1648         else
1649                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1650
1651         if (ctx->nobrl)
1652                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1653         else
1654                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1655
1656         if (ctx->nohandlecache)
1657                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1658         else
1659                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1660
1661         if (ctx->nostrictsync)
1662                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1663         else
1664                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1665
1666         if (ctx->mand_lock)
1667                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1668         else
1669                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1670
1671         if (ctx->rwpidforward)
1672                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1673         else
1674                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1675
1676         if (ctx->mode_ace)
1677                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1678         else
1679                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1680
1681         if (ctx->cifs_acl)
1682                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1683         else
1684                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1685
1686         if (ctx->backupuid_specified)
1687                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1688         else
1689                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1690
1691         if (ctx->backupgid_specified)
1692                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1693         else
1694                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1695
1696         if (ctx->override_uid)
1697                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1698         else
1699                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1700
1701         if (ctx->override_gid)
1702                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1703         else
1704                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1705
1706         if (ctx->dynperm)
1707                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1708         else
1709                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1710
1711         if (ctx->fsc)
1712                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1713         else
1714                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1715
1716         if (ctx->multiuser)
1717                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1718                                             CIFS_MOUNT_NO_PERM);
1719         else
1720                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1721
1722
1723         if (ctx->strict_io)
1724                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1725         else
1726                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1727
1728         if (ctx->direct_io)
1729                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1730         else
1731                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1732
1733         if (ctx->mfsymlinks)
1734                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1735         else
1736                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1737         if (ctx->mfsymlinks) {
1738                 if (ctx->sfu_emul) {
1739                         /*
1740                          * Our SFU ("Services for Unix" emulation does not allow
1741                          * creating symlinks but does allow reading existing SFU
1742                          * symlinks (it does allow both creating and reading SFU
1743                          * style mknod and FIFOs though). When "mfsymlinks" and
1744                          * "sfu" are both enabled at the same time, it allows
1745                          * reading both types of symlinks, but will only create
1746                          * them with mfsymlinks format. This allows better
1747                          * Apple compatibility (probably better for Samba too)
1748                          * while still recognizing old Windows style symlinks.
1749                          */
1750                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1751                 }
1752         }
1753         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;
1754
1755         return;
1756 }