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                         if (ctx->linux_ext == 1)
1271                                 pr_warn_once("conflicting posix mount options specified\n");
1272                         ctx->linux_ext = 0;
1273                         ctx->no_linux_ext = 1;
1274                 } else {
1275                         if (ctx->no_linux_ext == 1)
1276                                 pr_warn_once("conflicting posix mount options specified\n");
1277                         ctx->linux_ext = 1;
1278                         ctx->no_linux_ext = 0;
1279                 }
1280                 break;
1281         case Opt_nocase:
1282                 ctx->nocase = 1;
1283                 break;
1284         case Opt_brl:
1285                 if (result.negated) {
1286                         /*
1287                          * turn off mandatory locking in mode
1288                          * if remote locking is turned off since the
1289                          * local vfs will do advisory
1290                          */
1291                         if (ctx->file_mode ==
1292                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1293                                 ctx->file_mode = S_IALLUGO;
1294                         ctx->nobrl =  1;
1295                 } else
1296                         ctx->nobrl =  0;
1297                 break;
1298         case Opt_handlecache:
1299                 if (result.negated)
1300                         ctx->nohandlecache = 1;
1301                 else
1302                         ctx->nohandlecache = 0;
1303                 break;
1304         case Opt_forcemandatorylock:
1305                 ctx->mand_lock = 1;
1306                 break;
1307         case Opt_setuids:
1308                 ctx->setuids = result.negated;
1309                 break;
1310         case Opt_intr:
1311                 ctx->intr = !result.negated;
1312                 break;
1313         case Opt_setuidfromacl:
1314                 ctx->setuidfromacl = 1;
1315                 break;
1316         case Opt_strictsync:
1317                 ctx->nostrictsync = result.negated;
1318                 break;
1319         case Opt_serverino:
1320                 ctx->server_ino = !result.negated;
1321                 break;
1322         case Opt_rwpidforward:
1323                 ctx->rwpidforward = 1;
1324                 break;
1325         case Opt_modesid:
1326                 ctx->mode_ace = 1;
1327                 break;
1328         case Opt_cifsacl:
1329                 ctx->cifs_acl = !result.negated;
1330                 break;
1331         case Opt_acl:
1332                 ctx->no_psx_acl = result.negated;
1333                 break;
1334         case Opt_locallease:
1335                 ctx->local_lease = 1;
1336                 break;
1337         case Opt_sign:
1338                 ctx->sign = true;
1339                 break;
1340         case Opt_ignore_signature:
1341                 ctx->sign = true;
1342                 ctx->ignore_signature = true;
1343                 break;
1344         case Opt_seal:
1345                 /* we do not do the following in secFlags because seal
1346                  * is a per tree connection (mount) not a per socket
1347                  * or per-smb connection option in the protocol
1348                  * vol->secFlg |= CIFSSEC_MUST_SEAL;
1349                  */
1350                 ctx->seal = 1;
1351                 break;
1352         case Opt_noac:
1353                 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1354                 break;
1355         case Opt_fsc:
1356 #ifndef CONFIG_CIFS_FSCACHE
1357                 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1358                 goto cifs_parse_mount_err;
1359 #endif
1360                 ctx->fsc = true;
1361                 break;
1362         case Opt_mfsymlinks:
1363                 ctx->mfsymlinks = true;
1364                 break;
1365         case Opt_multiuser:
1366                 ctx->multiuser = true;
1367                 break;
1368         case Opt_sloppy:
1369                 ctx->sloppy = true;
1370                 break;
1371         case Opt_nosharesock:
1372                 ctx->nosharesock = true;
1373                 break;
1374         case Opt_persistent:
1375                 if (result.negated) {
1376                         ctx->nopersistent = true;
1377                         if (ctx->persistent) {
1378                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1379                                 goto cifs_parse_mount_err;
1380                         }
1381                 } else {
1382                         ctx->persistent = true;
1383                         if ((ctx->nopersistent) || (ctx->resilient)) {
1384                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1385                                 goto cifs_parse_mount_err;
1386                         }
1387                 }
1388                 break;
1389         case Opt_resilient:
1390                 if (result.negated) {
1391                         ctx->resilient = false; /* already the default */
1392                 } else {
1393                         ctx->resilient = true;
1394                         if (ctx->persistent) {
1395                                 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1396                                 goto cifs_parse_mount_err;
1397                         }
1398                 }
1399                 break;
1400         case Opt_domainauto:
1401                 ctx->domainauto = true;
1402                 break;
1403         case Opt_rdma:
1404                 ctx->rdma = true;
1405                 break;
1406         }
1407         /* case Opt_ignore: - is ignored as expected ... */
1408
1409         return 0;
1410
1411  cifs_parse_mount_err:
1412         return -EINVAL;
1413 }
1414
1415 int smb3_init_fs_context(struct fs_context *fc)
1416 {
1417         struct smb3_fs_context *ctx;
1418         char *nodename = utsname()->nodename;
1419         int i;
1420
1421         ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1422         if (unlikely(!ctx))
1423                 return -ENOMEM;
1424
1425         /*
1426          * does not have to be perfect mapping since field is
1427          * informational, only used for servers that do not support
1428          * port 445 and it can be overridden at mount time
1429          */
1430         memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1431         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1432                 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1433
1434         ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1435         /*
1436          * null target name indicates to use *SMBSERVR default called name
1437          *  if we end up sending RFC1001 session initialize
1438          */
1439         ctx->target_rfc1001_name[0] = 0;
1440         ctx->cred_uid = current_uid();
1441         ctx->linux_uid = current_uid();
1442         ctx->linux_gid = current_gid();
1443         /* By default 4MB read ahead size, 1MB block size */
1444         ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1445         ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1446
1447         /*
1448          * default to SFM style remapping of seven reserved characters
1449          * unless user overrides it or we negotiate CIFS POSIX where
1450          * it is unnecessary.  Can not simultaneously use more than one mapping
1451          * since then readdir could list files that open could not open
1452          */
1453         ctx->remap = true;
1454
1455         /* default to only allowing write access to owner of the mount */
1456         ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1457
1458         /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1459         /* default is always to request posix paths. */
1460         ctx->posix_paths = 1;
1461         /* default to using server inode numbers where available */
1462         ctx->server_ino = 1;
1463
1464         /* default is to use strict cifs caching semantics */
1465         ctx->strict_io = true;
1466
1467         ctx->acregmax = CIFS_DEF_ACTIMEO;
1468         ctx->acdirmax = CIFS_DEF_ACTIMEO;
1469
1470         /* Most clients set timeout to 0, allows server to use its default */
1471         ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1472
1473         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1474         ctx->ops = &smb30_operations;
1475         ctx->vals = &smbdefault_values;
1476
1477         ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1478
1479         /* default to no multichannel (single server connection) */
1480         ctx->multichannel = false;
1481         ctx->max_channels = 1;
1482
1483         ctx->backupuid_specified = false; /* no backup intent for a user */
1484         ctx->backupgid_specified = false; /* no backup intent for a group */
1485
1486 /*
1487  *      short int override_uid = -1;
1488  *      short int override_gid = -1;
1489  *      char *nodename = strdup(utsname()->nodename);
1490  *      struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1491  */
1492
1493         fc->fs_private = ctx;
1494         fc->ops = &smb3_fs_context_ops;
1495         return 0;
1496 }
1497
1498 void
1499 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1500 {
1501         if (ctx == NULL)
1502                 return;
1503
1504         /*
1505          * Make sure this stays in sync with smb3_fs_context_dup()
1506          */
1507         kfree(ctx->mount_options);
1508         ctx->mount_options = NULL;
1509         kfree(ctx->username);
1510         ctx->username = NULL;
1511         kfree_sensitive(ctx->password);
1512         ctx->password = NULL;
1513         kfree(ctx->UNC);
1514         ctx->UNC = NULL;
1515         kfree(ctx->source);
1516         ctx->source = NULL;
1517         kfree(ctx->domainname);
1518         ctx->domainname = NULL;
1519         kfree(ctx->nodename);
1520         ctx->nodename = NULL;
1521         kfree(ctx->iocharset);
1522         ctx->iocharset = NULL;
1523         kfree(ctx->prepath);
1524         ctx->prepath = NULL;
1525 }
1526
1527 void
1528 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
1529 {
1530         if (!ctx)
1531                 return;
1532         smb3_cleanup_fs_context_contents(ctx);
1533         kfree(ctx);
1534 }
1535
1536 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
1537 {
1538         struct smb3_fs_context *ctx = cifs_sb->ctx;
1539
1540         if (ctx->nodfs)
1541                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
1542         else
1543                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
1544
1545         if (ctx->noperm)
1546                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
1547         else
1548                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
1549
1550         if (ctx->setuids)
1551                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
1552         else
1553                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
1554
1555         if (ctx->setuidfromacl)
1556                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
1557         else
1558                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
1559
1560         if (ctx->server_ino)
1561                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
1562         else
1563                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
1564
1565         if (ctx->remap)
1566                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
1567         else
1568                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
1569
1570         if (ctx->sfu_remap)
1571                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
1572         else
1573                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
1574
1575         if (ctx->no_xattr)
1576                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
1577         else
1578                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
1579
1580         if (ctx->sfu_emul)
1581                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
1582         else
1583                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
1584
1585         if (ctx->nobrl)
1586                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
1587         else
1588                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
1589
1590         if (ctx->nohandlecache)
1591                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
1592         else
1593                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
1594
1595         if (ctx->nostrictsync)
1596                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
1597         else
1598                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
1599
1600         if (ctx->mand_lock)
1601                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
1602         else
1603                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
1604
1605         if (ctx->rwpidforward)
1606                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
1607         else
1608                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
1609
1610         if (ctx->mode_ace)
1611                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
1612         else
1613                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
1614
1615         if (ctx->cifs_acl)
1616                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
1617         else
1618                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
1619
1620         if (ctx->backupuid_specified)
1621                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
1622         else
1623                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
1624
1625         if (ctx->backupgid_specified)
1626                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
1627         else
1628                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
1629
1630         if (ctx->override_uid)
1631                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
1632         else
1633                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
1634
1635         if (ctx->override_gid)
1636                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
1637         else
1638                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
1639
1640         if (ctx->dynperm)
1641                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
1642         else
1643                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
1644
1645         if (ctx->fsc)
1646                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
1647         else
1648                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
1649
1650         if (ctx->multiuser)
1651                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
1652                                             CIFS_MOUNT_NO_PERM);
1653         else
1654                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
1655
1656
1657         if (ctx->strict_io)
1658                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
1659         else
1660                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
1661
1662         if (ctx->direct_io)
1663                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
1664         else
1665                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
1666
1667         if (ctx->mfsymlinks)
1668                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
1669         else
1670                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
1671         if (ctx->mfsymlinks) {
1672                 if (ctx->sfu_emul) {
1673                         /*
1674                          * Our SFU ("Services for Unix" emulation does not allow
1675                          * creating symlinks but does allow reading existing SFU
1676                          * symlinks (it does allow both creating and reading SFU
1677                          * style mknod and FIFOs though). When "mfsymlinks" and
1678                          * "sfu" are both enabled at the same time, it allows
1679                          * reading both types of symlinks, but will only create
1680                          * them with mfsymlinks format. This allows better
1681                          * Apple compatibility (probably better for Samba too)
1682                          * while still recognizing old Windows style symlinks.
1683                          */
1684                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
1685                 }
1686         }
1687         cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;
1688
1689         return;
1690 }