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 */
  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_no("setuids", Opt_setuids),
  98         fsparam_flag_no("dynperm", Opt_dynperm),
  99         fsparam_flag_no("intr", Opt_intr),
 100         fsparam_flag_no("strictsync", Opt_strictsync),
 101         fsparam_flag_no("serverino", Opt_serverino),
 102         fsparam_flag("rwpidforward", Opt_rwpidforward),
 103         fsparam_flag("cifsacl", Opt_cifsacl),
 104         fsparam_flag_no("acl", Opt_acl),
 105         fsparam_flag("locallease", Opt_locallease),
 106         fsparam_flag("sign", Opt_sign),
 107         fsparam_flag("ignore_signature", Opt_ignore_signature),
 108         fsparam_flag("seal", Opt_seal),
 109         fsparam_flag("noac", Opt_noac),
 110         fsparam_flag("fsc", Opt_fsc),
 111         fsparam_flag("mfsymlinks", Opt_mfsymlinks),
 112         fsparam_flag("multiuser", Opt_multiuser),
 113         fsparam_flag("sloppy", Opt_sloppy),
 114         fsparam_flag("nosharesock", Opt_nosharesock),
 115         fsparam_flag_no("persistent", Opt_persistent),
 116         fsparam_flag_no("resilient", Opt_resilient),
 117         fsparam_flag("domainauto", Opt_domainauto),
 118         fsparam_flag("rdma", Opt_rdma),
 119         fsparam_flag("modesid", Opt_modesid),
 120         fsparam_flag("rootfs", Opt_rootfs),
 121         fsparam_flag("compress", Opt_compress),
 122         fsparam_flag("witness", Opt_witness),
 123
 124         /* Mount options which take numeric value */
 125         fsparam_u32("backupuid", Opt_backupuid),
 126         fsparam_u32("backupgid", Opt_backupgid),
 127         fsparam_u32("uid", Opt_uid),
 128         fsparam_u32("cruid", Opt_cruid),
 129         fsparam_u32("gid", Opt_gid),
 130         fsparam_u32("file_mode", Opt_file_mode),
 131         fsparam_u32("dirmode", Opt_dirmode),
 132         fsparam_u32("dir_mode", Opt_dirmode),
 133         fsparam_u32("port", Opt_port),
 134         fsparam_u32("min_enc_offload", Opt_min_enc_offload),
 135         fsparam_u32("bsize", Opt_blocksize),
 136         fsparam_u32("rsize", Opt_rsize),
 137         fsparam_u32("wsize", Opt_wsize),
 138         fsparam_u32("actimeo", Opt_actimeo),
 139         fsparam_u32("echo_interval", Opt_echo_interval),
 140         fsparam_u32("max_credits", Opt_max_credits),
 141         fsparam_u32("handletimeout", Opt_handletimeout),
 142         fsparam_u32("snapshot", Opt_snapshot),
 143         fsparam_u32("max_channels", Opt_max_channels),
 144
 145         /* Mount options which take string value */
 146         fsparam_string("source", Opt_source),
 147         fsparam_string("unc", Opt_source),
 148         fsparam_string("user", Opt_user),
 149         fsparam_string("username", Opt_user),
 150         fsparam_string("pass", Opt_pass),
 151         fsparam_string("password", Opt_pass),
 152         fsparam_string("ip", Opt_ip),
 153         fsparam_string("addr", Opt_ip),
 154         fsparam_string("domain", Opt_domain),
 155         fsparam_string("dom", Opt_domain),
 156         fsparam_string("srcaddr", Opt_srcaddr),
 157         fsparam_string("iocharset", Opt_iocharset),
 158         fsparam_string("netbiosname", Opt_netbiosname),
 159         fsparam_string("servern", Opt_servern),
 160         fsparam_string("ver", Opt_ver),
 161         fsparam_string("vers", Opt_vers),
 162         fsparam_string("sec", Opt_sec),
 163         fsparam_string("cache", Opt_cache),
 164
 165         /* Arguments that should be ignored */
 166         fsparam_flag("guest", Opt_ignore),
 167         fsparam_flag("noatime", Opt_ignore),
 168         fsparam_flag("relatime", Opt_ignore),
 169         fsparam_flag("_netdev", Opt_ignore),
 170         fsparam_flag_no("suid", Opt_ignore),
 171         fsparam_flag_no("exec", Opt_ignore),
 172         fsparam_flag_no("dev", Opt_ignore),
 173         fsparam_flag_no("mand", Opt_ignore),
 174         fsparam_string("cred", Opt_ignore),
 175         fsparam_string("credentials", Opt_ignore),
 176 };
 177
 178 int
 179 cifs_parse_security_flavors(char *value, struct smb3_fs_context *ctx)
 180 {
 181
 182         substring_t args[MAX_OPT_ARGS];
 183
 184         /*
 185          * With mount options, the last one should win. Reset any existing
 186          * settings back to default.
 187          */
 188         ctx->sectype = Unspecified;
 189         ctx->sign = false;
 190
 191         switch (match_token(value, cifs_secflavor_tokens, args)) {
 192         case Opt_sec_krb5p:
 193                 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
 194                 return 1;
 195         case Opt_sec_krb5i:
 196                 ctx->sign = true;
 197                 fallthrough;
 198         case Opt_sec_krb5:
 199                 ctx->sectype = Kerberos;
 200                 break;
 201         case Opt_sec_ntlmsspi:
 202                 ctx->sign = true;
 203                 fallthrough;
 204         case Opt_sec_ntlmssp:
 205                 ctx->sectype = RawNTLMSSP;
 206                 break;
 207         case Opt_sec_ntlmi:
 208                 ctx->sign = true;
 209                 fallthrough;
 210         case Opt_ntlm:
 211                 ctx->sectype = NTLM;
 212                 break;
 213         case Opt_sec_ntlmv2i:
 214                 ctx->sign = true;
 215                 fallthrough;
 216         case Opt_sec_ntlmv2:
 217                 ctx->sectype = NTLMv2;
 218                 break;
 219 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 220         case Opt_sec_lanman:
 221                 ctx->sectype = LANMAN;
 222                 break;
 223 #endif
 224         case Opt_sec_none:
 225                 ctx->nullauth = 1;
 226                 break;
 227         default:
 228                 cifs_dbg(VFS, "bad security option: %s\n", value);
 229                 return 1;
 230         }
 231
 232         return 0;
 233 }
 234
 235 static const match_table_t cifs_cacheflavor_tokens = {
 236         { Opt_cache_loose, "loose" },
 237         { Opt_cache_strict, "strict" },
 238         { Opt_cache_none, "none" },
 239         { Opt_cache_ro, "ro" },
 240         { Opt_cache_rw, "singleclient" },
 241         { Opt_cache_err, NULL }
 242 };
 243
 244 int
 245 cifs_parse_cache_flavor(char *value, struct smb3_fs_context *ctx)
 246 {
 247         substring_t args[MAX_OPT_ARGS];
 248
 249         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
 250         case Opt_cache_loose:
 251                 ctx->direct_io = false;
 252                 ctx->strict_io = false;
 253                 ctx->cache_ro = false;
 254                 ctx->cache_rw = false;
 255                 break;
 256         case Opt_cache_strict:
 257                 ctx->direct_io = false;
 258                 ctx->strict_io = true;
 259                 ctx->cache_ro = false;
 260                 ctx->cache_rw = false;
 261                 break;
 262         case Opt_cache_none:
 263                 ctx->direct_io = true;
 264                 ctx->strict_io = false;
 265                 ctx->cache_ro = false;
 266                 ctx->cache_rw = false;
 267                 break;
 268         case Opt_cache_ro:
 269                 ctx->direct_io = false;
 270                 ctx->strict_io = false;
 271                 ctx->cache_ro = true;
 272                 ctx->cache_rw = false;
 273                 break;
 274         case Opt_cache_rw:
 275                 ctx->direct_io = false;
 276                 ctx->strict_io = false;
 277                 ctx->cache_ro = false;
 278                 ctx->cache_rw = true;
 279                 break;
 280         default:
 281                 cifs_dbg(VFS, "bad cache= option: %s\n", value);
 282                 return 1;
 283         }
 284         return 0;
 285 }
 286
 287 #define DUP_CTX_STR(field)                                              \
 288 do {                                                                    \
 289         if (ctx->field) {                                               \
 290                 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC);       \
 291                 if (new_ctx->field == NULL) {                           \
 292                         cifs_cleanup_volume_info_contents(new_ctx);     \
 293                         return -ENOMEM;                                 \
 294                 }                                                       \
 295         }                                                               \
 296 } while (0)
 297
 298 int
 299 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
 300 {
 301         int rc = 0;
 302
 303         memcpy(new_ctx, ctx, sizeof(*ctx));
 304         new_ctx->prepath = NULL;
 305         new_ctx->mount_options = NULL;
 306         new_ctx->local_nls = NULL;
 307         new_ctx->nodename = NULL;
 308         new_ctx->username = NULL;
 309         new_ctx->password = NULL;
 310         new_ctx->domainname = NULL;
 311         new_ctx->UNC = NULL;
 312         new_ctx->iocharset = NULL;
 313
 314         /*
 315          * Make sure to stay in sync with cifs_cleanup_volume_info_contents()
 316          */
 317         DUP_CTX_STR(prepath);
 318         DUP_CTX_STR(mount_options);
 319         DUP_CTX_STR(username);
 320         DUP_CTX_STR(password);
 321         DUP_CTX_STR(UNC);
 322         DUP_CTX_STR(domainname);
 323         DUP_CTX_STR(nodename);
 324         DUP_CTX_STR(iocharset);
 325
 326         return rc;
 327 }
 328
 329 static int
 330 cifs_parse_smb_version(char *value, struct smb3_fs_context *ctx, bool is_smb3)
 331 {
 332         substring_t args[MAX_OPT_ARGS];
 333
 334         switch (match_token(value, cifs_smb_version_tokens, args)) {
 335 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 336         case Smb_1:
 337                 if (disable_legacy_dialects) {
 338                         cifs_dbg(VFS, "mount with legacy dialect disabled\n");
 339                         return 1;
 340                 }
 341                 if (is_smb3) {
 342                         cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
 343                         return 1;
 344                 }
 345                 cifs_dbg(VFS, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
 346                 ctx->ops = &smb1_operations;
 347                 ctx->vals = &smb1_values;
 348                 break;
 349         case Smb_20:
 350                 if (disable_legacy_dialects) {
 351                         cifs_dbg(VFS, "mount with legacy dialect disabled\n");
 352                         return 1;
 353                 }
 354                 if (is_smb3) {
 355                         cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
 356                         return 1;
 357                 }
 358                 ctx->ops = &smb20_operations;
 359                 ctx->vals = &smb20_values;
 360                 break;
 361 #else
 362         case Smb_1:
 363                 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
 364                 return 1;
 365         case Smb_20:
 366                 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
 367                 return 1;
 368 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
 369         case Smb_21:
 370                 ctx->ops = &smb21_operations;
 371                 ctx->vals = &smb21_values;
 372                 break;
 373         case Smb_30:
 374                 ctx->ops = &smb30_operations;
 375                 ctx->vals = &smb30_values;
 376                 break;
 377         case Smb_302:
 378                 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
 379                 ctx->vals = &smb302_values;
 380                 break;
 381         case Smb_311:
 382                 ctx->ops = &smb311_operations;
 383                 ctx->vals = &smb311_values;
 384                 break;
 385         case Smb_3any:
 386                 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
 387                 ctx->vals = &smb3any_values;
 388                 break;
 389         case Smb_default:
 390                 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
 391                 ctx->vals = &smbdefault_values;
 392                 break;
 393         default:
 394                 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
 395                 return 1;
 396         }
 397         return 0;
 398 }
 399
 400 /*
 401  * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
 402  * fields with the result. Returns 0 on success and an error otherwise
 403  * (e.g. ENOMEM or EINVAL)
 404  */
 405 int
 406 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
 407 {
 408         char *pos;
 409         const char *delims = "/\\";
 410         size_t len;
 411
 412         if (unlikely(!devname || !*devname)) {
 413                 cifs_dbg(VFS, "Device name not specified\n");
 414                 return -EINVAL;
 415         }
 416
 417         /* make sure we have a valid UNC double delimiter prefix */
 418         len = strspn(devname, delims);
 419         if (len != 2)
 420                 return -EINVAL;
 421
 422         /* find delimiter between host and sharename */
 423         pos = strpbrk(devname + 2, delims);
 424         if (!pos)
 425                 return -EINVAL;
 426
 427         /* skip past delimiter */
 428         ++pos;
 429
 430         /* now go until next delimiter or end of string */
 431         len = strcspn(pos, delims);
 432
 433         /* move "pos" up to delimiter or NULL */
 434         pos += len;
 435         ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
 436         if (!ctx->UNC)
 437                 return -ENOMEM;
 438
 439         convert_delimiter(ctx->UNC, '\\');
 440
 441         /* skip any delimiter */
 442         if (*pos == '/' || *pos == '\\')
 443                 pos++;
 444
 445         /* If pos is NULL then no prepath */
 446         if (!*pos)
 447                 return 0;
 448
 449         ctx->prepath = kstrdup(pos, GFP_KERNEL);
 450         if (!ctx->prepath)
 451                 return -ENOMEM;
 452
 453         return 0;
 454 }
 455
 456 static void smb3_fs_context_free(struct fs_context *fc);
 457 static int smb3_fs_context_parse_param(struct fs_context *fc,
 458                                        struct fs_parameter *param);
 459 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 460                                             void *data);
 461 static int smb3_get_tree(struct fs_context *fc);
 462 static int smb3_reconfigure(struct fs_context *fc);
 463
 464 static const struct fs_context_operations smb3_fs_context_ops = {
 465         .free                   = smb3_fs_context_free,
 466         .parse_param            = smb3_fs_context_parse_param,
 467         .parse_monolithic       = smb3_fs_context_parse_monolithic,
 468         .get_tree               = smb3_get_tree,
 469         .reconfigure            = smb3_reconfigure,
 470 };
 471
 472 /*
 473  * Parse a monolithic block of data from sys_mount().
 474  * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
 475  * @ctx: The superblock configuration to fill in.
 476  * @data: The data to parse
 477  *
 478  * Parse a blob of data that's in key[=val][,key[=val]]* form.  This can be
 479  * called from the ->monolithic_mount_data() fs_context operation.
 480  *
 481  * Returns 0 on success or the error returned by the ->parse_option() fs_context
 482  * operation on failure.
 483  */
 484 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
 485                                            void *data)
 486 {
 487         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 488         char *options = data, *key;
 489         int ret = 0;
 490
 491         if (!options)
 492                 return 0;
 493
 494         ctx->mount_options = kstrdup(data, GFP_KERNEL);
 495         if (ctx->mount_options == NULL)
 496                 return -ENOMEM;
 497
 498         ret = security_sb_eat_lsm_opts(options, &fc->security);
 499         if (ret)
 500                 return ret;
 501
 502         /* BB Need to add support for sep= here TBD */
 503         while ((key = strsep(&options, ",")) != NULL) {
 504                 if (*key) {
 505                         size_t v_len = 0;
 506                         char *value = strchr(key, '=');
 507
 508                         if (value) {
 509                                 if (value == key)
 510                                         continue;
 511                                 *value++ = 0;
 512                                 v_len = strlen(value);
 513                         }
 514                         ret = vfs_parse_fs_string(fc, key, value, v_len);
 515                         if (ret < 0)
 516                                 break;
 517                 }
 518         }
 519
 520         return ret;
 521 }
 522
 523 /*
 524  * Validate the preparsed information in the config.
 525  */
 526 static int smb3_fs_context_validate(struct fs_context *fc)
 527 {
 528         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 529
 530         if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
 531                 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
 532                 return -1;
 533         }
 534
 535 #ifndef CONFIG_KEYS
 536         /* Muliuser mounts require CONFIG_KEYS support */
 537         if (ctx->multiuser) {
 538                 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
 539                 return -1;
 540         }
 541 #endif
 542
 543         if (ctx->got_version == false)
 544                 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");
 545
 546
 547         if (!ctx->UNC) {
 548                 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
 549                 return -1;
 550         }
 551
 552         /* make sure UNC has a share name */
 553         if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
 554                 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
 555                 return -1;
 556         }
 557
 558         if (!ctx->got_ip) {
 559                 int len;
 560                 const char *slash;
 561
 562                 /* No ip= option specified? Try to get it from UNC */
 563                 /* Use the address part of the UNC. */
 564                 slash = strchr(&ctx->UNC[2], '\\');
 565                 len = slash - &ctx->UNC[2];
 566                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
 567                                           &ctx->UNC[2], len)) {
 568                         pr_err("Unable to determine destination address\n");
 569                         return -1;
 570                 }
 571         }
 572
 573         /* set the port that we got earlier */
 574         cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
 575
 576         if (ctx->override_uid && !ctx->uid_specified) {
 577                 ctx->override_uid = 0;
 578                 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
 579         }
 580
 581         if (ctx->override_gid && !ctx->gid_specified) {
 582                 ctx->override_gid = 0;
 583                 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
 584         }
 585
 586         return 0;
 587 }
 588
 589 static int smb3_get_tree_common(struct fs_context *fc)
 590 {
 591         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 592         struct dentry *root;
 593         int rc = 0;
 594
 595         root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
 596         if (IS_ERR(root))
 597                 return PTR_ERR(root);
 598
 599         fc->root = root;
 600
 601         return rc;
 602 }
 603
 604 /*
 605  * Create an SMB3 superblock from the parameters passed.
 606  */
 607 static int smb3_get_tree(struct fs_context *fc)
 608 {
 609         int err = smb3_fs_context_validate(fc);
 610
 611         if (err)
 612                 return err;
 613         return smb3_get_tree_common(fc);
 614 }
 615
 616 static void smb3_fs_context_free(struct fs_context *fc)
 617 {
 618         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 619
 620         cifs_cleanup_volume_info(ctx);
 621 }
 622
 623 static int smb3_reconfigure(struct fs_context *fc)
 624 {
 625         // TODO:  struct smb3_fs_context *ctx = smb3_fc2context(fc);
 626
 627         /* FIXME : add actual reconfigure */
 628         return 0;
 629 }
 630
 631 static int smb3_fs_context_parse_param(struct fs_context *fc,
 632                                       struct fs_parameter *param)
 633 {
 634         struct fs_parse_result result;
 635         struct smb3_fs_context *ctx = smb3_fc2context(fc);
 636         int i, opt;
 637         bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
 638         bool skip_parsing = false;
 639
 640         cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
 641
 642         /*
 643          * fs_parse can not handle string options with an empty value so
 644          * we will need special handling of them.
 645          */
 646         if (param->type == fs_value_is_string && param->string[0] == 0) {
 647                 if (!strcmp("pass", param->key) || !strcmp("password", param->key))
 648                         skip_parsing = true;
 649         }
 650
 651         if (!skip_parsing) {
 652                 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
 653                 if (opt < 0)
 654                         return ctx->sloppy ? 1 : opt;
 655         }
 656
 657         switch (opt) {
 658         case Opt_compress:
 659                 ctx->compression = UNKNOWN_TYPE;
 660                 cifs_dbg(VFS,
 661                         "SMB3 compression support is experimental\n");
 662                 break;
 663         case Opt_nodfs:
 664                 ctx->nodfs = 1;
 665                 break;
 666         case Opt_hard:
 667                 if (result.negated)
 668                         ctx->retry = 0;
 669                 else
 670                         ctx->retry = 1;
 671                 break;
 672         case Opt_soft:
 673                 if (result.negated)
 674                         ctx->retry = 1;
 675                 else
 676                         ctx->retry = 0;
 677                 break;
 678         case Opt_mapposix:
 679                 if (result.negated)
 680                         ctx->remap = false;
 681                 else {
 682                         ctx->remap = true;
 683                         ctx->sfu_remap = false; /* disable SFU mapping */
 684                 }
 685                 break;
 686         case Opt_user_xattr:
 687                 if (result.negated)
 688                         ctx->no_xattr = 1;
 689                 else
 690                         ctx->no_xattr = 0;
 691                 break;
 692         case Opt_forceuid:
 693                 if (result.negated)
 694                         ctx->override_uid = 0;
 695                 else
 696                         ctx->override_uid = 1;
 697                 break;
 698         case Opt_forcegid:
 699                 if (result.negated)
 700                         ctx->override_gid = 0;
 701                 else
 702                         ctx->override_gid = 1;
 703                 break;
 704         case Opt_perm:
 705                 if (result.negated)
 706                         ctx->noperm = 1;
 707                 else
 708                         ctx->noperm = 0;
 709                 break;
 710         case Opt_dynperm:
 711                 if (result.negated)
 712                         ctx->dynperm = 0;
 713                 else
 714                         ctx->dynperm = 1;
 715                 break;
 716         case Opt_sfu:
 717                 if (result.negated)
 718                         ctx->sfu_emul = 0;
 719                 else
 720                         ctx->sfu_emul = 1;
 721                 break;
 722         case Opt_noblocksend:
 723                 ctx->noblocksnd = 1;
 724                 break;
 725         case Opt_noautotune:
 726                 ctx->noautotune = 1;
 727                 break;
 728         case Opt_nolease:
 729                 ctx->no_lease = 1;
 730                 break;
 731         case Opt_nodelete:
 732                 ctx->nodelete = 1;
 733                 break;
 734         case Opt_multichannel:
 735                 if (result.negated) {
 736                         ctx->multichannel = false;
 737                         ctx->max_channels = 1;
 738                 } else {
 739                         ctx->multichannel = true;
 740                         /* if number of channels not specified, default to 2 */
 741                         if (ctx->max_channels < 2)
 742                                 ctx->max_channels = 2;
 743                 }
 744                 break;
 745         case Opt_uid:
 746                 ctx->linux_uid.val = result.uint_32;
 747                 ctx->uid_specified = true;
 748                 break;
 749         case Opt_cruid:
 750                 ctx->cred_uid.val = result.uint_32;
 751                 break;
 752         case Opt_backupgid:
 753                 ctx->backupgid.val = result.uint_32;
 754                 ctx->backupgid_specified = true;
 755                 break;
 756         case Opt_gid:
 757                 ctx->linux_gid.val = result.uint_32;
 758                 ctx->gid_specified = true;
 759                 break;
 760         case Opt_port:
 761                 ctx->port = result.uint_32;
 762                 break;
 763         case Opt_file_mode:
 764                 ctx->file_mode = result.uint_32;
 765                 break;
 766         case Opt_dirmode:
 767                 ctx->dir_mode = result.uint_32;
 768                 break;
 769         case Opt_min_enc_offload:
 770                 ctx->min_offload = result.uint_32;
 771                 break;
 772         case Opt_blocksize:
 773                 /*
 774                  * inode blocksize realistically should never need to be
 775                  * less than 16K or greater than 16M and default is 1MB.
 776                  * Note that small inode block sizes (e.g. 64K) can lead
 777                  * to very poor performance of common tools like cp and scp
 778                  */
 779                 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
 780                    (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
 781                         cifs_dbg(VFS, "%s: Invalid blocksize\n",
 782                                 __func__);
 783                         goto cifs_parse_mount_err;
 784                 }
 785                 ctx->bsize = result.uint_32;
 786                 break;
 787         case Opt_rsize:
 788                 ctx->rsize = result.uint_32;
 789                 break;
 790         case Opt_wsize:
 791                 ctx->wsize = result.uint_32;
 792                 break;
 793         case Opt_actimeo:
 794                 ctx->actimeo = HZ * result.uint_32;
 795                 if (ctx->actimeo > CIFS_MAX_ACTIMEO) {
 796                         cifs_dbg(VFS, "attribute cache timeout too large\n");
 797                         goto cifs_parse_mount_err;
 798                 }
 799                 break;
 800         case Opt_echo_interval:
 801                 ctx->echo_interval = result.uint_32;
 802                 break;
 803         case Opt_snapshot:
 804                 ctx->snapshot_time = result.uint_32;
 805                 break;
 806         case Opt_max_credits:
 807                 if (result.uint_32 < 20 || result.uint_32 > 60000) {
 808                         cifs_dbg(VFS, "%s: Invalid max_credits value\n",
 809                                  __func__);
 810                         goto cifs_parse_mount_err;
 811                 }
 812                 ctx->max_credits = result.uint_32;
 813                 break;
 814         case Opt_max_channels:
 815                 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
 816                         cifs_dbg(VFS, "%s: Invalid max_channels value, needs to be 1-%d\n",
 817                                  __func__, CIFS_MAX_CHANNELS);
 818                         goto cifs_parse_mount_err;
 819                 }
 820                 ctx->max_channels = result.uint_32;
 821                 break;
 822         case Opt_handletimeout:
 823                 ctx->handle_timeout = result.uint_32;
 824                 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
 825                         cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
 826                         goto cifs_parse_mount_err;
 827                 }
 828                 break;
 829         case Opt_source:
 830                 kfree(ctx->UNC);
 831                 ctx->UNC = NULL;
 832                 switch (smb3_parse_devname(param->string, ctx)) {
 833                 case 0:
 834                         break;
 835                 case -ENOMEM:
 836                         cifs_dbg(VFS, "Unable to allocate memory for devname\n");
 837                         goto cifs_parse_mount_err;
 838                 case -EINVAL:
 839                         cifs_dbg(VFS, "Malformed UNC in devname\n");
 840                         goto cifs_parse_mount_err;
 841                 default:
 842                         cifs_dbg(VFS, "Unknown error parsing devname\n");
 843                         goto cifs_parse_mount_err;
 844                 }
 845                 fc->source = kstrdup(param->string, GFP_KERNEL);
 846                 if (fc->source == NULL) {
 847                         cifs_dbg(VFS, "OOM when copying UNC string\n");
 848                         goto cifs_parse_mount_err;
 849                 }
 850                 break;
 851         case Opt_user:
 852                 kfree(ctx->username);
 853                 ctx->username = NULL;
 854                 if (strlen(param->string) == 0) {
 855                         /* null user, ie. anonymous authentication */
 856                         ctx->nullauth = 1;
 857                         break;
 858                 }
 859
 860                 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
 861                     CIFS_MAX_USERNAME_LEN) {
 862                         pr_warn("username too long\n");
 863                         goto cifs_parse_mount_err;
 864                 }
 865                 ctx->username = kstrdup(param->string, GFP_KERNEL);
 866                 if (ctx->username == NULL) {
 867                         cifs_dbg(VFS, "OOM when copying username string\n");
 868                         goto cifs_parse_mount_err;
 869                 }
 870                 break;
 871         case Opt_pass:
 872                 kfree(ctx->password);
 873                 ctx->password = NULL;
 874                 if (strlen(param->string) == 0)
 875                         break;
 876
 877                 ctx->password = kstrdup(param->string, GFP_KERNEL);
 878                 if (ctx->password == NULL) {
 879                         cifs_dbg(VFS, "OOM when copying password string\n");
 880                         goto cifs_parse_mount_err;
 881                 }
 882                 break;
 883         case Opt_ip:
 884                 if (strlen(param->string) == 0) {
 885                         ctx->got_ip = false;
 886                         break;
 887                 }
 888                 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
 889                                           param->string,
 890                                           strlen(param->string))) {
 891                         pr_err("bad ip= option (%s)\n", param->string);
 892                         goto cifs_parse_mount_err;
 893                 }
 894                 ctx->got_ip = true;
 895                 break;
 896         case Opt_domain:
 897                 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
 898                                 == CIFS_MAX_DOMAINNAME_LEN) {
 899                         pr_warn("domain name too long\n");
 900                         goto cifs_parse_mount_err;
 901                 }
 902
 903                 kfree(ctx->domainname);
 904                 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
 905                 if (ctx->domainname == NULL) {
 906                         cifs_dbg(VFS, "OOM when copying domainname string\n");
 907                         goto cifs_parse_mount_err;
 908                 }
 909                 cifs_dbg(FYI, "Domain name set\n");
 910                 break;
 911         case Opt_srcaddr:
 912                 if (!cifs_convert_address(
 913                                 (struct sockaddr *)&ctx->srcaddr,
 914                                 param->string, strlen(param->string))) {
 915                         pr_warn("Could not parse srcaddr: %s\n",
 916                                 param->string);
 917                         goto cifs_parse_mount_err;
 918                 }
 919                 break;
 920         case Opt_iocharset:
 921                 if (strnlen(param->string, 1024) >= 65) {
 922                         pr_warn("iocharset name too long\n");
 923                         goto cifs_parse_mount_err;
 924                 }
 925
 926                 if (strncasecmp(param->string, "default", 7) != 0) {
 927                         kfree(ctx->iocharset);
 928                         ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
 929                         if (ctx->iocharset == NULL) {
 930                                 cifs_dbg(VFS, "OOM when copying iocharset string\n");
 931                                 goto cifs_parse_mount_err;
 932                         }
 933                 }
 934                 /* if iocharset not set then load_nls_default
 935                  * is used by caller
 936                  */
 937                  cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
 938                 break;
 939         case Opt_netbiosname:
 940                 memset(ctx->source_rfc1001_name, 0x20,
 941                         RFC1001_NAME_LEN);
 942                 /*
 943                  * FIXME: are there cases in which a comma can
 944                  * be valid in workstation netbios name (and
 945                  * need special handling)?
 946                  */
 947                 for (i = 0; i < RFC1001_NAME_LEN; i++) {
 948                         /* don't ucase netbiosname for user */
 949                         if (param->string[i] == 0)
 950                                 break;
 951                         ctx->source_rfc1001_name[i] = param->string[i];
 952                 }
 953                 /* The string has 16th byte zero still from
 954                  * set at top of the function
 955                  */
 956                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
 957                         pr_warn("netbiosname longer than 15 truncated\n");
 958                 break;
 959         case Opt_servern:
 960                 /* last byte, type, is 0x20 for servr type */
 961                 memset(ctx->target_rfc1001_name, 0x20,
 962                         RFC1001_NAME_LEN_WITH_NULL);
 963                 /*
 964                  * BB are there cases in which a comma can be valid in this
 965                  * workstation netbios name (and need special handling)?
 966                  */
 967
 968                 /* user or mount helper must uppercase the netbios name */
 969                 for (i = 0; i < 15; i++) {
 970                         if (param->string[i] == 0)
 971                                 break;
 972                         ctx->target_rfc1001_name[i] = param->string[i];
 973                 }
 974
 975                 /* The string has 16th byte zero still from set at top of function */
 976                 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
 977                         pr_warn("server netbiosname longer than 15 truncated\n");
 978                 break;
 979         case Opt_ver:
 980                 /* version of mount userspace tools, not dialect */
 981                 /* If interface changes in mount.cifs bump to new ver */
 982                 if (strncasecmp(param->string, "1", 1) == 0) {
 983                         if (strlen(param->string) > 1) {
 984                                 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
 985                                         param->string);
 986                                 goto cifs_parse_mount_err;
 987                         }
 988                         /* This is the default */
 989                         break;
 990                 }
 991                 /* For all other value, error */
 992                 pr_warn("Invalid mount helper version specified\n");
 993                 goto cifs_parse_mount_err;
 994         case Opt_vers:
 995                 /* protocol version (dialect) */
 996                 if (cifs_parse_smb_version(param->string, ctx, is_smb3) != 0)
 997                         goto cifs_parse_mount_err;
 998                 ctx->got_version = true;
 999                 break;
