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