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