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