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