1000         case Opt_sec:
1001                 if (cifs_parse_security_flavors(param->string, ctx) != 0)
1002                         goto cifs_parse_mount_err;
1003                 break;
1004         case Opt_cache:
1005                 if (cifs_parse_cache_flavor(param->string, ctx) != 0)
1006                         goto cifs_parse_mount_err;
1007                 break;
1008         case Opt_witness:
1009 #ifndef CONFIG_CIFS_SWN_UPCALL
1010                 cifs_dbg(VFS, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1011                         goto cifs_parse_mount_err;
1012 #endif
1013                 ctx->witness = true;
1014                 break;
1015         case Opt_rootfs:
1016 #ifdef CONFIG_CIFS_ROOT
1017                 ctx->rootfs = true;
1018 #endif
1019                 break;
1020         case Opt_posixpaths:
1021                 if (result.negated)
1022                         ctx->posix_paths = 0;
1023                 else
1024                         ctx->posix_paths = 1;
1025                 break;
1026         case Opt_unix:
1027                 if (result.negated)
1028                         ctx->linux_ext = 0;
1029                 else
1030                         ctx->no_linux_ext = 1;
1031                 break;
1032         case Opt_nocase:
1033                 ctx->nocase = 1;
1034                 break;
1035         case Opt_brl:
1036                 if (result.negated) {
1037                         /*
1038                          * turn off mandatory locking in mode
1039                          * if remote locking is turned off since the
1040                          * local vfs will do advisory
1041                          */
1042                         if (ctx->file_mode ==
1043                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1044                                 ctx->file_mode = S_IALLUGO;
1045                         ctx->nobrl =  1;
1046                 } else
1047                         ctx->nobrl =  0;
1048                 break;
1049         case Opt_handlecache:
1050                 if (result.negated)
1051                         ctx->nohandlecache = 1;
1052                 else
1053                         ctx->nohandlecache = 0;
1054                 break;
1055         case Opt_forcemandatorylock:
1056                 ctx->mand_lock = 1;
1057                 break;
1058         case Opt_setuids:
1059                 ctx->setuids = result.negated;
1060                 break;
1061         case Opt_intr:
1062                 ctx->intr = !result.negated;
1063                 break;
1064         case Opt_setuidfromacl:
1065                 ctx->setuidfromacl = 1;
1066                 break;
1067         case Opt_strictsync:
1068                 ctx->nostrictsync = result.negated;
1069                 break;
1070         case Opt_serverino:
1071                 ctx->server_ino = !result.negated;
1072                 break;
1073         case Opt_rwpidforward:
1074                 ctx->rwpidforward = 1;
1075                 break;
1076         case Opt_modesid:
1077                 ctx->mode_ace = 1;
1078                 break;
1079         case Opt_cifsacl:
1080                 ctx->cifs_acl = !result.negated;
1081                 break;
1082         case Opt_acl:
1083                 ctx->no_psx_acl = result.negated;
1084                 break;
1085         case Opt_locallease:
1086                 ctx->local_lease = 1;
1087                 break;
1088         case Opt_sign:
1089                 ctx->sign = true;
1090                 break;
1091         case Opt_ignore_signature:
1092                 ctx->sign = true;
1093                 ctx->ignore_signature = true;
1094                 break;
1095         case Opt_seal:
1096                 /* we do not do the following in secFlags because seal
1097                  * is a per tree connection (mount) not a per socket
1098                  * or per-smb connection option in the protocol
1099                  * vol->secFlg |= CIFSSEC_MUST_SEAL;
1100                  */
1101                 ctx->seal = 1;
1102                 break;
1103         case Opt_noac:
1104                 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1105                 break;
1106         case Opt_fsc:
1107 #ifndef CONFIG_CIFS_FSCACHE
1108                 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1109                 goto cifs_parse_mount_err;
1110 #endif
1111                 ctx->fsc = true;
1112                 break;
1113         case Opt_mfsymlinks:
1114                 ctx->mfsymlinks = true;
1115                 break;
1116         case Opt_multiuser:
1117                 ctx->multiuser = true;
1118                 break;
1119         case Opt_sloppy:
1120                 ctx->sloppy = true;
1121                 break;
1122         case Opt_nosharesock:
1123                 ctx->nosharesock = true;
1124                 break;
1125         case Opt_persistent:
1126                 if (result.negated) {
1127                         if ((ctx->nopersistent) || (ctx->resilient)) {
1128                                 cifs_dbg(VFS,
1129                                   "persistenthandles mount options conflict\n");
1130                                 goto cifs_parse_mount_err;
1131                         }
1132                 } else {
1133                         ctx->nopersistent = true;
1134                         if (ctx->persistent) {
1135                                 cifs_dbg(VFS,
1136                                   "persistenthandles mount options conflict\n");
1137                                 goto cifs_parse_mount_err;
1138                         }
1139                 }
1140                 break;
1141         case Opt_resilient:
1142                 if (result.negated) {
1143                         ctx->resilient = false; /* already the default */
1144                 } else {
1145                         ctx->resilient = true;
1146                         if (ctx->persistent) {
1147                                 cifs_dbg(VFS,
1148                                   "persistenthandles mount options conflict\n");
1149                                 goto cifs_parse_mount_err;
1150                         }
1151                 }
1152                 break;
1153         case Opt_domainauto:
1154                 ctx->domainauto = true;
1155                 break;
1156         case Opt_rdma:
1157                 ctx->rdma = true;
1158                 break;
1159         }
1160
1161         return 0;
1162
1163  cifs_parse_mount_err:
1164         return 1;
1165 }
1166
1167 int smb3_init_fs_context(struct fs_context *fc)
1168 {
1169         struct smb3_fs_context *ctx;
1170         char *nodename = utsname()->nodename;
1171         int i;
1172
1173         ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1174         if (unlikely(!ctx))
1175                 return -ENOMEM;
1176
1177         /*
1178          * does not have to be perfect mapping since field is
1179          * informational, only used for servers that do not support
1180          * port 445 and it can be overridden at mount time
1181          */
1182         memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1183         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1184                 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1185
1186         ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1187         /*
1188          * null target name indicates to use *SMBSERVR default called name
1189          *  if we end up sending RFC1001 session initialize
1190          */
1191         ctx->target_rfc1001_name[0] = 0;
1192         ctx->cred_uid = current_uid();
1193         ctx->linux_uid = current_uid();
1194         ctx->linux_gid = current_gid();
1195         ctx->bsize = 1024 * 1024; /* can improve cp performance significantly */
1196
1197         /*
1198          * default to SFM style remapping of seven reserved characters
1199          * unless user overrides it or we negotiate CIFS POSIX where
1200          * it is unnecessary.  Can not simultaneously use more than one mapping
1201          * since then readdir could list files that open could not open
1202          */
1203         ctx->remap = true;
1204
1205         /* default to only allowing write access to owner of the mount */
1206         ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1207
1208         /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1209         /* default is always to request posix paths. */
1210         ctx->posix_paths = 1;
1211         /* default to using server inode numbers where available */
1212         ctx->server_ino = 1;
1213
1214         /* default is to use strict cifs caching semantics */
1215         ctx->strict_io = true;
1216
1217         ctx->actimeo = CIFS_DEF_ACTIMEO;
1218
1219         /* Most clients set timeout to 0, allows server to use its default */
1220         ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1221
1222         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1223         ctx->ops = &smb30_operations;
1224         ctx->vals = &smbdefault_values;
1225
1226         ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1227
1228         /* default to no multichannel (single server connection) */
1229         ctx->multichannel = false;
1230         ctx->max_channels = 1;
1231
1232         ctx->backupuid_specified = false; /* no backup intent for a user */
1233         ctx->backupgid_specified = false; /* no backup intent for a group */
1234
1235 /*
1236  *      short int override_uid = -1;
1237  *      short int override_gid = -1;
1238  *      char *nodename = strdup(utsname()->nodename);
1239  *      struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1240  */
1241
1242         fc->fs_private = ctx;
1243         fc->ops = &smb3_fs_context_ops;
1244         return 0;
1245 }