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 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 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 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 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 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 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 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 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) == '\\') 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 */ 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 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 */ 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 */ 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 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 */ 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 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 */ 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 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 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 char *new_password = NULL, *new_password2 = NULL; 1025 bool need_recon = false; 1026 int rc; 1027 1028 if (ses->expired_pwd) 1029 need_recon = true; 1030 1031 rc = smb3_verify_reconfigure_ctx(fc, ctx, cifs_sb->ctx, need_recon); 1032 if (rc) 1033 return rc; 1034 1035 /* 1036 * We can not change UNC/username/password/domainname/ 1037 * workstation_name/nodename/iocharset 1038 * during reconnect so ignore what we have in the new context and 1039 * just use what we already have in cifs_sb->ctx. 1040 */ 1041 STEAL_STRING(cifs_sb, ctx, UNC); 1042 STEAL_STRING(cifs_sb, ctx, source); 1043 STEAL_STRING(cifs_sb, ctx, username); 1044 1045 if (need_recon == false) 1046 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password); 1047 else { 1048 if (ctx->password) { 1049 new_password = kstrdup(ctx->password, GFP_KERNEL); 1050 if (!new_password) 1051 return -ENOMEM; 1052 } else 1053 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password); 1054 } 1055 1056 /* 1057 * if a new password2 has been specified, then reset it's value 1058 * inside the ses struct 1059 */ 1060 if (ctx->password2) { 1061 new_password2 = kstrdup(ctx->password2, GFP_KERNEL); 1062 if (!new_password2) { 1063 kfree_sensitive(new_password); 1064 return -ENOMEM; 1065 } 1066 } else 1067 STEAL_STRING_SENSITIVE(cifs_sb, ctx, password2); 1068 1069 /* 1070 * we may update the passwords in the ses struct below. Make sure we do 1071 * not race with smb2_reconnect 1072 */ 1073 mutex_lock(&ses->session_mutex); 1074 1075 /* 1076 * smb2_reconnect may swap password and password2 in case session setup 1077 * failed. First get ctx passwords in sync with ses passwords. It should 1078 * be okay to do this even if this function were to return an error at a 1079 * later stage 1080 */ 1081 rc = smb3_sync_session_ctx_passwords(cifs_sb, ses); 1082 if (rc) { 1083 mutex_unlock(&ses->session_mutex); 1084 return rc; 1085 } 1086 1087 /* 1088 * now that allocations for passwords are done, commit them 1089 */ 1090 if (new_password) { 1091 kfree_sensitive(ses->password); 1092 ses->password = new_password; 1093 } 1094 if (new_password2) { 1095 kfree_sensitive(ses->password2); 1096 ses->password2 = new_password2; 1097 } 1098 1099 mutex_unlock(&ses->session_mutex); 1100 1101 STEAL_STRING(cifs_sb, ctx, domainname); 1102 STEAL_STRING(cifs_sb, ctx, nodename); 1103 STEAL_STRING(cifs_sb, ctx, iocharset); 1104 1105 /* if rsize or wsize not passed in on remount, use previous values */ 1106 if (ctx->rsize == 0) 1107 ctx->rsize = cifs_sb->ctx->rsize; 1108 if (ctx->wsize == 0) 1109 ctx->wsize = cifs_sb->ctx->wsize; 1110 1111 1112 smb3_cleanup_fs_context_contents(cifs_sb->ctx); 1113 rc = smb3_fs_context_dup(cifs_sb->ctx, ctx); 1114 smb3_update_mnt_flags(cifs_sb); 1115 #ifdef CONFIG_CIFS_DFS_UPCALL 1116 if (!rc) 1117 rc = dfs_cache_remount_fs(cifs_sb); 1118 #endif 1119 1120 return rc; 1121 } 1122 1123 static int smb3_fs_context_parse_param(struct fs_context *fc, 1124 struct fs_parameter *param) 1125 { 1126 struct fs_parse_result result; 1127 struct smb3_fs_context *ctx = smb3_fc2context(fc); 1128 int i, opt; 1129 bool is_smb3 = !strcmp(fc->fs_type->name, "smb3"); 1130 bool skip_parsing = false; 1131 char *hostname; 1132 1133 cifs_dbg(FYI, "CIFS: parsing cifs mount option '%s'\n", param->key); 1134 1135 /* 1136 * fs_parse can not handle string options with an empty value so 1137 * we will need special handling of them. 1138 */ 1139 if (param->type == fs_value_is_string && param->string[0] == 0) { 1140 if (!strcmp("pass", param->key) || !strcmp("password", param->key)) { 1141 skip_parsing = true; 1142 opt = Opt_pass; 1143 } else if (!strcmp("user", param->key) || !strcmp("username", param->key)) { 1144 skip_parsing = true; 1145 opt = Opt_user; 1146 } else if (!strcmp("pass2", param->key) || !strcmp("password2", param->key)) { 1147 skip_parsing = true; 1148 opt = Opt_pass2; 1149 } 1150 } 1151 1152 if (!skip_parsing) { 1153 opt = fs_parse(fc, smb3_fs_parameters, param, &result); 1154 if (opt < 0) 1155 return ctx->sloppy ? 1 : opt; 1156 } 1157 1158 switch (opt) { 1159 case Opt_compress: 1160 if (!IS_ENABLED(CONFIG_CIFS_COMPRESSION)) { 1161 cifs_errorf(fc, "CONFIG_CIFS_COMPRESSION kernel config option is unset\n"); 1162 goto cifs_parse_mount_err; 1163 } 1164 ctx->compress = true; 1165 cifs_dbg(VFS, "SMB3 compression support is experimental\n"); 1166 break; 1167 case Opt_nodfs: 1168 ctx->nodfs = 1; 1169 break; 1170 case Opt_hard: 1171 if (result.negated) { 1172 if (ctx->retry == 1) 1173 cifs_dbg(VFS, "conflicting hard vs. soft mount options\n"); 1174 ctx->retry = 0; 1175 } else 1176 ctx->retry = 1; 1177 break; 1178 case Opt_soft: 1179 if (result.negated) 1180 ctx->retry = 1; 1181 else { 1182 if (ctx->retry == 1) 1183 cifs_dbg(VFS, "conflicting hard vs soft mount options\n"); 1184 ctx->retry = 0; 1185 } 1186 break; 1187 case Opt_mapposix: 1188 if (result.negated) 1189 ctx->remap = false; 1190 else { 1191 ctx->remap = true; 1192 ctx->sfu_remap = false; /* disable SFU mapping */ 1193 } 1194 break; 1195 case Opt_mapchars: 1196 if (result.negated) 1197 ctx->sfu_remap = false; 1198 else { 1199 ctx->sfu_remap = true; 1200 ctx->remap = false; /* disable SFM (mapposix) mapping */ 1201 } 1202 break; 1203 case Opt_user_xattr: 1204 if (result.negated) 1205 ctx->no_xattr = 1; 1206 else 1207 ctx->no_xattr = 0; 1208 break; 1209 case Opt_forceuid: 1210 if (result.negated) 1211 ctx->override_uid = 0; 1212 else 1213 ctx->override_uid = 1; 1214 ctx->forceuid_specified = true; 1215 break; 1216 case Opt_forcegid: 1217 if (result.negated) 1218 ctx->override_gid = 0; 1219 else 1220 ctx->override_gid = 1; 1221 ctx->forcegid_specified = true; 1222 break; 1223 case Opt_perm: 1224 if (result.negated) 1225 ctx->noperm = 1; 1226 else 1227 ctx->noperm = 0; 1228 break; 1229 case Opt_dynperm: 1230 if (result.negated) 1231 ctx->dynperm = 0; 1232 else 1233 ctx->dynperm = 1; 1234 break; 1235 case Opt_sfu: 1236 if (result.negated) 1237 ctx->sfu_emul = 0; 1238 else 1239 ctx->sfu_emul = 1; 1240 break; 1241 case Opt_noblocksend: 1242 ctx->noblocksnd = 1; 1243 break; 1244 case Opt_noautotune: 1245 ctx->noautotune = 1; 1246 break; 1247 case Opt_nolease: 1248 ctx->no_lease = 1; 1249 break; 1250 case Opt_nosparse: 1251 ctx->no_sparse = 1; 1252 break; 1253 case Opt_nodelete: 1254 ctx->nodelete = 1; 1255 break; 1256 case Opt_multichannel: 1257 if (result.negated) { 1258 ctx->multichannel = false; 1259 ctx->max_channels = 1; 1260 } else { 1261 ctx->multichannel = true; 1262 /* if number of channels not specified, default to 2 */ 1263 if (ctx->max_channels < 2) 1264 ctx->max_channels = 2; 1265 } 1266 break; 1267 case Opt_uid: 1268 ctx->linux_uid = result.uid; 1269 ctx->uid_specified = true; 1270 break; 1271 case Opt_cruid: 1272 ctx->cred_uid = result.uid; 1273 ctx->cruid_specified = true; 1274 break; 1275 case Opt_backupuid: 1276 ctx->backupuid = result.uid; 1277 ctx->backupuid_specified = true; 1278 break; 1279 case Opt_backupgid: 1280 ctx->backupgid = result.gid; 1281 ctx->backupgid_specified = true; 1282 break; 1283 case Opt_gid: 1284 ctx->linux_gid = result.gid; 1285 ctx->gid_specified = true; 1286 break; 1287 case Opt_port: 1288 ctx->port = result.uint_32; 1289 break; 1290 case Opt_file_mode: 1291 ctx->file_mode = result.uint_32; 1292 break; 1293 case Opt_dirmode: 1294 ctx->dir_mode = result.uint_32; 1295 break; 1296 case Opt_min_enc_offload: 1297 ctx->min_offload = result.uint_32; 1298 break; 1299 case Opt_retrans: 1300 ctx->retrans = result.uint_32; 1301 break; 1302 case Opt_blocksize: 1303 /* 1304 * inode blocksize realistically should never need to be 1305 * less than 16K or greater than 16M and default is 1MB. 1306 * Note that small inode block sizes (e.g. 64K) can lead 1307 * to very poor performance of common tools like cp and scp 1308 */ 1309 if ((result.uint_32 < CIFS_MAX_MSGSIZE) || 1310 (result.uint_32 > (4 * SMB3_DEFAULT_IOSIZE))) { 1311 cifs_errorf(fc, "%s: Invalid blocksize\n", 1312 __func__); 1313 goto cifs_parse_mount_err; 1314 } 1315 ctx->bsize = result.uint_32; 1316 ctx->got_bsize = true; 1317 break; 1318 case Opt_rasize: 1319 /* 1320 * readahead size realistically should never need to be 1321 * less than 1M (CIFS_DEFAULT_IOSIZE) or greater than 32M 1322 * (perhaps an exception should be considered in the 1323 * for the case of a large number of channels 1324 * when multichannel is negotiated) since that would lead 1325 * to plenty of parallel I/O in flight to the server. 1326 * Note that smaller read ahead sizes would 1327 * hurt performance of common tools like cp and scp 1328 * which often trigger sequential i/o with read ahead 1329 */ 1330 if ((result.uint_32 > (8 * SMB3_DEFAULT_IOSIZE)) || 1331 (result.uint_32 < CIFS_DEFAULT_IOSIZE)) { 1332 cifs_errorf(fc, "%s: Invalid rasize %d vs. %d\n", 1333 __func__, result.uint_32, SMB3_DEFAULT_IOSIZE); 1334 goto cifs_parse_mount_err; 1335 } 1336 ctx->rasize = result.uint_32; 1337 break; 1338 case Opt_rsize: 1339 ctx->rsize = result.uint_32; 1340 ctx->got_rsize = true; 1341 ctx->vol_rsize = ctx->rsize; 1342 break; 1343 case Opt_wsize: 1344 ctx->wsize = result.uint_32; 1345 ctx->got_wsize = true; 1346 if (ctx->wsize % PAGE_SIZE != 0) { 1347 ctx->wsize = round_down(ctx->wsize, PAGE_SIZE); 1348 if (ctx->wsize == 0) { 1349 ctx->wsize = PAGE_SIZE; 1350 cifs_dbg(VFS, "wsize too small, reset to minimum %ld\n", PAGE_SIZE); 1351 } else { 1352 cifs_dbg(VFS, 1353 "wsize rounded down to %d to multiple of PAGE_SIZE %ld\n", 1354 ctx->wsize, PAGE_SIZE); 1355 } 1356 } 1357 ctx->vol_wsize = ctx->wsize; 1358 break; 1359 case Opt_acregmax: 1360 if (result.uint_32 > CIFS_MAX_ACTIMEO / HZ) { 1361 cifs_errorf(fc, "acregmax too large\n"); 1362 goto cifs_parse_mount_err; 1363 } 1364 ctx->acregmax = HZ * result.uint_32; 1365 break; 1366 case Opt_acdirmax: 1367 if (result.uint_32 > CIFS_MAX_ACTIMEO / HZ) { 1368 cifs_errorf(fc, "acdirmax too large\n"); 1369 goto cifs_parse_mount_err; 1370 } 1371 ctx->acdirmax = HZ * result.uint_32; 1372 break; 1373 case Opt_actimeo: 1374 if (result.uint_32 > CIFS_MAX_ACTIMEO / HZ) { 1375 cifs_errorf(fc, "timeout too large\n"); 1376 goto cifs_parse_mount_err; 1377 } 1378 if ((ctx->acdirmax != CIFS_DEF_ACTIMEO) || 1379 (ctx->acregmax != CIFS_DEF_ACTIMEO)) { 1380 cifs_errorf(fc, "actimeo ignored since acregmax or acdirmax specified\n"); 1381 break; 1382 } 1383 ctx->acdirmax = ctx->acregmax = HZ * result.uint_32; 1384 break; 1385 case Opt_closetimeo: 1386 if (result.uint_32 > SMB3_MAX_DCLOSETIMEO / HZ) { 1387 cifs_errorf(fc, "closetimeo too large\n"); 1388 goto cifs_parse_mount_err; 1389 } 1390 ctx->closetimeo = HZ * result.uint_32; 1391 break; 1392 case Opt_echo_interval: 1393 if (result.uint_32 < SMB_ECHO_INTERVAL_MIN || 1394 result.uint_32 > SMB_ECHO_INTERVAL_MAX) { 1395 cifs_errorf(fc, "echo interval is out of bounds\n"); 1396 goto cifs_parse_mount_err; 1397 } 1398 ctx->echo_interval = result.uint_32; 1399 break; 1400 case Opt_snapshot: 1401 ctx->snapshot_time = result.uint_64; 1402 break; 1403 case Opt_max_credits: 1404 if (result.uint_32 < 20 || result.uint_32 > 60000) { 1405 cifs_errorf(fc, "%s: Invalid max_credits value\n", 1406 __func__); 1407 goto cifs_parse_mount_err; 1408 } 1409 ctx->max_credits = result.uint_32; 1410 break; 1411 case Opt_max_channels: 1412 if (result.uint_32 < 1 || result.uint_32 > CIFS_MAX_CHANNELS) { 1413 cifs_errorf(fc, "%s: Invalid max_channels value, needs to be 1-%d\n", 1414 __func__, CIFS_MAX_CHANNELS); 1415 goto cifs_parse_mount_err; 1416 } 1417 ctx->max_channels = result.uint_32; 1418 /* If more than one channel requested ... they want multichan */ 1419 if (result.uint_32 > 1) 1420 ctx->multichannel = true; 1421 break; 1422 case Opt_max_cached_dirs: 1423 if (result.uint_32 < 1) { 1424 cifs_errorf(fc, "%s: Invalid max_cached_dirs, needs to be 1 or more\n", 1425 __func__); 1426 goto cifs_parse_mount_err; 1427 } 1428 ctx->max_cached_dirs = result.uint_32; 1429 break; 1430 case Opt_handletimeout: 1431 ctx->handle_timeout = result.uint_32; 1432 if (ctx->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) { 1433 cifs_errorf(fc, "Invalid handle cache timeout, longer than 16 minutes\n"); 1434 goto cifs_parse_mount_err; 1435 } 1436 break; 1437 case Opt_source: 1438 kfree(ctx->UNC); 1439 ctx->UNC = NULL; 1440 switch (smb3_parse_devname(param->string, ctx)) { 1441 case 0: 1442 break; 1443 case -ENOMEM: 1444 cifs_errorf(fc, "Unable to allocate memory for devname\n"); 1445 goto cifs_parse_mount_err; 1446 case -EINVAL: 1447 cifs_errorf(fc, "Malformed UNC in devname\n"); 1448 goto cifs_parse_mount_err; 1449 default: 1450 cifs_errorf(fc, "Unknown error parsing devname\n"); 1451 goto cifs_parse_mount_err; 1452 } 1453 ctx->source = smb3_fs_context_fullpath(ctx, '/'); 1454 if (IS_ERR(ctx->source)) { 1455 ctx->source = NULL; 1456 cifs_errorf(fc, "OOM when copying UNC string\n"); 1457 goto cifs_parse_mount_err; 1458 } 1459 fc->source = kstrdup(ctx->source, GFP_KERNEL); 1460 if (fc->source == NULL) { 1461 cifs_errorf(fc, "OOM when copying UNC string\n"); 1462 goto cifs_parse_mount_err; 1463 } 1464 hostname = extract_hostname(ctx->UNC); 1465 if (IS_ERR(hostname)) { 1466 cifs_errorf(fc, "Cannot extract hostname from UNC string\n"); 1467 goto cifs_parse_mount_err; 1468 } 1469 /* last byte, type, is 0x20 for servr type */ 1470 memset(ctx->target_rfc1001_name, 0x20, RFC1001_NAME_LEN_WITH_NULL); 1471 for (i = 0; i < RFC1001_NAME_LEN && hostname[i] != 0; i++) 1472 ctx->target_rfc1001_name[i] = toupper(hostname[i]); 1473 kfree(hostname); 1474 break; 1475 case Opt_user: 1476 kfree(ctx->username); 1477 ctx->username = NULL; 1478 if (ctx->nullauth) 1479 break; 1480 if (strlen(param->string) == 0) { 1481 /* null user, ie. anonymous authentication */ 1482 ctx->nullauth = 1; 1483 break; 1484 } 1485 1486 if (strnlen(param->string, CIFS_MAX_USERNAME_LEN) > 1487 CIFS_MAX_USERNAME_LEN) { 1488 pr_warn("username too long\n"); 1489 goto cifs_parse_mount_err; 1490 } 1491 ctx->username = kstrdup(param->string, GFP_KERNEL); 1492 if (ctx->username == NULL) { 1493 cifs_errorf(fc, "OOM when copying username string\n"); 1494 goto cifs_parse_mount_err; 1495 } 1496 break; 1497 case Opt_pass: 1498 kfree_sensitive(ctx->password); 1499 ctx->password = NULL; 1500 if (strlen(param->string) == 0) 1501 break; 1502 1503 ctx->password = kstrdup(param->string, GFP_KERNEL); 1504 if (ctx->password == NULL) { 1505 cifs_errorf(fc, "OOM when copying password string\n"); 1506 goto cifs_parse_mount_err; 1507 } 1508 break; 1509 case Opt_pass2: 1510 kfree_sensitive(ctx->password2); 1511 ctx->password2 = NULL; 1512 if (strlen(param->string) == 0) 1513 break; 1514 1515 ctx->password2 = kstrdup(param->string, GFP_KERNEL); 1516 if (ctx->password2 == NULL) { 1517 cifs_errorf(fc, "OOM when copying password2 string\n"); 1518 goto cifs_parse_mount_err; 1519 } 1520 break; 1521 case Opt_ip: 1522 if (strlen(param->string) == 0) { 1523 ctx->got_ip = false; 1524 break; 1525 } 1526 if (!cifs_convert_address((struct sockaddr *)&ctx->dstaddr, 1527 param->string, 1528 strlen(param->string))) { 1529 pr_err("bad ip= option (%s)\n", param->string); 1530 goto cifs_parse_mount_err; 1531 } 1532 ctx->got_ip = true; 1533 break; 1534 case Opt_domain: 1535 if (strnlen(param->string, CIFS_MAX_DOMAINNAME_LEN) 1536 == CIFS_MAX_DOMAINNAME_LEN) { 1537 pr_warn("domain name too long\n"); 1538 goto cifs_parse_mount_err; 1539 } 1540 1541 kfree(ctx->domainname); 1542 ctx->domainname = kstrdup(param->string, GFP_KERNEL); 1543 if (ctx->domainname == NULL) { 1544 cifs_errorf(fc, "OOM when copying domainname string\n"); 1545 goto cifs_parse_mount_err; 1546 } 1547 cifs_dbg(FYI, "Domain name set\n"); 1548 break; 1549 case Opt_srcaddr: 1550 if (!cifs_convert_address( 1551 (struct sockaddr *)&ctx->srcaddr, 1552 param->string, strlen(param->string))) { 1553 pr_warn("Could not parse srcaddr: %s\n", 1554 param->string); 1555 goto cifs_parse_mount_err; 1556 } 1557 break; 1558 case Opt_iocharset: 1559 if (strnlen(param->string, 1024) >= 65) { 1560 pr_warn("iocharset name too long\n"); 1561 goto cifs_parse_mount_err; 1562 } 1563 1564 if (strncasecmp(param->string, "default", 7) != 0) { 1565 kfree(ctx->iocharset); 1566 ctx->iocharset = kstrdup(param->string, GFP_KERNEL); 1567 if (ctx->iocharset == NULL) { 1568 cifs_errorf(fc, "OOM when copying iocharset string\n"); 1569 goto cifs_parse_mount_err; 1570 } 1571 } 1572 /* if iocharset not set then load_nls_default 1573 * is used by caller 1574 */ 1575 cifs_dbg(FYI, "iocharset set to %s\n", ctx->iocharset); 1576 break; 1577 case Opt_netbiosname: 1578 memset(ctx->source_rfc1001_name, 0x20, 1579 RFC1001_NAME_LEN); 1580 /* 1581 * FIXME: are there cases in which a comma can 1582 * be valid in workstation netbios name (and 1583 * need special handling)? 1584 */ 1585 for (i = 0; i < RFC1001_NAME_LEN; i++) { 1586 /* don't ucase netbiosname for user */ 1587 if (param->string[i] == 0) 1588 break; 1589 ctx->source_rfc1001_name[i] = param->string[i]; 1590 } 1591 /* The string has 16th byte zero still from 1592 * set at top of the function 1593 */ 1594 if (i == RFC1001_NAME_LEN && param->string[i] != 0) 1595 pr_warn("netbiosname longer than 15 truncated\n"); 1596 break; 1597 case Opt_servern: 1598 /* last byte, type, is 0x20 for servr type */ 1599 memset(ctx->target_rfc1001_name, 0x20, 1600 RFC1001_NAME_LEN_WITH_NULL); 1601 /* 1602 * BB are there cases in which a comma can be valid in this 1603 * workstation netbios name (and need special handling)? 1604 */ 1605 1606 /* user or mount helper must uppercase the netbios name */ 1607 for (i = 0; i < 15; i++) { 1608 if (param->string[i] == 0) 1609 break; 1610 ctx->target_rfc1001_name[i] = param->string[i]; 1611 } 1612 1613 /* The string has 16th byte zero still from set at top of function */ 1614 if (i == RFC1001_NAME_LEN && param->string[i] != 0) 1615 pr_warn("server netbiosname longer than 15 truncated\n"); 1616 break; 1617 case Opt_nbsessinit: 1618 ctx->rfc1001_sessinit = !result.negated; 1619 cifs_dbg(FYI, "rfc1001_sessinit set to %d\n", ctx->rfc1001_sessinit); 1620 break; 1621 case Opt_ver: 1622 /* version of mount userspace tools, not dialect */ 1623 /* If interface changes in mount.cifs bump to new ver */ 1624 if (strncasecmp(param->string, "1", 1) == 0) { 1625 if (strlen(param->string) > 1) { 1626 pr_warn("Bad mount helper ver=%s. Did you want SMB1 (CIFS) dialect and mean to type vers=1.0 instead?\n", 1627 param->string); 1628 goto cifs_parse_mount_err; 1629 } 1630 /* This is the default */ 1631 break; 1632 } 1633 /* For all other value, error */ 1634 pr_warn("Invalid mount helper version specified\n"); 1635 goto cifs_parse_mount_err; 1636 case Opt_vers: 1637 /* protocol version (dialect) */ 1638 if (cifs_parse_smb_version(fc, param->string, ctx, is_smb3) != 0) 1639 goto cifs_parse_mount_err; 1640 ctx->got_version = true; 1641 break; 1642 case Opt_sec: 1643 if (cifs_parse_security_flavors(fc, param->string, ctx) != 0) 1644 goto cifs_parse_mount_err; 1645 break; 1646 case Opt_upcalltarget: 1647 if (cifs_parse_upcall_target(fc, param->string, ctx) != 0) 1648 goto cifs_parse_mount_err; 1649 break; 1650 case Opt_cache: 1651 if (cifs_parse_cache_flavor(fc, param->string, ctx) != 0) 1652 goto cifs_parse_mount_err; 1653 break; 1654 case Opt_witness: 1655 #ifndef CONFIG_CIFS_SWN_UPCALL 1656 cifs_errorf(fc, "Witness support needs CONFIG_CIFS_SWN_UPCALL config option\n"); 1657 goto cifs_parse_mount_err; 1658 #endif 1659 ctx->witness = true; 1660 pr_warn_once("Witness protocol support is experimental\n"); 1661 break; 1662 case Opt_unicode: 1663 ctx->unicode = !result.negated; 1664 cifs_dbg(FYI, "unicode set to %d\n", ctx->unicode); 1665 break; 1666 case Opt_rootfs: 1667 #ifndef CONFIG_CIFS_ROOT 1668 cifs_dbg(VFS, "rootfs support requires CONFIG_CIFS_ROOT config option\n"); 1669 goto cifs_parse_mount_err; 1670 #endif 1671 ctx->rootfs = true; 1672 break; 1673 case Opt_posixpaths: 1674 if (result.negated) 1675 ctx->posix_paths = 0; 1676 else 1677 ctx->posix_paths = 1; 1678 break; 1679 case Opt_unix: 1680 if (result.negated) { 1681 if (ctx->linux_ext == 1) 1682 pr_warn_once("conflicting posix mount options specified\n"); 1683 ctx->linux_ext = 0; 1684 ctx->no_linux_ext = 1; 1685 } else { 1686 if (ctx->no_linux_ext == 1) 1687 pr_warn_once("conflicting posix mount options specified\n"); 1688 ctx->linux_ext = 1; 1689 ctx->no_linux_ext = 0; 1690 } 1691 break; 1692 case Opt_nocase: 1693 ctx->nocase = 1; 1694 break; 1695 case Opt_brl: 1696 if (result.negated) { 1697 /* 1698 * turn off mandatory locking in mode 1699 * if remote locking is turned off since the 1700 * local vfs will do advisory 1701 */ 1702 if (ctx->file_mode == 1703 (S_IALLUGO & ~(S_ISUID | S_IXGRP))) 1704 ctx->file_mode = S_IALLUGO; 1705 ctx->nobrl = 1; 1706 } else 1707 ctx->nobrl = 0; 1708 break; 1709 case Opt_handlecache: 1710 if (result.negated) 1711 ctx->nohandlecache = 1; 1712 else 1713 ctx->nohandlecache = 0; 1714 break; 1715 case Opt_forcemandatorylock: 1716 ctx->mand_lock = 1; 1717 break; 1718 case Opt_setuids: 1719 ctx->setuids = result.negated; 1720 break; 1721 case Opt_intr: 1722 ctx->intr = !result.negated; 1723 break; 1724 case Opt_setuidfromacl: 1725 ctx->setuidfromacl = 1; 1726 break; 1727 case Opt_strictsync: 1728 ctx->nostrictsync = result.negated; 1729 break; 1730 case Opt_serverino: 1731 ctx->server_ino = !result.negated; 1732 break; 1733 case Opt_rwpidforward: 1734 ctx->rwpidforward = 1; 1735 break; 1736 case Opt_modesid: 1737 ctx->mode_ace = 1; 1738 break; 1739 case Opt_cifsacl: 1740 ctx->cifs_acl = !result.negated; 1741 break; 1742 case Opt_acl: 1743 ctx->no_psx_acl = result.negated; 1744 break; 1745 case Opt_locallease: 1746 ctx->local_lease = 1; 1747 break; 1748 case Opt_sign: 1749 ctx->sign = true; 1750 break; 1751 case Opt_ignore_signature: 1752 ctx->sign = true; 1753 ctx->ignore_signature = true; 1754 break; 1755 case Opt_seal: 1756 /* we do not do the following in secFlags because seal 1757 * is a per tree connection (mount) not a per socket 1758 * or per-smb connection option in the protocol 1759 * vol->secFlg |= CIFSSEC_MUST_SEAL; 1760 */ 1761 ctx->seal = 1; 1762 break; 1763 case Opt_noac: 1764 pr_warn("Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n"); 1765 break; 1766 case Opt_fsc: 1767 #ifndef CONFIG_CIFS_FSCACHE 1768 cifs_errorf(fc, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n"); 1769 goto cifs_parse_mount_err; 1770 #endif 1771 ctx->fsc = true; 1772 break; 1773 case Opt_mfsymlinks: 1774 ctx->mfsymlinks = true; 1775 break; 1776 case Opt_multiuser: 1777 ctx->multiuser = true; 1778 break; 1779 case Opt_sloppy: 1780 ctx->sloppy = true; 1781 break; 1782 case Opt_nosharesock: 1783 ctx->nosharesock = true; 1784 break; 1785 case Opt_persistent: 1786 if (result.negated) { 1787 ctx->nopersistent = true; 1788 if (ctx->persistent) { 1789 cifs_errorf(fc, "persistenthandles mount options conflict\n"); 1790 goto cifs_parse_mount_err; 1791 } 1792 } else { 1793 ctx->persistent = true; 1794 if ((ctx->nopersistent) || (ctx->resilient)) { 1795 cifs_errorf(fc, "persistenthandles mount options conflict\n"); 1796 goto cifs_parse_mount_err; 1797 } 1798 } 1799 break; 1800 case Opt_resilient: 1801 if (result.negated) { 1802 ctx->resilient = false; /* already the default */ 1803 } else { 1804 ctx->resilient = true; 1805 if (ctx->persistent) { 1806 cifs_errorf(fc, "persistenthandles mount options conflict\n"); 1807 goto cifs_parse_mount_err; 1808 } 1809 } 1810 break; 1811 case Opt_tcp_nodelay: 1812 /* tcp nodelay should not usually be needed since we CORK/UNCORK the socket */ 1813 if (result.negated) 1814 ctx->sockopt_tcp_nodelay = false; 1815 else 1816 ctx->sockopt_tcp_nodelay = true; 1817 break; 1818 case Opt_domainauto: 1819 ctx->domainauto = true; 1820 break; 1821 case Opt_rdma: 1822 ctx->rdma = true; 1823 break; 1824 case Opt_reparse: 1825 if (parse_reparse_flavor(fc, param->string, ctx)) 1826 goto cifs_parse_mount_err; 1827 break; 1828 case Opt_nativesocket: 1829 ctx->nonativesocket = result.negated; 1830 break; 1831 case Opt_symlink: 1832 if (parse_symlink_flavor(fc, param->string, ctx)) 1833 goto cifs_parse_mount_err; 1834 break; 1835 case Opt_symlinkroot: 1836 if (param->string[0] != '/') { 1837 cifs_errorf(fc, "symlinkroot mount options must be absolute path\n"); 1838 goto cifs_parse_mount_err; 1839 } 1840 kfree(ctx->symlinkroot); 1841 ctx->symlinkroot = kstrdup(param->string, GFP_KERNEL); 1842 if (!ctx->symlinkroot) 1843 goto cifs_parse_mount_err; 1844 break; 1845 } 1846 /* case Opt_ignore: - is ignored as expected ... */ 1847 1848 if (ctx->multiuser && ctx->upcall_target == UPTARGET_MOUNT) { 1849 cifs_errorf(fc, "multiuser mount option not supported with upcalltarget set as 'mount'\n"); 1850 goto cifs_parse_mount_err; 1851 } 1852 1853 /* 1854 * By default resolve all native absolute symlinks relative to "/mnt/". 1855 * Same default has drvfs driver running in WSL for resolving SMB shares. 1856 */ 1857 if (!ctx->symlinkroot) 1858 ctx->symlinkroot = kstrdup("/mnt/", GFP_KERNEL); 1859 1860 return 0; 1861 1862 cifs_parse_mount_err: 1863 kfree_sensitive(ctx->password); 1864 ctx->password = NULL; 1865 kfree_sensitive(ctx->password2); 1866 ctx->password2 = NULL; 1867 return -EINVAL; 1868 } 1869 1870 enum cifs_symlink_type get_cifs_symlink_type(struct cifs_sb_info *cifs_sb) 1871 { 1872 if (cifs_sb->ctx->symlink_type == CIFS_SYMLINK_TYPE_DEFAULT) { 1873 if (cifs_sb->ctx->mfsymlinks) 1874 return CIFS_SYMLINK_TYPE_MFSYMLINKS; 1875 else if (cifs_sb->ctx->sfu_emul) 1876 return CIFS_SYMLINK_TYPE_SFU; 1877 else if (cifs_sb->ctx->linux_ext && !cifs_sb->ctx->no_linux_ext) 1878 return CIFS_SYMLINK_TYPE_UNIX; 1879 else if (cifs_sb->ctx->reparse_type != CIFS_REPARSE_TYPE_NONE) 1880 return CIFS_SYMLINK_TYPE_NATIVE; 1881 else 1882 return CIFS_SYMLINK_TYPE_NONE; 1883 } else { 1884 return cifs_sb->ctx->symlink_type; 1885 } 1886 } 1887 1888 int smb3_init_fs_context(struct fs_context *fc) 1889 { 1890 struct smb3_fs_context *ctx; 1891 char *nodename = utsname()->nodename; 1892 int i; 1893 1894 ctx = kzalloc(sizeof(struct smb3_fs_context), GFP_KERNEL); 1895 if (unlikely(!ctx)) 1896 return -ENOMEM; 1897 1898 strscpy(ctx->workstation_name, nodename, sizeof(ctx->workstation_name)); 1899 1900 /* 1901 * does not have to be perfect mapping since field is 1902 * informational, only used for servers that do not support 1903 * port 445 and it can be overridden at mount time 1904 */ 1905 memset(ctx->source_rfc1001_name, 0x20, RFC1001_NAME_LEN); 1906 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++) 1907 ctx->source_rfc1001_name[i] = toupper(nodename[i]); 1908 ctx->source_rfc1001_name[RFC1001_NAME_LEN] = 0; 1909 1910 /* 1911 * null target name indicates to use *SMBSERVR default called name 1912 * if we end up sending RFC1001 session initialize 1913 */ 1914 ctx->target_rfc1001_name[0] = 0; 1915 1916 ctx->rfc1001_sessinit = -1; /* autodetect based on port number */ 1917 1918 ctx->cred_uid = current_uid(); 1919 ctx->linux_uid = current_uid(); 1920 ctx->linux_gid = current_gid(); 1921 /* By default 4MB read ahead size, 1MB block size */ 1922 ctx->bsize = CIFS_DEFAULT_IOSIZE; /* can improve cp performance significantly */ 1923 ctx->rasize = 0; /* 0 = use default (ie negotiated rsize) for read ahead pages */ 1924 1925 /* 1926 * default to SFM style remapping of seven reserved characters 1927 * unless user overrides it or we negotiate CIFS POSIX where 1928 * it is unnecessary. Can not simultaneously use more than one mapping 1929 * since then readdir could list files that open could not open 1930 */ 1931 ctx->remap = true; 1932 1933 /* default to only allowing write access to owner of the mount */ 1934 ctx->dir_mode = ctx->file_mode = S_IRUGO | S_IXUGO | S_IWUSR; 1935 1936 /* ctx->retry default is 0 (i.e. "soft" limited retry not hard retry) */ 1937 /* default is always to request posix paths. */ 1938 ctx->posix_paths = 1; 1939 /* default to using server inode numbers where available */ 1940 ctx->server_ino = 1; 1941 1942 /* default is to use strict cifs caching semantics */ 1943 ctx->strict_io = true; 1944 1945 ctx->acregmax = CIFS_DEF_ACTIMEO; 1946 ctx->acdirmax = CIFS_DEF_ACTIMEO; 1947 ctx->closetimeo = SMB3_DEF_DCLOSETIMEO; 1948 ctx->max_cached_dirs = MAX_CACHED_FIDS; 1949 /* Most clients set timeout to 0, allows server to use its default */ 1950 ctx->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */ 1951 1952 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */ 1953 ctx->ops = &smb30_operations; 1954 ctx->vals = &smbdefault_values; 1955 1956 ctx->echo_interval = SMB_ECHO_INTERVAL_DEFAULT; 1957 1958 /* default to no multichannel (single server connection) */ 1959 ctx->multichannel = false; 1960 ctx->max_channels = 1; 1961 1962 ctx->backupuid_specified = false; /* no backup intent for a user */ 1963 ctx->backupgid_specified = false; /* no backup intent for a group */ 1964 1965 ctx->retrans = 1; 1966 ctx->reparse_type = CIFS_REPARSE_TYPE_DEFAULT; 1967 ctx->symlink_type = CIFS_SYMLINK_TYPE_DEFAULT; 1968 ctx->nonativesocket = 0; 1969 1970 ctx->unicode = -1; /* autodetect, but prefer UNICODE mode */ 1971 1972 /* 1973 * short int override_uid = -1; 1974 * short int override_gid = -1; 1975 * char *nodename = strdup(utsname()->nodename); 1976 * struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr; 1977 */ 1978 1979 fc->fs_private = ctx; 1980 fc->ops = &smb3_fs_context_ops; 1981 return 0; 1982 } 1983 1984 void 1985 smb3_cleanup_fs_context_contents(struct smb3_fs_context *ctx) 1986 { 1987 if (ctx == NULL) 1988 return; 1989 1990 /* 1991 * Make sure this stays in sync with smb3_fs_context_dup() 1992 */ 1993 kfree(ctx->username); 1994 ctx->username = NULL; 1995 kfree_sensitive(ctx->password); 1996 ctx->password = NULL; 1997 kfree_sensitive(ctx->password2); 1998 ctx->password2 = NULL; 1999 kfree(ctx->server_hostname); 2000 ctx->server_hostname = NULL; 2001 kfree(ctx->UNC); 2002 ctx->UNC = NULL; 2003 kfree(ctx->source); 2004 ctx->source = NULL; 2005 kfree(ctx->domainname); 2006 ctx->domainname = NULL; 2007 kfree(ctx->nodename); 2008 ctx->nodename = NULL; 2009 kfree(ctx->iocharset); 2010 ctx->iocharset = NULL; 2011 kfree(ctx->prepath); 2012 ctx->prepath = NULL; 2013 kfree(ctx->leaf_fullpath); 2014 ctx->leaf_fullpath = NULL; 2015 kfree(ctx->dns_dom); 2016 ctx->dns_dom = NULL; 2017 kfree(ctx->symlinkroot); 2018 ctx->symlinkroot = NULL; 2019 } 2020 2021 void 2022 smb3_cleanup_fs_context(struct smb3_fs_context *ctx) 2023 { 2024 if (!ctx) 2025 return; 2026 smb3_cleanup_fs_context_contents(ctx); 2027 kfree(ctx); 2028 } 2029 2030 void smb3_update_mnt_flags(struct cifs_sb_info *cifs_sb) 2031 { 2032 struct smb3_fs_context *ctx = cifs_sb->ctx; 2033 2034 if (ctx->nodfs) 2035 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS; 2036 else 2037 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_DFS; 2038 2039 if (ctx->noperm) 2040 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM; 2041 else 2042 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_PERM; 2043 2044 if (ctx->setuids) 2045 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID; 2046 else 2047 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SET_UID; 2048 2049 if (ctx->setuidfromacl) 2050 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL; 2051 else 2052 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UID_FROM_ACL; 2053 2054 if (ctx->server_ino) 2055 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM; 2056 else 2057 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SERVER_INUM; 2058 2059 if (ctx->remap) 2060 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR; 2061 else 2062 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SFM_CHR; 2063 2064 if (ctx->sfu_remap) 2065 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR; 2066 else 2067 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MAP_SPECIAL_CHR; 2068 2069 if (ctx->no_xattr) 2070 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR; 2071 else 2072 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_XATTR; 2073 2074 if (ctx->sfu_emul) 2075 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL; 2076 else 2077 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_UNX_EMUL; 2078 2079 if (ctx->nobrl) 2080 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL; 2081 else 2082 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_BRL; 2083 2084 if (ctx->nohandlecache) 2085 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE; 2086 else 2087 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NO_HANDLE_CACHE; 2088 2089 if (ctx->nostrictsync) 2090 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC; 2091 else 2092 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOSSYNC; 2093 2094 if (ctx->mand_lock) 2095 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL; 2096 else 2097 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_NOPOSIXBRL; 2098 2099 if (ctx->rwpidforward) 2100 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD; 2101 else 2102 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_RWPIDFORWARD; 2103 2104 if (ctx->mode_ace) 2105 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID; 2106 else 2107 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MODE_FROM_SID; 2108 2109 if (ctx->cifs_acl) 2110 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL; 2111 else 2112 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_ACL; 2113 2114 if (ctx->backupuid_specified) 2115 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID; 2116 else 2117 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPUID; 2118 2119 if (ctx->backupgid_specified) 2120 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID; 2121 else 2122 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_CIFS_BACKUPGID; 2123 2124 if (ctx->override_uid) 2125 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID; 2126 else 2127 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_UID; 2128 2129 if (ctx->override_gid) 2130 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID; 2131 else 2132 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_OVERR_GID; 2133 2134 if (ctx->dynperm) 2135 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM; 2136 else 2137 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DYNPERM; 2138 2139 if (ctx->fsc) 2140 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE; 2141 else 2142 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_FSCACHE; 2143 2144 if (ctx->multiuser) 2145 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER | 2146 CIFS_MOUNT_NO_PERM); 2147 else 2148 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MULTIUSER; 2149 2150 2151 if (ctx->strict_io) 2152 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO; 2153 else 2154 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_STRICT_IO; 2155 2156 if (ctx->direct_io) 2157 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO; 2158 else 2159 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_DIRECT_IO; 2160 2161 if (ctx->mfsymlinks) 2162 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS; 2163 else 2164 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_MF_SYMLINKS; 2165 if (ctx->mfsymlinks) { 2166 if (ctx->sfu_emul) { 2167 /* 2168 * Our SFU ("Services for Unix") emulation allows now 2169 * creating new and reading existing SFU symlinks. 2170 * Older Linux kernel versions were not able to neither 2171 * read existing nor create new SFU symlinks. But 2172 * creating and reading SFU style mknod and FIFOs was 2173 * supported for long time. When "mfsymlinks" and 2174 * "sfu" are both enabled at the same time, it allows 2175 * reading both types of symlinks, but will only create 2176 * them with mfsymlinks format. This allows better 2177 * Apple compatibility, compatibility with older Linux 2178 * kernel clients (probably better for Samba too) 2179 * while still recognizing old Windows style symlinks. 2180 */ 2181 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n"); 2182 } 2183 } 2184 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_SHUTDOWN; 2185 2186 return; 2187 } 2188