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