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
40 DEFINE_MUTEX(cifs_mount_mutex);
41
42 static 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
56 static 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
70 static const match_table_t cifs_upcall_target = {
71 { Opt_upcall_target_mount, "mount" },
72 { Opt_upcall_target_application, "app" },
73 { Opt_upcall_target_err, NULL }
74 };
75
76 const struct fs_parameter_spec smb3_fs_parameters[] = {
77 /* Mount options that take no arguments */
78 fsparam_flag_no("user_xattr", Opt_user_xattr),
79 fsparam_flag_no("forceuid", Opt_forceuid),
80 fsparam_flag_no("multichannel", Opt_multichannel),
81 fsparam_flag_no("forcegid", Opt_forcegid),
82 fsparam_flag("noblocksend", Opt_noblocksend),
83 fsparam_flag("noautotune", Opt_noautotune),
84 fsparam_flag("nolease", Opt_nolease),
85 fsparam_flag_no("hard", Opt_hard),
86 fsparam_flag_no("soft", Opt_soft),
87 fsparam_flag_no("perm", Opt_perm),
88 fsparam_flag("nodelete", Opt_nodelete),
89 fsparam_flag_no("mapposix", Opt_mapposix),
90 fsparam_flag("mapchars", Opt_mapchars),
91 fsparam_flag("nomapchars", Opt_nomapchars),
92 fsparam_flag_no("sfu", Opt_sfu),
93 fsparam_flag("nodfs", Opt_nodfs),
94 fsparam_flag_no("posixpaths", Opt_posixpaths),
95 fsparam_flag_no("unix", Opt_unix),
96 fsparam_flag_no("linux", Opt_unix),
97 fsparam_flag_no("posix", Opt_unix),
98 fsparam_flag("nocase", Opt_nocase),
99 fsparam_flag("ignorecase", Opt_nocase),
100 fsparam_flag_no("brl", Opt_brl),
101 fsparam_flag_no("handlecache", Opt_handlecache),
102 fsparam_flag("forcemandatorylock", Opt_forcemandatorylock),
103 fsparam_flag("forcemand", Opt_forcemandatorylock),
104 fsparam_flag("setuidfromacl", Opt_setuidfromacl),
105 fsparam_flag("idsfromsid", Opt_setuidfromacl),
106 fsparam_flag_no("setuids", Opt_setuids),
107 fsparam_flag_no("dynperm", Opt_dynperm),
108 fsparam_flag_no("intr", Opt_intr),
109 fsparam_flag_no("strictsync", Opt_strictsync),
110 fsparam_flag_no("serverino", Opt_serverino),
111 fsparam_flag("rwpidforward", Opt_rwpidforward),
112 fsparam_flag("cifsacl", Opt_cifsacl),
113 fsparam_flag_no("acl", Opt_acl),
114 fsparam_flag("locallease", Opt_locallease),
115 fsparam_flag("sign", Opt_sign),
116 fsparam_flag("ignore_signature", Opt_ignore_signature),
117 fsparam_flag("signloosely", Opt_ignore_signature),
118 fsparam_flag("seal", Opt_seal),
119 fsparam_flag("noac", Opt_noac),
120 fsparam_flag("fsc", Opt_fsc),
121 fsparam_flag("mfsymlinks", Opt_mfsymlinks),
122 fsparam_flag("multiuser", Opt_multiuser),
123 fsparam_flag("sloppy", Opt_sloppy),
124 fsparam_flag("nosharesock", Opt_nosharesock),
125 fsparam_flag_no("persistenthandles", Opt_persistent),
126 fsparam_flag_no("resilienthandles", Opt_resilient),
127 fsparam_flag_no("tcpnodelay", Opt_tcp_nodelay),
128 fsparam_flag("nosparse", Opt_nosparse),
129 fsparam_flag("domainauto", Opt_domainauto),
130 fsparam_flag("rdma", Opt_rdma),
131 fsparam_flag("modesid", Opt_modesid),
132 fsparam_flag("modefromsid", Opt_modesid),
133 fsparam_flag("rootfs", Opt_rootfs),
134 fsparam_flag("compress", Opt_compress),
135 fsparam_flag("witness", Opt_witness),
136 fsparam_flag_no("nativesocket", Opt_nativesocket),
137 fsparam_flag_no("unicode", Opt_unicode),
138 fsparam_flag_no("nbsessinit", Opt_nbsessinit),
139
140 /* Mount options which take uid or gid */
141 fsparam_uid("backupuid", Opt_backupuid),
142 fsparam_gid("backupgid", Opt_backupgid),
143 fsparam_uid("uid", Opt_uid),
144 fsparam_uid("cruid", Opt_cruid),
145 fsparam_gid("gid", Opt_gid),
146
147 /* Mount options which take numeric value */
148 fsparam_u32("file_mode", Opt_file_mode),
149 fsparam_u32("dirmode", Opt_dirmode),
150 fsparam_u32("dir_mode", Opt_dirmode),
151 fsparam_u32("port", Opt_port),
152 fsparam_u32("min_enc_offload", Opt_min_enc_offload),
153 fsparam_u32("retrans", Opt_retrans),
154 fsparam_u32("esize", Opt_min_enc_offload),
155 fsparam_u32("bsize", Opt_blocksize),
156 fsparam_u32("rasize", Opt_rasize),
157 fsparam_u32("rsize", Opt_rsize),
158 fsparam_u32("wsize", Opt_wsize),
159 fsparam_u32("actimeo", Opt_actimeo),
160 fsparam_u32("acdirmax", Opt_acdirmax),
161 fsparam_u32("acregmax", Opt_acregmax),
162 fsparam_u32("closetimeo", Opt_closetimeo),
163 fsparam_u32("echo_interval", Opt_echo_interval),
164 fsparam_u32("max_credits", Opt_max_credits),
165 fsparam_u32("max_cached_dirs", Opt_max_cached_dirs),
166 fsparam_u32("handletimeout", Opt_handletimeout),
167 fsparam_u64("snapshot", Opt_snapshot),
168 fsparam_u32("max_channels", Opt_max_channels),
169
170 /* Mount options which take string value */
171 fsparam_string("source", Opt_source),
172 fsparam_string("user", Opt_user),
173 fsparam_string("username", Opt_user),
174 fsparam_string("pass", Opt_pass),
175 fsparam_string("password", Opt_pass),
176 fsparam_string("pass2", Opt_pass2),
177 fsparam_string("password2", Opt_pass2),
178 fsparam_string("ip", Opt_ip),
179 fsparam_string("addr", Opt_ip),
180 fsparam_string("domain", Opt_domain),
181 fsparam_string("dom", Opt_domain),
182 fsparam_string("srcaddr", Opt_srcaddr),
183 fsparam_string("iocharset", Opt_iocharset),
184 fsparam_string("netbiosname", Opt_netbiosname),
185 fsparam_string("servern", Opt_servern),
186 fsparam_string("ver", Opt_ver),
187 fsparam_string("vers", Opt_vers),
188 fsparam_string("sec", Opt_sec),
189 fsparam_string("cache", Opt_cache),
190 fsparam_string("reparse", Opt_reparse),
191 fsparam_string("upcall_target", Opt_upcalltarget),
192 fsparam_string("symlink", Opt_symlink),
193 fsparam_string("symlinkroot", Opt_symlinkroot),
194
195 /* Arguments that should be ignored */
196 fsparam_flag("guest", Opt_ignore),
197 fsparam_flag("noatime", Opt_ignore),
198 fsparam_flag("relatime", Opt_ignore),
199 fsparam_flag("_netdev", Opt_ignore),
200 fsparam_flag_no("suid", Opt_ignore),
201 fsparam_flag_no("exec", Opt_ignore),
202 fsparam_flag_no("dev", Opt_ignore),
203 fsparam_flag_no("mand", Opt_ignore),
204 fsparam_flag_no("auto", Opt_ignore),
205 fsparam_string("cred", Opt_ignore),
206 fsparam_string("credentials", Opt_ignore),
207 /*
208 * UNC and prefixpath is now extracted from Opt_source
209 * in the new mount API so we can just ignore them going forward.
210 */
211 fsparam_string("unc", Opt_ignore),
212 fsparam_string("prefixpath", Opt_ignore),
213 {}
214 };
215
216 static int
cifs_parse_security_flavors(struct fs_context * fc,char * value,struct smb3_fs_context * ctx)217 cifs_parse_security_flavors(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
218 {
219
220 substring_t args[MAX_OPT_ARGS];
221
222 /*
223 * With mount options, the last one should win. Reset any existing
224 * settings back to default.
225 */
226 ctx->sectype = Unspecified;
227 ctx->sign = false;
228
229 switch (match_token(value, cifs_secflavor_tokens, args)) {
230 case Opt_sec_krb5p:
231 cifs_errorf(fc, "sec=krb5p is not supported. Use sec=krb5,seal instead\n");
232 return 1;
233 case Opt_sec_krb5i:
234 ctx->sign = true;
235 fallthrough;
236 case Opt_sec_krb5:
237 ctx->sectype = Kerberos;
238 break;
239 case Opt_sec_ntlmsspi:
240 ctx->sign = true;
241 fallthrough;
242 case Opt_sec_ntlmssp:
243 ctx->sectype = RawNTLMSSP;
244 break;
245 case Opt_sec_ntlmv2i:
246 ctx->sign = true;
247 fallthrough;
248 case Opt_sec_ntlmv2:
249 ctx->sectype = NTLMv2;
250 break;
251 case Opt_sec_none:
252 ctx->nullauth = 1;
253 kfree(ctx->username);
254 ctx->username = NULL;
255 break;
256 default:
257 cifs_errorf(fc, "bad security option: %s\n", value);
258 return 1;
259 }
260
261 return 0;
262 }
263
264 static int
cifs_parse_upcall_target(struct fs_context * fc,char * value,struct smb3_fs_context * ctx)265 cifs_parse_upcall_target(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
266 {
267 substring_t args[MAX_OPT_ARGS];
268
269 ctx->upcall_target = UPTARGET_UNSPECIFIED;
270
271 switch (match_token(value, cifs_upcall_target, args)) {
272 case Opt_upcall_target_mount:
273 ctx->upcall_target = UPTARGET_MOUNT;
274 break;
275 case Opt_upcall_target_application:
276 ctx->upcall_target = UPTARGET_APP;
277 break;
278
279 default:
280 cifs_errorf(fc, "bad upcall target: %s\n", value);
281 return 1;
282 }
283
284 return 0;
285 }
286
287 static const match_table_t cifs_cacheflavor_tokens = {
288 { Opt_cache_loose, "loose" },
289 { Opt_cache_strict, "strict" },
290 { Opt_cache_none, "none" },
291 { Opt_cache_ro, "ro" },
292 { Opt_cache_rw, "singleclient" },
293 { Opt_cache_err, NULL }
294 };
295
296 static int
cifs_parse_cache_flavor(struct fs_context * fc,char * value,struct smb3_fs_context * ctx)297 cifs_parse_cache_flavor(struct fs_context *fc, char *value, struct smb3_fs_context *ctx)
298 {
299 substring_t args[MAX_OPT_ARGS];
300
301 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
302 case Opt_cache_loose:
303 ctx->direct_io = false;
304 ctx->strict_io = false;
305 ctx->cache_ro = false;
306 ctx->cache_rw = false;
307 break;
308 case Opt_cache_strict:
309 ctx->direct_io = false;
310 ctx->strict_io = true;
311 ctx->cache_ro = false;
312 ctx->cache_rw = false;
313 break;
314 case Opt_cache_none:
315 ctx->direct_io = true;
316 ctx->strict_io = false;
317 ctx->cache_ro = false;
318 ctx->cache_rw = false;
319 break;
320 case Opt_cache_ro:
321 ctx->direct_io = false;
322 ctx->strict_io = false;
323 ctx->cache_ro = true;
324 ctx->cache_rw = false;
325 break;
326 case Opt_cache_rw:
327 ctx->direct_io = false;
328 ctx->strict_io = false;
329 ctx->cache_ro = false;
330 ctx->cache_rw = true;
331 break;
332 default:
333 cifs_errorf(fc, "bad cache= option: %s\n", value);
334 return 1;
335 }
336 return 0;
337 }
338
339 static const match_table_t reparse_flavor_tokens = {
340 { Opt_reparse_default, "default" },
341 { Opt_reparse_none, "none" },
342 { Opt_reparse_nfs, "nfs" },
343 { Opt_reparse_wsl, "wsl" },
344 { Opt_reparse_err, NULL },
345 };
346
parse_reparse_flavor(struct fs_context * fc,char * value,struct smb3_fs_context * ctx)347 static int parse_reparse_flavor(struct fs_context *fc, char *value,
348 struct smb3_fs_context *ctx)
349 {
350 substring_t args[MAX_OPT_ARGS];
351
352 switch (match_token(value, reparse_flavor_tokens, args)) {
353 case Opt_reparse_default:
354 ctx->reparse_type = CIFS_REPARSE_TYPE_DEFAULT;
355 break;
356 case Opt_reparse_none:
357 ctx->reparse_type = CIFS_REPARSE_TYPE_NONE;
358 break;
359 case Opt_reparse_nfs:
360 ctx->reparse_type = CIFS_REPARSE_TYPE_NFS;
361 break;
362 case Opt_reparse_wsl:
363 ctx->reparse_type = CIFS_REPARSE_TYPE_WSL;
364 break;
365 default:
366 cifs_errorf(fc, "bad reparse= option: %s\n", value);
367 return 1;
368 }
369 return 0;
370 }
371
372 static const match_table_t symlink_flavor_tokens = {
373 { Opt_symlink_default, "default" },
374 { Opt_symlink_none, "none" },
375 { Opt_symlink_native, "native" },
376 { Opt_symlink_unix, "unix" },
377 { Opt_symlink_mfsymlinks, "mfsymlinks" },
378 { Opt_symlink_sfu, "sfu" },
379 { Opt_symlink_nfs, "nfs" },
380 { Opt_symlink_wsl, "wsl" },
381 { Opt_symlink_err, NULL },
382 };
383
parse_symlink_flavor(struct fs_context * fc,char * value,struct smb3_fs_context * ctx)384 static int parse_symlink_flavor(struct fs_context *fc, char *value,
385 struct smb3_fs_context *ctx)
386 {
387 substring_t args[MAX_OPT_ARGS];
388
389 switch (match_token(value, symlink_flavor_tokens, args)) {
390 case Opt_symlink_default:
391 ctx->symlink_type = CIFS_SYMLINK_TYPE_DEFAULT;
392 break;
393 case Opt_symlink_none:
394 ctx->symlink_type = CIFS_SYMLINK_TYPE_NONE;
395 break;
396 case Opt_symlink_native:
397 ctx->symlink_type = CIFS_SYMLINK_TYPE_NATIVE;
398 break;
399 case Opt_symlink_unix:
400 ctx->symlink_type = CIFS_SYMLINK_TYPE_UNIX;
401 break;
402 case Opt_symlink_mfsymlinks:
403 ctx->symlink_type = CIFS_SYMLINK_TYPE_MFSYMLINKS;
404 break;
405 case Opt_symlink_sfu:
406 ctx->symlink_type = CIFS_SYMLINK_TYPE_SFU;
407 break;
408 case Opt_symlink_nfs:
409 ctx->symlink_type = CIFS_SYMLINK_TYPE_NFS;
410 break;
411 case Opt_symlink_wsl:
412 ctx->symlink_type = CIFS_SYMLINK_TYPE_WSL;
413 break;
414 default:
415 cifs_errorf(fc, "bad symlink= option: %s\n", value);
416 return 1;
417 }
418 return 0;
419 }
420
421 #define DUP_CTX_STR(field) \
422 do { \
423 if (ctx->field) { \
424 new_ctx->field = kstrdup(ctx->field, GFP_ATOMIC); \
425 if (new_ctx->field == NULL) { \
426 smb3_cleanup_fs_context_contents(new_ctx); \
427 return -ENOMEM; \
428 } \
429 } \
430 } while (0)
431
432 int
smb3_fs_context_dup(struct smb3_fs_context * new_ctx,struct smb3_fs_context * ctx)433 smb3_fs_context_dup(struct smb3_fs_context *new_ctx, struct smb3_fs_context *ctx)
434 {
435 memcpy(new_ctx, ctx, sizeof(*ctx));
436 new_ctx->prepath = NULL;
437 new_ctx->nodename = NULL;
438 new_ctx->username = NULL;
439 new_ctx->password = NULL;
440 new_ctx->password2 = NULL;
441 new_ctx->server_hostname = NULL;
442 new_ctx->domainname = NULL;
443 new_ctx->UNC = NULL;
444 new_ctx->source = NULL;
445 new_ctx->iocharset = NULL;
446 new_ctx->leaf_fullpath = NULL;
447 new_ctx->dns_dom = NULL;
448 new_ctx->symlinkroot = NULL;
449 /*
450 * Make sure to stay in sync with smb3_cleanup_fs_context_contents()
451 */
452 DUP_CTX_STR(prepath);
453 DUP_CTX_STR(username);
454 DUP_CTX_STR(password);
455 DUP_CTX_STR(password2);
456 DUP_CTX_STR(server_hostname);
457 DUP_CTX_STR(UNC);
458 DUP_CTX_STR(source);
459 DUP_CTX_STR(domainname);
460 DUP_CTX_STR(nodename);
461 DUP_CTX_STR(iocharset);
462 DUP_CTX_STR(leaf_fullpath);
463 DUP_CTX_STR(dns_dom);
464 DUP_CTX_STR(symlinkroot);
465
466 return 0;
467 }
468
469 static int
cifs_parse_smb_version(struct fs_context * fc,char * value,struct smb3_fs_context * ctx,bool is_smb3)470 cifs_parse_smb_version(struct fs_context *fc, char *value, struct smb3_fs_context *ctx, bool is_smb3)
471 {
472 substring_t args[MAX_OPT_ARGS];
473
474 switch (match_token(value, cifs_smb_version_tokens, args)) {
475 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
476 case Smb_1:
477 if (disable_legacy_dialects) {
478 cifs_errorf(fc, "mount with legacy dialect disabled\n");
479 return 1;
480 }
481 if (is_smb3) {
482 cifs_errorf(fc, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
483 return 1;
484 }
485 cifs_errorf(fc, "Use of the less secure dialect vers=1.0 is not recommended unless required for access to very old servers\n");
486 ctx->ops = &smb1_operations;
487 ctx->vals = &smb1_values;
488 break;
489 case Smb_20:
490 if (disable_legacy_dialects) {
491 cifs_errorf(fc, "mount with legacy dialect disabled\n");
492 return 1;
493 }
494 if (is_smb3) {
495 cifs_errorf(fc, "vers=2.0 not permitted when mounting with smb3\n");
496 return 1;
497 }
498 ctx->ops = &smb20_operations;
499 ctx->vals = &smb20_values;
500 break;
501 #else
502 case Smb_1:
503 cifs_errorf(fc, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
504 return 1;
505 case Smb_20:
506 cifs_errorf(fc, "vers=2.0 mount not permitted when legacy dialects disabled\n");
507 return 1;
508 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
509 case Smb_21:
510 ctx->ops = &smb21_operations;
511 ctx->vals = &smb21_values;
512 break;
513 case Smb_30:
514 ctx->ops = &smb30_operations;
515 ctx->vals = &smb30_values;
516 break;
517 case Smb_302:
518 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
519 ctx->vals = &smb302_values;
520 break;
521 case Smb_311:
522 ctx->ops = &smb311_operations;
523 ctx->vals = &smb311_values;
524 break;
525 case Smb_3any:
526 ctx->ops = &smb30_operations; /* currently identical with 3.0 */
527 ctx->vals = &smb3any_values;
528 break;
529 case Smb_default:
530 ctx->ops = &smb30_operations;
531 ctx->vals = &smbdefault_values;
532 break;
533 default:
534 cifs_errorf(fc, "Unknown vers= option specified: %s\n", value);
535 return 1;
536 }
537 return 0;
538 }
539
smb3_parse_opt(const char * options,const char * key,char ** val)540 int smb3_parse_opt(const char *options, const char *key, char **val)
541 {
542 int rc = -ENOENT;
543 char *opts, *orig, *p;
544
545 orig = opts = kstrdup(options, GFP_KERNEL);
546 if (!opts)
547 return -ENOMEM;
548
549 while ((p = strsep(&opts, ","))) {
550 char *nval;
551
552 if (!*p)
553 continue;
554 if (strncasecmp(p, key, strlen(key)))
555 continue;
556 nval = strchr(p, '=');
557 if (nval) {
558 if (nval == p)
559 continue;
560 *nval++ = 0;
561 *val = kstrdup(nval, GFP_KERNEL);
562 rc = !*val ? -ENOMEM : 0;
563 goto out;
564 }
565 }
566 out:
567 kfree(orig);
568 return rc;
569 }
570
571 /*
572 * Remove duplicate path delimiters. Windows is supposed to do that
573 * but there are some bugs that prevent rename from working if there are
574 * multiple delimiters.
575 *
576 * Return a sanitized duplicate of @path or NULL for empty prefix paths.
577 * Otherwise, return ERR_PTR.
578 *
579 * @gfp indicates the GFP_* flags for kstrdup.
580 * The caller is responsible for freeing the original.
581 */
582 #define IS_DELIM(c) ((c) == '/' || (c) == '\\')
cifs_sanitize_prepath(char * prepath,gfp_t gfp)583 char *cifs_sanitize_prepath(char *prepath, gfp_t gfp)
584 {
585 char *cursor1 = prepath, *cursor2 = prepath;
586 char *s;
587
588 /* skip all prepended delimiters */
589 while (IS_DELIM(*cursor1))
590 cursor1++;
591
592 /* copy the first letter */
593 *cursor2 = *cursor1;
594
595 /* copy the remainder... */
596 while (*(cursor1++)) {
597 /* ... skipping all duplicated delimiters */
598 if (IS_DELIM(*cursor1) && IS_DELIM(*cursor2))
599 continue;
600 *(++cursor2) = *cursor1;
601 }
602
603 /* if the last character is a delimiter, skip it */
604 if (IS_DELIM(*(cursor2 - 1)))
605 cursor2--;
606
607 *cursor2 = '\0';
608 if (!*prepath)
609 return NULL;
610 s = kstrdup(prepath, gfp);
611 if (!s)
612 return ERR_PTR(-ENOMEM);
613 return s;
614 }
615
616 /*
617 * Return full path based on the values of @ctx->{UNC,prepath}.
618 *
619 * It is assumed that both values were already parsed by smb3_parse_devname().
620 */
smb3_fs_context_fullpath(const struct smb3_fs_context * ctx,char dirsep)621 char *smb3_fs_context_fullpath(const struct smb3_fs_context *ctx, char dirsep)
622 {
623 size_t ulen, plen;
624 char *s;
625
626 ulen = strlen(ctx->UNC);
627 plen = ctx->prepath ? strlen(ctx->prepath) + 1 : 0;
628
629 s = kmalloc(ulen + plen + 1, GFP_KERNEL);
630 if (!s)
631 return ERR_PTR(-ENOMEM);
632 memcpy(s, ctx->UNC, ulen);
633 if (plen) {
634 s[ulen] = dirsep;
635 memcpy(s + ulen + 1, ctx->prepath, plen);
636 }
637 s[ulen + plen] = '\0';
638 convert_delimiter(s, dirsep);
639 return s;
640 }
641
642 /*
643 * Parse a devname into substrings and populate the ctx->UNC and ctx->prepath
644 * fields with the result. Returns 0 on success and an error otherwise
645 * (e.g. ENOMEM or EINVAL)
646 */
647 int
smb3_parse_devname(const char * devname,struct smb3_fs_context * ctx)648 smb3_parse_devname(const char *devname, struct smb3_fs_context *ctx)
649 {
650 char *pos;
651 const char *delims = "/\\";
652 size_t len;
653 int rc;
654
655 if (unlikely(!devname || !*devname)) {
656 cifs_dbg(VFS, "Device name not specified\n");
657 return -EINVAL;
658 }
659
660 /* make sure we have a valid UNC double delimiter prefix */
661 len = strspn(devname, delims);
662 if (len != 2)
663 return -EINVAL;
664
665 /* find delimiter between host and sharename */
666 pos = strpbrk(devname + 2, delims);
667 if (!pos)
668 return -EINVAL;
669
670 /* record the server hostname */
671 kfree(ctx->server_hostname);
672 ctx->server_hostname = kstrndup(devname + 2, pos - devname - 2, GFP_KERNEL);
673 if (!ctx->server_hostname)
674 return -ENOMEM;
675
676 /* skip past delimiter */
677 ++pos;
678
679 /* now go until next delimiter or end of string */
680 len = strcspn(pos, delims);
681 if (!len)
682 return -EINVAL;
683
684 /* move "pos" up to delimiter or NULL */
685 pos += len;
686 kfree(ctx->UNC);
687 ctx->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
688 if (!ctx->UNC)
689 return -ENOMEM;
690
691 convert_delimiter(ctx->UNC, '\\');
692
693 /* skip any delimiter */
694 if (*pos == '/' || *pos == '\\')
695 pos++;
696
697 kfree(ctx->prepath);
698 ctx->prepath = NULL;
699
700 /* If pos is NULL then no prepath */
701 if (!*pos)
702 return 0;
703
704 ctx->prepath = cifs_sanitize_prepath(pos, GFP_KERNEL);
705 if (IS_ERR(ctx->prepath)) {
706 rc = PTR_ERR(ctx->prepath);
707 ctx->prepath = NULL;
708 return rc;
709 }
710
711 return 0;
712 }
713
714 static void smb3_fs_context_free(struct fs_context *fc);
715 static int smb3_fs_context_parse_param(struct fs_context *fc,
716 struct fs_parameter *param);
717 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
718 void *data);
719 static int smb3_get_tree(struct fs_context *fc);
720 static int smb3_reconfigure(struct fs_context *fc);
721
722 static const struct fs_context_operations smb3_fs_context_ops = {
723 .free = smb3_fs_context_free,
724 .parse_param = smb3_fs_context_parse_param,
725 .parse_monolithic = smb3_fs_context_parse_monolithic,
726 .get_tree = smb3_get_tree,
727 .reconfigure = smb3_reconfigure,
728 };
729
730 /*
731 * Parse a monolithic block of data from sys_mount().
732 * smb3_fs_context_parse_monolithic - Parse key[=val][,key[=val]]* mount data
733 * @ctx: The superblock configuration to fill in.
734 * @data: The data to parse
735 *
736 * Parse a blob of data that's in key[=val][,key[=val]]* form. This can be
737 * called from the ->monolithic_mount_data() fs_context operation.
738 *
739 * Returns 0 on success or the error returned by the ->parse_option() fs_context
740 * operation on failure.
741 */
smb3_fs_context_parse_monolithic(struct fs_context * fc,void * data)742 static int smb3_fs_context_parse_monolithic(struct fs_context *fc,
743 void *data)
744 {
745 char *options = data, *key;
746 int ret = 0;
747
748 if (!options)
749 return 0;
750
751 ret = security_sb_eat_lsm_opts(options, &fc->security);
752 if (ret)
753 return ret;
754
755 /* BB Need to add support for sep= here TBD */
756 while ((key = strsep(&options, ",")) != NULL) {
757 size_t len;
758 char *value;
759
760 if (*key == 0)
761 break;
762
763 /* Check if following character is the deliminator If yes,
764 * we have encountered a double deliminator reset the NULL
765 * character to the deliminator
766 */
767 while (options && options[0] == ',') {
768 len = strlen(key);
769 strcpy(key + len, options);
770 options = strchr(options, ',');
771 if (options)
772 *options++ = 0;
773 }
774
775
776 len = 0;
777 value = strchr(key, '=');
778 if (value) {
779 if (value == key)
780 continue;
781 *value++ = 0;
782 len = strlen(value);
783 }
784
785 ret = vfs_parse_fs_string(fc, key, value, len);
786 if (ret < 0)
787 break;
788 }
789
790 return ret;
791 }
792
793 /*
794 * Validate the preparsed information in the config.
795 */
smb3_fs_context_validate(struct fs_context * fc)796 static int smb3_fs_context_validate(struct fs_context *fc)
797 {
798 struct smb3_fs_context *ctx = smb3_fc2context(fc);
799
800 if (ctx->rdma && ctx->vals->protocol_id < SMB30_PROT_ID) {
801 cifs_errorf(fc, "SMB Direct requires Version >=3.0\n");
802 return -EOPNOTSUPP;
803 }
804
805 #ifndef CONFIG_KEYS
806 /* Muliuser mounts require CONFIG_KEYS support */
807 if (ctx->multiuser) {
808 cifs_errorf(fc, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
809 return -1;
810 }
811 #endif
812
813 if (ctx->got_version == false)
814 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");
815
816
817 if (!ctx->UNC) {
818 cifs_errorf(fc, "CIFS mount error: No usable UNC path provided in device string!\n");
819 return -1;
820 }
821
822 /* make sure UNC has a share name */
823 if (strlen(ctx->UNC) < 3 || !strchr(ctx->UNC + 3, '\\')) {
824 cifs_errorf(fc, "Malformed UNC. Unable to find share name.\n");
825 return -ENOENT;
826 }
827
828 if (!ctx->got_ip) {
829 int len;
830 const char *slash;
831
832 /* No ip= option specified? Try to get it from UNC */
833 /* Use the address part of the UNC. */
834 slash = strchr(&ctx->UNC[2], '\\');
835 len = slash - &ctx->UNC[2];
836 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
837 &ctx->UNC[2], len)) {
838 pr_err("Unable to determine destination address\n");
839 return -EHOSTUNREACH;
840 }
841 }
842
843 /* set the port that we got earlier */
844 cifs_set_port((struct sockaddr *)&ctx->dstaddr, ctx->port);
845
846 if (ctx->uid_specified && !ctx->forceuid_specified) {
847 ctx->override_uid = 1;
848 pr_notice("enabling forceuid mount option implicitly because uid= option is specified\n");
849 }
850
851 if (ctx->gid_specified && !ctx->forcegid_specified) {
852 ctx->override_gid = 1;
853 pr_notice("enabling forcegid mount option implicitly because gid= option is specified\n");
854 }
855
856 if (ctx->override_uid && !ctx->uid_specified) {
857 ctx->override_uid = 0;
858 pr_notice("ignoring forceuid mount option specified with no uid= option\n");
859 }
860
861 if (ctx->override_gid && !ctx->gid_specified) {
862 ctx->override_gid = 0;
863 pr_notice("ignoring forcegid mount option specified with no gid= option\n");
864 }
865
866 return 0;
867 }
868
smb3_get_tree_common(struct fs_context * fc)869 static int smb3_get_tree_common(struct fs_context *fc)
870 {
871 struct smb3_fs_context *ctx = smb3_fc2context(fc);
872 struct dentry *root;
873 int rc = 0;
874
875 root = cifs_smb3_do_mount(fc->fs_type, 0, ctx);
876 if (IS_ERR(root))
877 return PTR_ERR(root);
878
879 fc->root = root;
880
881 return rc;
882 }
883
884 /*
885 * Create an SMB3 superblock from the parameters passed.
886 */
smb3_get_tree(struct fs_context * fc)887 static int smb3_get_tree(struct fs_context *fc)
888 {
889 int err = smb3_fs_context_validate(fc);
890 int ret;
891
892 if (err)
893 return err;
894 cifs_mount_lock();
895 ret = smb3_get_tree_common(fc);
896 cifs_mount_unlock();
897 return ret;
898 }
899
smb3_fs_context_free(struct fs_context * fc)900 static void smb3_fs_context_free(struct fs_context *fc)
901 {
902 struct smb3_fs_context *ctx = smb3_fc2context(fc);
903
904 smb3_cleanup_fs_context(ctx);
905 }
906
907 /*
908 * Compare the old and new proposed context during reconfigure
909 * and check if the changes are compatible.
910 */
smb3_verify_reconfigure_ctx(struct fs_context * fc,struct smb3_fs_context * new_ctx,struct smb3_fs_context * old_ctx,bool need_recon)911 static int smb3_verify_reconfigure_ctx(struct fs_context *fc,
912 struct smb3_fs_context *new_ctx,
913 struct smb3_fs_context *old_ctx, bool need_recon)
914 {
915 if (new_ctx->posix_paths != old_ctx->posix_paths) {
916 cifs_errorf(fc, "can not change posixpaths during remount\n");
917 return -EINVAL;
918 }
919 if (new_ctx->sectype != old_ctx->sectype) {
920 cifs_errorf(fc, "can not change sec during remount\n");
921 return -EINVAL;
922 }
923 if (new_ctx->multiuser != old_ctx->multiuser) {
924 cifs_errorf(fc, "can not change multiuser during remount\n");
925 return -EINVAL;
926 }
927 if (new_ctx->UNC &&
928 (!old_ctx->UNC || strcmp(new_ctx->UNC, old_ctx->UNC))) {
929 cifs_errorf(fc, "can not change UNC during remount\n");
930 return -EINVAL;
931 }
932 if (new_ctx->username &&
933 (!old_ctx->username || strcmp(new_ctx->username, old_ctx->username))) {
934 cifs_errorf(fc, "can not change username during remount\n");
935 return -EINVAL;
936 }
937 if (new_ctx->password &&
938 (!old_ctx->password || strcmp(new_ctx->password, old_ctx->password))) {
939 if (need_recon == false) {
940 cifs_errorf(fc,
941 "can not change password of active session during remount\n");
942 return -EINVAL;
943 } else if (old_ctx->sectype == Kerberos) {
944 cifs_errorf(fc,
945 "can not change password for Kerberos via remount\n");
946 return -EINVAL;
947 }
948 }
949 if (new_ctx->domainname &&
950 (!old_ctx->domainname || strcmp(new_ctx->domainname, old_ctx->domainname))) {
951 cifs_errorf(fc, "can not change domainname during remount\n");
952 return -EINVAL;
953 }
954 if (strcmp(new_ctx->workstation_name, old_ctx->workstation_name)) {
955 cifs_errorf(fc, "can not change workstation_name during remount\n");
956 return -EINVAL;
957 }
958 if (new_ctx->nodename &&
959 (!old_ctx->nodename || strcmp(new_ctx->nodename, old_ctx->nodename))) {
960 cifs_errorf(fc, "can not change nodename during remount\n");
961 return -EINVAL;
962 }
963 if (new_ctx->iocharset &&
964 (!old_ctx->iocharset || strcmp(new_ctx->iocharset, old_ctx->iocharset))) {
965 cifs_errorf(fc, "can not change iocharset during remount\n");
966 return -EINVAL;
967 }
968 if (new_ctx->unicode != old_ctx->unicode) {
969 cifs_errorf(fc, "can not change unicode during remount\n");
970 return -EINVAL;
971 }
972 if (new_ctx->rfc1001_sessinit != old_ctx->rfc1001_sessinit) {
973 cifs_errorf(fc, "can not change nbsessinit during remount\n");
974 return -EINVAL;
975 }
976
977 return 0;
978 }
979
980 #define STEAL_STRING(cifs_sb, ctx, field) \
981 do { \
982 kfree(ctx->field); \
983 ctx->field = cifs_sb->ctx->field; \
984 cifs_sb->ctx->field = NULL; \
985 } while (0)
986
987 #define STEAL_STRING_SENSITIVE(cifs_sb, ctx, field) \
988 do { \
989 kfree_sensitive(ctx->field); \
990 ctx->field = cifs_sb->ctx->field; \
991 cifs_sb->ctx->field = NULL; \
992 } while (0)
993
smb3_sync_session_ctx_passwords(struct cifs_sb_info * cifs_sb,struct cifs_ses * ses)994 int smb3_sync_session_ctx_passwords(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses)
995 {
996 if (ses->password &&
997 cifs_sb->ctx->password &&
998 strcmp(ses->password, cifs_sb->ctx->password)) {
999 kfree_sensitive(cifs_sb->ctx->password);
1000 cifs_sb->ctx->password = kstrdup(ses->password, GFP_KERNEL);
1001 if (!cifs_sb->ctx->password)
1002 return -ENOMEM;
1003 }
1004 if (ses->password2 &&
1005 cifs_sb->ctx->password2 &&
1006 strcmp(ses->password2, cifs_sb->ctx->password2)) {
1007 kfree_sensitive(cifs_sb->ctx->password2);
1008 cifs_sb->ctx->password2 = kstrdup(ses->password2, GFP_KERNEL);
1009 if (!cifs_sb->ctx->password2) {
1010 kfree_sensitive(cifs_sb->ctx->password);
1011 cifs_sb->ctx->password = NULL;
1012 return -ENOMEM;
1013 }
1014 }
1015 return 0;
1016 }
1017
smb3_reconfigure(struct fs_context * fc)1018 static int smb3_reconfigure(struct fs_context *fc)
1019 {
1020 struct smb3_fs_context *ctx = smb3_fc2context(fc);
1021 struct dentry *root = fc->root;
1022 struct cifs_sb_info *cifs_sb = CIFS_SB(root->d_sb);
1023 struct cifs_ses *ses = cifs_sb_master_tcon(cifs_sb)->ses;
1024 unsigned int rsize = ctx->rsize, wsize = ctx->wsize;
1025 char *new_password = NULL, *new_password2 = NULL;
1026 bool need_recon = false;
1027 int rc;
1028
1029 if (ses->expired_pwd)
1030 need_recon = true;
1031
1032 rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx, need_recon);
1033 if (rc)
1034 return rc;
1035
1036 /*
1037 * We can not change UNC/username/password/domainname/
1038 * workstation_name/nodename/iocharset
1039 * during reconnect so ignore what we have in the new context and
1040 * just use what we already have in cifs_sb->ctx.
1041 */
1042 STEAL_STRING(cifs_sb, ctx, UNC);
1043 STEAL_STRING(cifs_sb, ctx, source);
1044 STEAL_STRING(cifs_sb, ctx, username);
1045
1046 if (need_recon == false)
1047 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password);
1048 else {
1049 if (ctx->password) {
1050 new_password = kstrdup(ctx->password, GFP_KERNEL);
1051 if (!new_password)
1052 return -ENOMEM;
1053 } else
1054 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password);
1055 }
1056
1057 /*
1058 * if a new password2 has been specified, then reset it's value
1059 * inside the ses struct
1060 */
1061 if (ctx->password2) {
1062 new_password2 = kstrdup(ctx->password2, GFP_KERNEL);
1063 if (!new_password2) {
1064 kfree_sensitive(new_password);
1065 return -ENOMEM;
1066 }
1067 } else
1068 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password2);
1069
1070 /*
1071 * we may update the passwords in the ses struct below. Make sure we do
1072 * not race with smb2_reconnect
1073 */
1074 mutex_lock(&ses->session_mutex);
1075
1076 /*
1077 * smb2_reconnect may swap password and password2 in case session setup
1078 * failed. First get ctx passwords in sync with ses passwords. It should
1079 * be okay to do this even if this function were to return an error at a
1080 * later stage
1081 */
1082 rc = smb3_sync_session_ctx_passwords(cifs_sb, ses);
1083 if (rc) {
1084 mutex_unlock(&ses->session_mutex);
1085 return rc;
1086 }
1087
1088 /*
1089 * now that allocations for passwords are done, commit them
1090 */
1091 if (new_password) {
1092 kfree_sensitive(ses->password);
1093 ses->password = new_password;
1094 }
1095 if (new_password2) {
1096 kfree_sensitive(ses->password2);
1097 ses->password2 = new_password2;
1098 }
1099
1100 mutex_unlock(&ses->session_mutex);
1101
1102 STEAL_STRING(cifs_sb, ctx, domainname);
1103 STEAL_STRING(cifs_sb, ctx, nodename);
1104 STEAL_STRING(cifs_sb, ctx, iocharset);
1105
1106 /* if rsize or wsize not passed in on remount, use previous values */
1107 ctx->rsize = rsize ? CIFS_ALIGN_RSIZE(fc, rsize) : cifs_sb->ctx->rsize;
1108 ctx->wsize = wsize ? CIFS_ALIGN_WSIZE(fc, wsize) : cifs_sb->ctx->wsize;
1109
1110 smb3_cleanup_fs_context_contents(cifs_sb->ctx);
1111 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx);
1112 smb3_update_mnt_flags(cifs_sb);
1113 #ifdef CONFIG_CIFS_DFS_UPCALL
1114 if (!rc)
1115 rc = dfs_cache_remount_fs(cifs_sb);
1116 #endif
1117
1118 return rc;
1119 }
1120
smb3_fs_context_parse_param(struct fs_context * fc,struct fs_parameter * param)1121 static int smb3_fs_context_parse_param(struct fs_context *fc,
1122 struct fs_parameter *param)
1123 {
1124 struct fs_parse_result result;
1125 struct smb3_fs_context *ctx = smb3_fc2context(fc);
1126 int i, opt;
1127 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3");
1128 bool skip_parsing = false;
1129 char *hostname;
1130
1131 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key);
1132
1133 /*
1134 * fs_parse can not handle string options with an empty value so
1135 * we will need special handling of them.
1136 */
1137 if (param->type == fs_value_is_string && param->string[0] == 0) {
1138 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) {
1139 skip_parsing = true;
1140 opt = Opt_pass;
1141 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) {
1142 skip_parsing = true;
1143 opt = Opt_user;
1144 } else if (!strcmp("pass2", param->key) || !strcmp("password2", param->key)) {
1145 skip_parsing = true;
1146 opt = Opt_pass2;
1147 }
1148 }
1149
1150 if (!skip_parsing) {
1151 opt = fs_parse(fc, smb3_fs_parameters, param, &result);
1152 if (opt < 0)
1153 return ctx->sloppy ? 1 : opt;
1154 }
1155
1156 switch (opt) {
1157 case Opt_compress:
1158 if (!IS_ENABLED(CONFIG_CIFS_COMPRESSION)) {
1159 cifs_errorf(fc, "CONFIG_CIFS_COMPRESSION kernel config option is unset\n");
1160 goto cifs_parse_mount_err;
1161 }
1162 ctx->compress = true;
1163 cifs_dbg(VFS, "SMB3 compression support is experimental\n");
1164 break;
1165 case Opt_nodfs:
1166 ctx->nodfs = 1;
1167 break;
1168 case Opt_hard:
1169 if (result.negated) {
1170 if (ctx->retry == 1)
1171 cifs_dbg(VFS, "conflicting hard vs. soft mount options\n");
1172 ctx->retry = 0;
1173 } else
1174 ctx->retry = 1;
1175 break;
1176 case Opt_soft:
1177 if (result.negated)
1178 ctx->retry = 1;
1179 else {
1180 if (ctx->retry == 1)
1181 cifs_dbg(VFS, "conflicting hard vs soft mount options\n");
1182 ctx->retry = 0;
1183 }
1184 break;
1185 case Opt_mapposix:
1186 if (result.negated)
1187 ctx->remap = false;
1188 else {
1189 ctx->remap = true;
1190 ctx->sfu_remap = false; /* disable SFU mapping */
1191 }
1192 break;
1193 case Opt_mapchars:
1194 if (result.negated)
1195 ctx->sfu_remap = false;
1196 else {
1197 ctx->sfu_remap = true;
1198 ctx->remap = false; /* disable SFM (mapposix) mapping */
1199 }
1200 break;
1201 case Opt_user_xattr:
1202 if (result.negated)
1203 ctx->no_xattr = 1;
1204 else
1205 ctx->no_xattr = 0;
1206 break;
1207 case Opt_forceuid:
1208 if (result.negated)
1209 ctx->override_uid = 0;
1210 else
1211 ctx->override_uid = 1;
1212 ctx->forceuid_specified = true;
1213 break;
1214 case Opt_forcegid:
1215 if (result.negated)
1216 ctx->override_gid = 0;
1217 else
1218 ctx->override_gid = 1;
1219 ctx->forcegid_specified = true;
1220 break;
1221 case Opt_perm:
1222 if (result.negated)
1223 ctx->noperm = 1;
1224 else
1225 ctx->noperm = 0;
1226 break;
1227 case Opt_dynperm:
1228 if (result.negated)
1229 ctx->dynperm = 0;
1230 else
1231 ctx->dynperm = 1;
1232 break;
1233 case Opt_sfu:
1234 if (result.negated)
1235 ctx->sfu_emul = 0;
1236 else
1237 ctx->sfu_emul = 1;
1238 break;
1239 case Opt_noblocksend:
1240 ctx->noblocksnd = 1;
1241 break;
1242 case Opt_noautotune:
1243 ctx->noautotune = 1;
1244 break;
1245 case Opt_nolease:
1246 ctx->no_lease = 1;
1247 break;
1248 case Opt_nosparse:
1249 ctx->no_sparse = 1;
1250 break;
1251 case Opt_nodelete:
1252 ctx->nodelete = 1;
1253 break;
1254 case Opt_multichannel:
1255 if (result.negated) {
1256 ctx->multichannel = false;
1257 ctx->max_channels = 1;
1258 } else {
1259 ctx->multichannel = true;
1260 /* if number of channels not specified, default to 2 */
1261 if (ctx->max_channels < 2)
1262 ctx->max_channels = 2;
1263 }
1264 break;
1265 case Opt_uid:
1266 ctx->linux_uid = result.uid;
1267 ctx->uid_specified = true;
1268 break;
1269 case Opt_cruid:
1270 ctx->cred_uid = result.uid;
1271 ctx->cruid_specified = true;
1272 break;
1273 case Opt_backupuid:
1274 ctx->backupuid = result.uid;
1275 ctx->backupuid_specified = true;
1276 break;
1277 case Opt_backupgid:
1278 ctx->backupgid = result.gid;
1279 ctx->backupgid_specified = true;
1280 break;
1281 case Opt_gid:
1282 ctx->linux_gid = result.gid;
1283 ctx->gid_specified = true;
1284 break;
1285 case Opt_port:
1286 ctx->port = result.uint_32;
1287 break;
1288 case Opt_file_mode:
1289 ctx->file_mode = result.uint_32;
1290 break;
1291 case Opt_dirmode:
1292 ctx->dir_mode = result.uint_32;
1293 break;
1294 case Opt_min_enc_offload:
1295 ctx->min_offload = result.uint_32;
1296 break;
1297 case Opt_retrans:
1298 ctx->retrans = result.uint_32;
1299 break;
1300 case Opt_blocksize:
1301 /*
1302 * inode blocksize realistically should never need to be
1303 * less than 16K or greater than 16M and default is 1MB.
1304 * Note that small inode block sizes (e.g. 64K) can lead
1305 * to very poor performance of common tools like cp and scp
1306 */
1307 if ((result.uint_32 < CIFS_MAX_MSGSIZE) ||
1308 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) {
1309 cifs_errorf(fc, "%s: Invalid blocksize\n",
1310 __func__);
1311 goto cifs_parse_mount_err;
1312 }
1313 ctx->bsize = CIFS_ALIGN_BSIZE(fc, result.uint_32);
1314 ctx->got_bsize = true;
1315 break;
1316 case Opt_rasize:
1317 /*
1318 * readahead size realistically should never need to be
1319 * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M
1320 * (perhaps an exception should be considered in the
1321 * for the case of a large number of channels
1322 * when multichannel is negotiated) since that would lead
1323 * to plenty of parallel I/O in flight to the server.
1324 * Note that smaller read ahead sizes would
1325 * hurt performance of common tools like cp and scp
1326 * which often trigger sequential i/o with read ahead
1327 */
1328 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) ||
1329 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) {
1330 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n",
1331 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE);
1332 goto cifs_parse_mount_err;
1333 }
1334 ctx->rasize = result.uint_32;
1335 break;
1336 case Opt_rsize:
1337 ctx->rsize = CIFS_ALIGN_RSIZE(fc, result.uint_32);
1338 ctx->got_rsize = true;
1339 ctx->vol_rsize = ctx->rsize;
1340 break;
1341 case Opt_wsize:
1342 ctx->wsize = CIFS_ALIGN_WSIZE(fc, result.uint_32);
1343 ctx->got_wsize = true;
1344 ctx->vol_wsize = ctx->wsize;
1345 break;
1346 case Opt_acregmax:
1347 if (result.uint_32 > CIFS_MAX_ACTIMEO / HZ) {
1348 cifs_errorf(fc, "acregmax too large\n");
1349 goto cifs_parse_mount_err;
1350 }
1351 ctx->acregmax = HZ * result.uint_32;
1352 break;
1353 case Opt_acdirmax:
1354 if (result.uint_32 > CIFS_MAX_ACTIMEO / HZ) {
1355 cifs_errorf(fc, "acdirmax too large\n");
1356 goto cifs_parse_mount_err;
1357 }
1358 ctx->acdirmax = HZ * result.uint_32;
1359 break;
1360 case Opt_actimeo:
1361 if (result.uint_32 > CIFS_MAX_ACTIMEO / HZ) {
1362 cifs_errorf(fc, "timeout too large\n");
1363 goto cifs_parse_mount_err;
1364 }
1365 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) ||
1366 (ctx->acregmax != CIFS_DEF_ACTIMEO)) {
1367 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n");
1368 break;
1369 }
1370 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32;
1371 break;
1372 case Opt_closetimeo:
1373 if (result.uint_32 > SMB3_MAX_DCLOSETIMEO / HZ) {
1374 cifs_errorf(fc, "closetimeo too large\n");
1375 goto cifs_parse_mount_err;
1376 }
1377 ctx->closetimeo = HZ * result.uint_32;
1378 break;
1379 case Opt_echo_interval:
1380 if (result.uint_32 < SMB_ECHO_INTERVAL_MIN ||
1381 result.uint_32 > SMB_ECHO_INTERVAL_MAX) {
1382 cifs_errorf(fc, "echo interval is out of bounds\n");
1383 goto cifs_parse_mount_err;
1384 }
1385 ctx->echo_interval = result.uint_32;
1386 break;
1387 case Opt_snapshot:
1388 ctx->snapshot_time = result.uint_64;
1389 break;
1390 case Opt_max_credits:
1391 if (result.uint_32 < 20 || result.uint_32 > 60000) {
1392 cifs_errorf(fc, "%s: Invalid max_credits value\n",
1393 __func__);
1394 goto cifs_parse_mount_err;
1395 }
1396 ctx->max_credits = result.uint_32;
1397 break;
1398 case Opt_max_channels:
1399 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) {
1400 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n",
1401 __func__, CIFS_MAX_CHANNELS);
1402 goto cifs_parse_mount_err;
1403 }
1404 ctx->max_channels = result.uint_32;
1405 /* If more than one channel requested ... they want multichan */
1406 if (result.uint_32 > 1)
1407 ctx->multichannel = true;
1408 break;
1409 case Opt_max_cached_dirs:
1410 if (result.uint_32 < 1) {
1411 cifs_errorf(fc, "%s: Invalid max_cached_dirs, needs to be 1 or more\n",
1412 __func__);
1413 goto cifs_parse_mount_err;
1414 }
1415 ctx->max_cached_dirs = result.uint_32;
1416 break;
1417 case Opt_handletimeout:
1418 ctx->handle_timeout = result.uint_32;
1419 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
1420 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n");
1421 goto cifs_parse_mount_err;
1422 }
1423 break;
1424 case Opt_source:
1425 kfree(ctx->UNC);
1426 ctx->UNC = NULL;
1427 switch (smb3_parse_devname(param->string, ctx)) {
1428 case 0:
1429 break;
1430 case -ENOMEM:
1431 cifs_errorf(fc, "Unable to allocate memory for devname\n");
1432 goto cifs_parse_mount_err;
1433 case -EINVAL:
1434 cifs_errorf(fc, "Malformed UNC in devname\n");
1435 goto cifs_parse_mount_err;
1436 default:
1437 cifs_errorf(fc, "Unknown error parsing devname\n");
1438 goto cifs_parse_mount_err;
1439 }
1440 ctx->source = smb3_fs_context_fullpath(ctx, '/');
1441 if (IS_ERR(ctx->source)) {
1442 ctx->source = NULL;
1443 cifs_errorf(fc, "OOM when copying UNC string\n");
1444 goto cifs_parse_mount_err;
1445 }
1446 fc->source = kstrdup(ctx->source, GFP_KERNEL);
1447 if (fc->source == NULL) {
1448 cifs_errorf(fc, "OOM when copying UNC string\n");
1449 goto cifs_parse_mount_err;
1450 }
1451 hostname = extract_hostname(ctx->UNC);
1452 if (IS_ERR(hostname)) {
1453 cifs_errorf(fc, "Cannot extract hostname from UNC string\n");
1454 goto cifs_parse_mount_err;
1455 }
1456 /* last byte, type, is 0x20 for servr type */
1457 memset(ctx->target_rfc1001_name, 0x20, RFC1001_NAME_LEN_WITH_NULL);
1458 for (i = 0; i < RFC1001_NAME_LEN && hostname[i] != 0; i++)
1459 ctx->target_rfc1001_name[i] = toupper(hostname[i]);
1460 kfree(hostname);
1461 break;
1462 case Opt_user:
1463 kfree(ctx->username);
1464 ctx->username = NULL;
1465 if (ctx->nullauth)
1466 break;
1467 if (strlen(param->string) == 0) {
1468 /* null user, ie. anonymous authentication */
1469 ctx->nullauth = 1;
1470 break;
1471 }
1472
1473 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) >
1474 CIFS_MAX_USERNAME_LEN) {
1475 pr_warn("username too long\n");
1476 goto cifs_parse_mount_err;
1477 }
1478 ctx->username = kstrdup(param->string, GFP_KERNEL);
1479 if (ctx->username == NULL) {
1480 cifs_errorf(fc, "OOM when copying username string\n");
1481 goto cifs_parse_mount_err;
1482 }
1483 break;
1484 case Opt_pass:
1485 kfree_sensitive(ctx->password);
1486 ctx->password = NULL;
1487 if (strlen(param->string) == 0)
1488 break;
1489
1490 ctx->password = kstrdup(param->string, GFP_KERNEL);
1491 if (ctx->password == NULL) {
1492 cifs_errorf(fc, "OOM when copying password string\n");
1493 goto cifs_parse_mount_err;
1494 }
1495 break;
1496 case Opt_pass2:
1497 kfree_sensitive(ctx->password2);
1498 ctx->password2 = NULL;
1499 if (strlen(param->string) == 0)
1500 break;
1501
1502 ctx->password2 = kstrdup(param->string, GFP_KERNEL);
1503 if (ctx->password2 == NULL) {
1504 cifs_errorf(fc, "OOM when copying password2 string\n");
1505 goto cifs_parse_mount_err;
1506 }
1507 break;
1508 case Opt_ip:
1509 if (strlen(param->string) == 0) {
1510 ctx->got_ip = false;
1511 break;
1512 }
1513 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr,
1514 param->string,
1515 strlen(param->string))) {
1516 pr_err("bad ip= option (%s)\n", param->string);
1517 goto cifs_parse_mount_err;
1518 }
1519 ctx->got_ip = true;
1520 break;
1521 case Opt_domain:
1522 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN)
1523 == CIFS_MAX_DOMAINNAME_LEN) {
1524 pr_warn("domain name too long\n");
1525 goto cifs_parse_mount_err;
1526 }
1527
1528 kfree(ctx->domainname);
1529 ctx->domainname = kstrdup(param->string, GFP_KERNEL);
1530 if (ctx->domainname == NULL) {
1531 cifs_errorf(fc, "OOM when copying domainname string\n");
1532 goto cifs_parse_mount_err;
1533 }
1534 cifs_dbg(FYI, "Domain name set\n");
1535 break;
1536 case Opt_srcaddr:
1537 if (!cifs_convert_address(
1538 (struct sockaddr *)&ctx->srcaddr,
1539 param->string, strlen(param->string))) {
1540 pr_warn("Could not parse srcaddr: %s\n",
1541 param->string);
1542 goto cifs_parse_mount_err;
1543 }
1544 break;
1545 case Opt_iocharset:
1546 if (strnlen(param->string, 1024) >= 65) {
1547 pr_warn("iocharset name too long\n");
1548 goto cifs_parse_mount_err;
1549 }
1550
1551 if (strncasecmp(param->string, "default", 7) != 0) {
1552 kfree(ctx->iocharset);
1553 ctx->iocharset = kstrdup(param->string, GFP_KERNEL);
1554 if (ctx->iocharset == NULL) {
1555 cifs_errorf(fc, "OOM when copying iocharset string\n");
1556 goto cifs_parse_mount_err;
1557 }
1558 }
1559 /* if iocharset not set then load_nls_default
1560 * is used by caller
1561 */
1562 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset);
1563 break;
1564 case Opt_netbiosname:
1565 memset(ctx->source_rfc1001_name, 0x20,
1566 RFC1001_NAME_LEN);
1567 /*
1568 * FIXME: are there cases in which a comma can
1569 * be valid in workstation netbios name (and
1570 * need special handling)?
1571 */
1572 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1573 /* don't ucase netbiosname for user */
1574 if (param->string[i] == 0)
1575 break;
1576 ctx->source_rfc1001_name[i] = param->string[i];
1577 }
1578 /* The string has 16th byte zero still from
1579 * set at top of the function
1580 */
1581 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1582 pr_warn("netbiosname longer than 15 truncated\n");
1583 break;
1584 case Opt_servern:
1585 /* last byte, type, is 0x20 for servr type */
1586 memset(ctx->target_rfc1001_name, 0x20,
1587 RFC1001_NAME_LEN_WITH_NULL);
1588 /*
1589 * BB are there cases in which a comma can be valid in this
1590 * workstation netbios name (and need special handling)?
1591 */
1592
1593 /* user or mount helper must uppercase the netbios name */
1594 for (i = 0; i < 15; i++) {
1595 if (param->string[i] == 0)
1596 break;
1597 ctx->target_rfc1001_name[i] = param->string[i];
1598 }
1599
1600 /* The string has 16th byte zero still from set at top of function */
1601 if (i == RFC1001_NAME_LEN && param->string[i] != 0)
1602 pr_warn("server netbiosname longer than 15 truncated\n");
1603 break;
1604 case Opt_nbsessinit:
1605 ctx->rfc1001_sessinit = !result.negated;
1606 cifs_dbg(FYI, "rfc1001_sessinit set to %d\n", ctx->rfc1001_sessinit);
1607 break;
1608 case Opt_ver:
1609 /* version of mount userspace tools, not dialect */
1610 /* If interface changes in mount.cifs bump to new ver */
1611 if (strncasecmp(param->string, "1", 1) == 0) {
1612 if (strlen(param->string) > 1) {
1613 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n",
1614 param->string);
1615 goto cifs_parse_mount_err;
1616 }
1617 /* This is the default */
1618 break;
1619 }
1620 /* For all other value, error */
1621 pr_warn("Invalid mount helper version specified\n");
1622 goto cifs_parse_mount_err;
1623 case Opt_vers:
1624 /* protocol version (dialect) */
1625 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0)
1626 goto cifs_parse_mount_err;
1627 ctx->got_version = true;
1628 break;
1629 case Opt_sec:
1630 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0)
1631 goto cifs_parse_mount_err;
1632 break;
1633 case Opt_upcalltarget:
1634 if (cifs_parse_upcall_target(fc, param->string, ctx) != 0)
1635 goto cifs_parse_mount_err;
1636 break;
1637 case Opt_cache:
1638 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0)
1639 goto cifs_parse_mount_err;
1640 break;
1641 case Opt_witness:
1642 #ifndef CONFIG_CIFS_SWN_UPCALL
1643 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n");
1644 goto cifs_parse_mount_err;
1645 #endif
1646 ctx->witness = true;
1647 pr_warn_once("Witness protocol support is experimental\n");
1648 break;
1649 case Opt_unicode:
1650 ctx->unicode = !result.negated;
1651 cifs_dbg(FYI, "unicode set to %d\n", ctx->unicode);
1652 break;
1653 case Opt_rootfs:
1654 #ifndef CONFIG_CIFS_ROOT
1655 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n");
1656 goto cifs_parse_mount_err;
1657 #endif
1658 ctx->rootfs = true;
1659 break;
1660 case Opt_posixpaths:
1661 if (result.negated)
1662 ctx->posix_paths = 0;
1663 else
1664 ctx->posix_paths = 1;
1665 break;
1666 case Opt_unix:
1667 if (result.negated) {
1668 if (ctx->linux_ext == 1)
1669 pr_warn_once("conflicting posix mount options specified\n");
1670 ctx->linux_ext = 0;
1671 ctx->no_linux_ext = 1;
1672 } else {
1673 if (ctx->no_linux_ext == 1)
1674 pr_warn_once("conflicting posix mount options specified\n");
1675 ctx->linux_ext = 1;
1676 ctx->no_linux_ext = 0;
1677 }
1678 break;
1679 case Opt_nocase:
1680 ctx->nocase = 1;
1681 break;
1682 case Opt_brl:
1683 if (result.negated) {
1684 /*
1685 * turn off mandatory locking in mode
1686 * if remote locking is turned off since the
1687 * local vfs will do advisory
1688 */
1689 if (ctx->file_mode ==
1690 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1691 ctx->file_mode = S_IALLUGO;
1692 ctx->nobrl = 1;
1693 } else
1694 ctx->nobrl = 0;
1695 break;
1696 case Opt_handlecache:
1697 if (result.negated)
1698 ctx->nohandlecache = 1;
1699 else
1700 ctx->nohandlecache = 0;
1701 break;
1702 case Opt_forcemandatorylock:
1703 ctx->mand_lock = 1;
1704 break;
1705 case Opt_setuids:
1706 ctx->setuids = result.negated;
1707 break;
1708 case Opt_intr:
1709 ctx->intr = !result.negated;
1710 break;
1711 case Opt_setuidfromacl:
1712 ctx->setuidfromacl = 1;
1713 break;
1714 case Opt_strictsync:
1715 ctx->nostrictsync = result.negated;
1716 break;
1717 case Opt_serverino:
1718 ctx->server_ino = !result.negated;
1719 break;
1720 case Opt_rwpidforward:
1721 ctx->rwpidforward = 1;
1722 break;
1723 case Opt_modesid:
1724 ctx->mode_ace = 1;
1725 break;
1726 case Opt_cifsacl:
1727 ctx->cifs_acl = !result.negated;
1728 break;
1729 case Opt_acl:
1730 ctx->no_psx_acl = result.negated;
1731 break;
1732 case Opt_locallease:
1733 ctx->local_lease = 1;
1734 break;
1735 case Opt_sign:
1736 ctx->sign = true;
1737 break;
1738 case Opt_ignore_signature:
1739 ctx->sign = true;
1740 ctx->ignore_signature = true;
1741 break;
1742 case Opt_seal:
1743 /* we do not do the following in secFlags because seal
1744 * is a per tree connection (mount) not a per socket
1745 * or per-smb connection option in the protocol
1746 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1747 */
1748 ctx->seal = 1;
1749 break;
1750 case Opt_noac:
1751 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1752 break;
1753 case Opt_fsc:
1754 #ifndef CONFIG_CIFS_FSCACHE
1755 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1756 goto cifs_parse_mount_err;
1757 #endif
1758 ctx->fsc = true;
1759 break;
1760 case Opt_mfsymlinks:
1761 ctx->mfsymlinks = true;
1762 break;
1763 case Opt_multiuser:
1764 ctx->multiuser = true;
1765 break;
1766 case Opt_sloppy:
1767 ctx->sloppy = true;
1768 break;
1769 case Opt_nosharesock:
1770 ctx->nosharesock = true;
1771 break;
1772 case Opt_persistent:
1773 if (result.negated) {
1774 ctx->nopersistent = true;
1775 if (ctx->persistent) {
1776 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1777 goto cifs_parse_mount_err;
1778 }
1779 } else {
1780 ctx->persistent = true;
1781 if ((ctx->nopersistent) || (ctx->resilient)) {
1782 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1783 goto cifs_parse_mount_err;
1784 }
1785 }
1786 break;
1787 case Opt_resilient:
1788 if (result.negated) {
1789 ctx->resilient = false; /* already the default */
1790 } else {
1791 ctx->resilient = true;
1792 if (ctx->persistent) {
1793 cifs_errorf(fc, "persistenthandles mount options conflict\n");
1794 goto cifs_parse_mount_err;
1795 }
1796 }
1797 break;
1798 case Opt_tcp_nodelay:
1799 /* tcp nodelay should not usually be needed since we CORK/UNCORK the socket */
1800 if (result.negated)
1801 ctx->sockopt_tcp_nodelay = false;
1802 else
1803 ctx->sockopt_tcp_nodelay = true;
1804 break;
1805 case Opt_domainauto:
1806 ctx->domainauto = true;
1807 break;
1808 case Opt_rdma:
1809 ctx->rdma = true;
1810 break;
1811 case Opt_reparse:
1812 if (parse_reparse_flavor(fc, param->string, ctx))
1813 goto cifs_parse_mount_err;
1814 break;
1815 case Opt_nativesocket:
1816 ctx->nonativesocket = result.negated;
1817 break;
1818 case Opt_symlink:
1819 if (parse_symlink_flavor(fc, param->string, ctx))
1820 goto cifs_parse_mount_err;
1821 break;
1822 case Opt_symlinkroot:
1823 if (param->string[0] != '/') {
1824 cifs_errorf(fc, "symlinkroot mount options must be absolute path\n");
1825 goto cifs_parse_mount_err;
1826 }
1827 kfree(ctx->symlinkroot);
1828 ctx->symlinkroot = kstrdup(param->string, GFP_KERNEL);
1829 if (!ctx->symlinkroot)
1830 goto cifs_parse_mount_err;
1831 break;
1832 }
1833 /* case Opt_ignore: - is ignored as expected ... */
1834
1835 if (ctx->multiuser && ctx->upcall_target == UPTARGET_MOUNT) {
1836 cifs_errorf(fc, "multiuser mount option not supported with upcalltarget set as 'mount'\n");
1837 goto cifs_parse_mount_err;
1838 }
1839
1840 /*
1841 * By default resolve all native absolute symlinks relative to "/mnt/".
1842 * Same default has drvfs driver running in WSL for resolving SMB shares.
1843 */
1844 if (!ctx->symlinkroot)
1845 ctx->symlinkroot = kstrdup("/mnt/", GFP_KERNEL);
1846
1847 return 0;
1848
1849 cifs_parse_mount_err:
1850 kfree_sensitive(ctx->password);
1851 ctx->password = NULL;
1852 kfree_sensitive(ctx->password2);
1853 ctx->password2 = NULL;
1854 return -EINVAL;
1855 }
1856
get_cifs_symlink_type(struct cifs_sb_info * cifs_sb)1857 enum cifs_symlink_type get_cifs_symlink_type(struct cifs_sb_info *cifs_sb)
1858 {
1859 if (cifs_sb->ctx->symlink_type == CIFS_SYMLINK_TYPE_DEFAULT) {
1860 if (cifs_sb->ctx->mfsymlinks)
1861 return CIFS_SYMLINK_TYPE_MFSYMLINKS;
1862 else if (cifs_sb->ctx->sfu_emul)
1863 return CIFS_SYMLINK_TYPE_SFU;
1864 else if (cifs_sb->ctx->linux_ext && !cifs_sb->ctx->no_linux_ext)
1865 return CIFS_SYMLINK_TYPE_UNIX;
1866 else if (cifs_sb->ctx->reparse_type != CIFS_REPARSE_TYPE_NONE)
1867 return CIFS_SYMLINK_TYPE_NATIVE;
1868 else
1869 return CIFS_SYMLINK_TYPE_NONE;
1870 } else {
1871 return cifs_sb->ctx->symlink_type;
1872 }
1873 }
1874
smb3_init_fs_context(struct fs_context * fc)1875 int smb3_init_fs_context(struct fs_context *fc)
1876 {
1877 struct smb3_fs_context *ctx;
1878 char *nodename = utsname()->nodename;
1879 int i;
1880
1881 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL);
1882 if (unlikely(!ctx))
1883 return -ENOMEM;
1884
1885 strscpy(ctx->workstation_name, nodename, sizeof(ctx->workstation_name));
1886
1887 /*
1888 * does not have to be perfect mapping since field is
1889 * informational, only used for servers that do not support
1890 * port 445 and it can be overridden at mount time
1891 */
1892 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1893 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1894 ctx->source_rfc1001_name[i] = toupper(nodename[i]);
1895 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1896
1897 /*
1898 * null target name indicates to use *SMBSERVR default called name
1899 * if we end up sending RFC1001 session initialize
1900 */
1901 ctx->target_rfc1001_name[0] = 0;
1902
1903 ctx->rfc1001_sessinit = -1; /* autodetect based on port number */
1904
1905 ctx->cred_uid = current_uid();
1906 ctx->linux_uid = current_uid();
1907 ctx->linux_gid = current_gid();
1908 /* By default 4MB read ahead size, 1MB block size */
1909 ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */
1910 ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */
1911
1912 /*
1913 * default to SFM style remapping of seven reserved characters
1914 * unless user overrides it or we negotiate CIFS POSIX where
1915 * it is unnecessary. Can not simultaneously use more than one mapping
1916 * since then readdir could list files that open could not open
1917 */
1918 ctx->remap = true;
1919
1920 /* default to only allowing write access to owner of the mount */
1921 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1922
1923 /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1924 /* default is always to request posix paths. */
1925 ctx->posix_paths = 1;
1926 /* default to using server inode numbers where available */
1927 ctx->server_ino = 1;
1928
1929 /* default is to use strict cifs caching semantics */
1930 ctx->strict_io = true;
1931
1932 ctx->acregmax = CIFS_DEF_ACTIMEO;
1933 ctx->acdirmax = CIFS_DEF_ACTIMEO;
1934 ctx->closetimeo = SMB3_DEF_DCLOSETIMEO;
1935 ctx->max_cached_dirs = MAX_CACHED_FIDS;
1936 /* Most clients set timeout to 0, allows server to use its default */
1937 ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1938
1939 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1940 ctx->ops = &smb30_operations;
1941 ctx->vals = &smbdefault_values;
1942
1943 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1944
1945 /* default to no multichannel (single server connection) */
1946 ctx->multichannel = false;
1947 ctx->max_channels = 1;
1948
1949 ctx->backupuid_specified = false; /* no backup intent for a user */
1950 ctx->backupgid_specified = false; /* no backup intent for a group */
1951
1952 ctx->retrans = 1;
1953 ctx->reparse_type = CIFS_REPARSE_TYPE_DEFAULT;
1954 ctx->symlink_type = CIFS_SYMLINK_TYPE_DEFAULT;
1955 ctx->nonativesocket = 0;
1956
1957 ctx->unicode = -1; /* autodetect, but prefer UNICODE mode */
1958
1959 /*
1960 * short int override_uid = -1;
1961 * short int override_gid = -1;
1962 * char *nodename = strdup(utsname()->nodename);
1963 * struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1964 */
1965
1966 fc->fs_private = ctx;
1967 fc->ops = &smb3_fs_context_ops;
1968 return 0;
1969 }
1970
1971 void
smb3_cleanup_fs_context_contents(struct smb3_fs_context * ctx)1972 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx)
1973 {
1974 if (ctx == NULL)
1975 return;
1976
1977 /*
1978 * Make sure this stays in sync with smb3_fs_context_dup()
1979 */
1980 kfree(ctx->username);
1981 ctx->username = NULL;
1982 kfree_sensitive(ctx->password);
1983 ctx->password = NULL;
1984 kfree_sensitive(ctx->password2);
1985 ctx->password2 = NULL;
1986 kfree(ctx->server_hostname);
1987 ctx->server_hostname = NULL;
1988 kfree(ctx->UNC);
1989 ctx->UNC = NULL;
1990 kfree(ctx->source);
1991 ctx->source = NULL;
1992 kfree(ctx->domainname);
1993 ctx->domainname = NULL;
1994 kfree(ctx->nodename);
1995 ctx->nodename = NULL;
1996 kfree(ctx->iocharset);
1997 ctx->iocharset = NULL;
1998 kfree(ctx->prepath);
1999 ctx->prepath = NULL;
2000 kfree(ctx->leaf_fullpath);
2001 ctx->leaf_fullpath = NULL;
2002 kfree(ctx->dns_dom);
2003 ctx->dns_dom = NULL;
2004 kfree(ctx->symlinkroot);
2005 ctx->symlinkroot = NULL;
2006 }
2007
2008 void
smb3_cleanup_fs_context(struct smb3_fs_context * ctx)2009 smb3_cleanup_fs_context(struct smb3_fs_context *ctx)
2010 {
2011 if (!ctx)
2012 return;
2013 smb3_cleanup_fs_context_contents(ctx);
2014 kfree(ctx);
2015 }
2016
smb3_update_mnt_flags(struct cifs_sb_info * cifs_sb)2017 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb)
2018 {
2019 struct smb3_fs_context *ctx = cifs_sb->ctx;
2020
2021 if (ctx->nodfs)
2022 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
2023 else
2024 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS;
2025
2026 if (ctx->noperm)
2027 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2028 else
2029 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM;
2030
2031 if (ctx->setuids)
2032 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2033 else
2034 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID;
2035
2036 if (ctx->setuidfromacl)
2037 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
2038 else
2039 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL;
2040
2041 if (ctx->server_ino)
2042 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2043 else
2044 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM;
2045
2046 if (ctx->remap)
2047 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
2048 else
2049 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR;
2050
2051 if (ctx->sfu_remap)
2052 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2053 else
2054 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR;
2055
2056 if (ctx->no_xattr)
2057 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2058 else
2059 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR;
2060
2061 if (ctx->sfu_emul)
2062 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2063 else
2064 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL;
2065
2066 if (ctx->nobrl)
2067 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2068 else
2069 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL;
2070
2071 if (ctx->nohandlecache)
2072 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
2073 else
2074 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE;
2075
2076 if (ctx->nostrictsync)
2077 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2078 else
2079 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC;
2080
2081 if (ctx->mand_lock)
2082 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2083 else
2084 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL;
2085
2086 if (ctx->rwpidforward)
2087 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
2088 else
2089 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD;
2090
2091 if (ctx->mode_ace)
2092 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
2093 else
2094 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID;
2095
2096 if (ctx->cifs_acl)
2097 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2098 else
2099 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL;
2100
2101 if (ctx->backupuid_specified)
2102 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
2103 else
2104 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID;
2105
2106 if (ctx->backupgid_specified)
2107 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
2108 else
2109 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID;
2110
2111 if (ctx->override_uid)
2112 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2113 else
2114 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID;
2115
2116 if (ctx->override_gid)
2117 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2118 else
2119 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID;
2120
2121 if (ctx->dynperm)
2122 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2123 else
2124 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM;
2125
2126 if (ctx->fsc)
2127 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2128 else
2129 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE;
2130
2131 if (ctx->multiuser)
2132 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2133 CIFS_MOUNT_NO_PERM);
2134 else
2135 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER;
2136
2137
2138 if (ctx->strict_io)
2139 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2140 else
2141 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO;
2142
2143 if (ctx->direct_io)
2144 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2145 else
2146 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO;
2147
2148 if (ctx->mfsymlinks)
2149 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2150 else
2151 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS;
2152 if (ctx->mfsymlinks) {
2153 if (ctx->sfu_emul) {
2154 /*
2155 * Our SFU ("Services for Unix") emulation allows now
2156 * creating new and reading existing SFU symlinks.
2157 * Older Linux kernel versions were not able to neither
2158 * read existing nor create new SFU symlinks. But
2159 * creating and reading SFU style mknod and FIFOs was
2160 * supported for long time. When "mfsymlinks" and
2161 * "sfu" are both enabled at the same time, it allows
2162 * reading both types of symlinks, but will only create
2163 * them with mfsymlinks format. This allows better
2164 * Apple compatibility, compatibility with older Linux
2165 * kernel clients (probably better for Samba too)
2166 * while still recognizing old Windows style symlinks.
2167 */
2168 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
2169 }
2170 }
2171 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN;
2172
2173 return;
2174 }
2175