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