1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2022 Paulo Alcantara <palcantara@suse.de> 4 */ 5 6 #include <linux/namei.h> 7 #include "cifsproto.h" 8 #include "cifs_debug.h" 9 #include "dns_resolve.h" 10 #include "fs_context.h" 11 #include "dfs.h" 12 13 /** 14 * dfs_parse_target_referral - set fs context for dfs target referral 15 * 16 * @full_path: full path in UNC format. 17 * @ref: dfs referral pointer. 18 * @ctx: smb3 fs context pointer. 19 * 20 * Return zero if dfs referral was parsed correctly, otherwise non-zero. 21 */ 22 int dfs_parse_target_referral(const char *full_path, const struct dfs_info3_param *ref, 23 struct smb3_fs_context *ctx) 24 { 25 int rc; 26 const char *prepath = NULL; 27 char *path; 28 29 if (!full_path || !*full_path || !ref || !ctx) 30 return -EINVAL; 31 32 if (WARN_ON_ONCE(!ref->node_name || ref->path_consumed < 0)) 33 return -EINVAL; 34 35 if (strlen(full_path) - ref->path_consumed) { 36 prepath = full_path + ref->path_consumed; 37 /* skip initial delimiter */ 38 if (*prepath == '/' || *prepath == '\\') 39 prepath++; 40 } 41 42 path = cifs_build_devname(ref->node_name, prepath); 43 if (IS_ERR(path)) 44 return PTR_ERR(path); 45 46 rc = smb3_parse_devname(path, ctx); 47 if (rc) 48 goto out; 49 50 rc = dns_resolve_server_name_to_ip(path, (struct sockaddr *)&ctx->dstaddr, NULL); 51 52 out: 53 kfree(path); 54 return rc; 55 } 56 57 static int get_session(struct cifs_mount_ctx *mnt_ctx, const char *full_path) 58 { 59 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx; 60 int rc; 61 62 ctx->leaf_fullpath = (char *)full_path; 63 rc = cifs_mount_get_session(mnt_ctx); 64 ctx->leaf_fullpath = NULL; 65 66 return rc; 67 } 68 69 /* 70 * Track individual DFS referral servers used by new DFS mount. 71 * 72 * On success, their lifetime will be shared by final tcon (dfs_ses_list). 73 * Otherwise, they will be put by dfs_put_root_smb_sessions() in cifs_mount(). 74 */ 75 static int add_root_smb_session(struct cifs_mount_ctx *mnt_ctx) 76 { 77 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx; 78 struct dfs_root_ses *root_ses; 79 struct cifs_ses *ses = mnt_ctx->ses; 80 81 if (ses) { 82 root_ses = kmalloc(sizeof(*root_ses), GFP_KERNEL); 83 if (!root_ses) 84 return -ENOMEM; 85 86 INIT_LIST_HEAD(&root_ses->list); 87 88 spin_lock(&cifs_tcp_ses_lock); 89 cifs_smb_ses_inc_refcount(ses); 90 spin_unlock(&cifs_tcp_ses_lock); 91 root_ses->ses = ses; 92 list_add_tail(&root_ses->list, &mnt_ctx->dfs_ses_list); 93 } 94 /* Select new DFS referral server so that new referrals go through it */ 95 ctx->dfs_root_ses = ses; 96 return 0; 97 } 98 99 static int get_dfs_conn(struct cifs_mount_ctx *mnt_ctx, const char *ref_path, const char *full_path, 100 const struct dfs_cache_tgt_iterator *tit) 101 { 102 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx; 103 struct dfs_info3_param ref = {}; 104 bool is_refsrv; 105 int rc, rc2; 106 107 rc = dfs_cache_get_tgt_referral(ref_path + 1, tit, &ref); 108 if (rc) 109 return rc; 110 111 rc = dfs_parse_target_referral(full_path + 1, &ref, ctx); 112 if (rc) 113 goto out; 114 115 cifs_mount_put_conns(mnt_ctx); 116 rc = get_session(mnt_ctx, ref_path); 117 if (rc) 118 goto out; 119 120 is_refsrv = !!(ref.flags & DFSREF_REFERRAL_SERVER); 121 122 rc = -EREMOTE; 123 if (ref.flags & DFSREF_STORAGE_SERVER) { 124 rc = cifs_mount_get_tcon(mnt_ctx); 125 if (rc) 126 goto out; 127 128 /* some servers may not advertise referral capability under ref.flags */ 129 is_refsrv |= is_tcon_dfs(mnt_ctx->tcon); 130 131 rc = cifs_is_path_remote(mnt_ctx); 132 } 133 134 dfs_cache_noreq_update_tgthint(ref_path + 1, tit); 135 136 if (rc == -EREMOTE && is_refsrv) { 137 rc2 = add_root_smb_session(mnt_ctx); 138 if (rc2) 139 rc = rc2; 140 } 141 142 out: 143 free_dfs_info_param(&ref); 144 return rc; 145 } 146 147 static int __dfs_mount_share(struct cifs_mount_ctx *mnt_ctx) 148 { 149 struct cifs_sb_info *cifs_sb = mnt_ctx->cifs_sb; 150 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx; 151 char *ref_path = NULL, *full_path = NULL; 152 struct dfs_cache_tgt_iterator *tit; 153 struct cifs_tcon *tcon; 154 char *origin_fullpath = NULL; 155 char sep = CIFS_DIR_SEP(cifs_sb); 156 int num_links = 0; 157 int rc; 158 159 ref_path = dfs_get_path(cifs_sb, ctx->UNC); 160 if (IS_ERR(ref_path)) 161 return PTR_ERR(ref_path); 162 163 full_path = smb3_fs_context_fullpath(ctx, sep); 164 if (IS_ERR(full_path)) { 165 rc = PTR_ERR(full_path); 166 full_path = NULL; 167 goto out; 168 } 169 170 origin_fullpath = kstrdup(full_path, GFP_KERNEL); 171 if (!origin_fullpath) { 172 rc = -ENOMEM; 173 goto out; 174 } 175 176 do { 177 struct dfs_cache_tgt_list tl = DFS_CACHE_TGT_LIST_INIT(tl); 178 179 rc = dfs_get_referral(mnt_ctx, ref_path + 1, NULL, &tl); 180 if (rc) 181 break; 182 183 tit = dfs_cache_get_tgt_iterator(&tl); 184 if (!tit) { 185 cifs_dbg(VFS, "%s: dfs referral (%s) with no targets\n", __func__, 186 ref_path + 1); 187 rc = -ENOENT; 188 dfs_cache_free_tgts(&tl); 189 break; 190 } 191 192 do { 193 rc = get_dfs_conn(mnt_ctx, ref_path, full_path, tit); 194 if (!rc) 195 break; 196 if (rc == -EREMOTE) { 197 if (++num_links > MAX_NESTED_LINKS) { 198 rc = -ELOOP; 199 break; 200 } 201 kfree(ref_path); 202 kfree(full_path); 203 ref_path = full_path = NULL; 204 205 full_path = smb3_fs_context_fullpath(ctx, sep); 206 if (IS_ERR(full_path)) { 207 rc = PTR_ERR(full_path); 208 full_path = NULL; 209 } else { 210 ref_path = dfs_get_path(cifs_sb, full_path); 211 if (IS_ERR(ref_path)) { 212 rc = PTR_ERR(ref_path); 213 ref_path = NULL; 214 } 215 } 216 break; 217 } 218 } while ((tit = dfs_cache_get_next_tgt(&tl, tit))); 219 dfs_cache_free_tgts(&tl); 220 } while (rc == -EREMOTE); 221 222 if (!rc) { 223 tcon = mnt_ctx->tcon; 224 225 spin_lock(&tcon->tc_lock); 226 if (!tcon->origin_fullpath) { 227 tcon->origin_fullpath = origin_fullpath; 228 origin_fullpath = NULL; 229 } 230 spin_unlock(&tcon->tc_lock); 231 232 if (list_empty(&tcon->dfs_ses_list)) { 233 list_replace_init(&mnt_ctx->dfs_ses_list, 234 &tcon->dfs_ses_list); 235 queue_delayed_work(dfscache_wq, &tcon->dfs_cache_work, 236 dfs_cache_get_ttl() * HZ); 237 } else { 238 dfs_put_root_smb_sessions(&mnt_ctx->dfs_ses_list); 239 } 240 } 241 242 out: 243 kfree(origin_fullpath); 244 kfree(ref_path); 245 kfree(full_path); 246 return rc; 247 } 248 249 int dfs_mount_share(struct cifs_mount_ctx *mnt_ctx, bool *isdfs) 250 { 251 struct smb3_fs_context *ctx = mnt_ctx->fs_ctx; 252 bool nodfs = ctx->nodfs; 253 int rc; 254 255 *isdfs = false; 256 rc = get_session(mnt_ctx, NULL); 257 if (rc) 258 return rc; 259 260 ctx->dfs_root_ses = mnt_ctx->ses; 261 /* 262 * If called with 'nodfs' mount option, then skip DFS resolving. Otherwise unconditionally 263 * try to get an DFS referral (even cached) to determine whether it is an DFS mount. 264 * 265 * Skip prefix path to provide support for DFS referrals from w2k8 servers which don't seem 266 * to respond with PATH_NOT_COVERED to requests that include the prefix. 267 */ 268 if (!nodfs) { 269 rc = dfs_get_referral(mnt_ctx, ctx->UNC + 1, NULL, NULL); 270 if (rc) { 271 cifs_dbg(FYI, "%s: no dfs referral for %s: %d\n", 272 __func__, ctx->UNC + 1, rc); 273 cifs_dbg(FYI, "%s: assuming non-dfs mount...\n", __func__); 274 nodfs = true; 275 } 276 } 277 if (nodfs) { 278 rc = cifs_mount_get_tcon(mnt_ctx); 279 if (!rc) 280 rc = cifs_is_path_remote(mnt_ctx); 281 return rc; 282 } 283 284 *isdfs = true; 285 add_root_smb_session(mnt_ctx); 286 return __dfs_mount_share(mnt_ctx); 287 } 288 289 /* Update dfs referral path of superblock */ 290 static int update_server_fullpath(struct TCP_Server_Info *server, struct cifs_sb_info *cifs_sb, 291 const char *target) 292 { 293 int rc = 0; 294 size_t len = strlen(target); 295 char *refpath, *npath; 296 297 if (unlikely(len < 2 || *target != '\\')) 298 return -EINVAL; 299 300 if (target[1] == '\\') { 301 len += 1; 302 refpath = kmalloc(len, GFP_KERNEL); 303 if (!refpath) 304 return -ENOMEM; 305 306 scnprintf(refpath, len, "%s", target); 307 } else { 308 len += sizeof("\\"); 309 refpath = kmalloc(len, GFP_KERNEL); 310 if (!refpath) 311 return -ENOMEM; 312 313 scnprintf(refpath, len, "\\%s", target); 314 } 315 316 npath = dfs_cache_canonical_path(refpath, cifs_sb->local_nls, cifs_remap(cifs_sb)); 317 kfree(refpath); 318 319 if (IS_ERR(npath)) { 320 rc = PTR_ERR(npath); 321 } else { 322 mutex_lock(&server->refpath_lock); 323 spin_lock(&server->srv_lock); 324 kfree(server->leaf_fullpath); 325 server->leaf_fullpath = npath; 326 spin_unlock(&server->srv_lock); 327 mutex_unlock(&server->refpath_lock); 328 } 329 return rc; 330 } 331 332 static int target_share_matches_server(struct TCP_Server_Info *server, char *share, 333 bool *target_match) 334 { 335 int rc = 0; 336 const char *dfs_host; 337 size_t dfs_host_len; 338 339 *target_match = true; 340 extract_unc_hostname(share, &dfs_host, &dfs_host_len); 341 342 /* Check if hostnames or addresses match */ 343 cifs_server_lock(server); 344 if (dfs_host_len != strlen(server->hostname) || 345 strncasecmp(dfs_host, server->hostname, dfs_host_len)) { 346 cifs_dbg(FYI, "%s: %.*s doesn't match %s\n", __func__, 347 (int)dfs_host_len, dfs_host, server->hostname); 348 rc = match_target_ip(server, dfs_host, dfs_host_len, target_match); 349 if (rc) 350 cifs_dbg(VFS, "%s: failed to match target ip: %d\n", __func__, rc); 351 } 352 cifs_server_unlock(server); 353 return rc; 354 } 355 356 static void __tree_connect_ipc(const unsigned int xid, char *tree, 357 struct cifs_sb_info *cifs_sb, 358 struct cifs_ses *ses) 359 { 360 struct TCP_Server_Info *server = ses->server; 361 struct cifs_tcon *tcon = ses->tcon_ipc; 362 int rc; 363 364 spin_lock(&ses->ses_lock); 365 spin_lock(&ses->chan_lock); 366 if (cifs_chan_needs_reconnect(ses, server) || 367 ses->ses_status != SES_GOOD) { 368 spin_unlock(&ses->chan_lock); 369 spin_unlock(&ses->ses_lock); 370 cifs_server_dbg(FYI, "%s: skipping ipc reconnect due to disconnected ses\n", 371 __func__); 372 return; 373 } 374 spin_unlock(&ses->chan_lock); 375 spin_unlock(&ses->ses_lock); 376 377 cifs_server_lock(server); 378 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname); 379 cifs_server_unlock(server); 380 381 rc = server->ops->tree_connect(xid, ses, tree, tcon, 382 cifs_sb->local_nls); 383 cifs_server_dbg(FYI, "%s: tree_reconnect %s: %d\n", __func__, tree, rc); 384 spin_lock(&tcon->tc_lock); 385 if (rc) { 386 tcon->status = TID_NEED_TCON; 387 } else { 388 tcon->status = TID_GOOD; 389 tcon->need_reconnect = false; 390 } 391 spin_unlock(&tcon->tc_lock); 392 } 393 394 static void tree_connect_ipc(const unsigned int xid, char *tree, 395 struct cifs_sb_info *cifs_sb, 396 struct cifs_tcon *tcon) 397 { 398 struct cifs_ses *ses = tcon->ses; 399 400 __tree_connect_ipc(xid, tree, cifs_sb, ses); 401 __tree_connect_ipc(xid, tree, cifs_sb, CIFS_DFS_ROOT_SES(ses)); 402 } 403 404 static int __tree_connect_dfs_target(const unsigned int xid, struct cifs_tcon *tcon, 405 struct cifs_sb_info *cifs_sb, char *tree, bool islink, 406 struct dfs_cache_tgt_list *tl) 407 { 408 int rc; 409 struct TCP_Server_Info *server = tcon->ses->server; 410 const struct smb_version_operations *ops = server->ops; 411 struct cifs_ses *root_ses = CIFS_DFS_ROOT_SES(tcon->ses); 412 char *share = NULL, *prefix = NULL; 413 struct dfs_cache_tgt_iterator *tit; 414 bool target_match; 415 416 tit = dfs_cache_get_tgt_iterator(tl); 417 if (!tit) { 418 rc = -ENOENT; 419 goto out; 420 } 421 422 /* Try to tree connect to all dfs targets */ 423 for (; tit; tit = dfs_cache_get_next_tgt(tl, tit)) { 424 const char *target = dfs_cache_get_tgt_name(tit); 425 struct dfs_cache_tgt_list ntl = DFS_CACHE_TGT_LIST_INIT(ntl); 426 427 kfree(share); 428 kfree(prefix); 429 share = prefix = NULL; 430 431 /* Check if share matches with tcp ses */ 432 rc = dfs_cache_get_tgt_share(server->leaf_fullpath + 1, tit, &share, &prefix); 433 if (rc) { 434 cifs_dbg(VFS, "%s: failed to parse target share: %d\n", __func__, rc); 435 break; 436 } 437 438 rc = target_share_matches_server(server, share, &target_match); 439 if (rc) 440 break; 441 if (!target_match) { 442 rc = -EHOSTUNREACH; 443 continue; 444 } 445 446 dfs_cache_noreq_update_tgthint(server->leaf_fullpath + 1, tit); 447 tree_connect_ipc(xid, tree, cifs_sb, tcon); 448 449 scnprintf(tree, MAX_TREE_SIZE, "\\%s", share); 450 if (!islink) { 451 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, cifs_sb->local_nls); 452 break; 453 } 454 455 /* 456 * If no dfs referrals were returned from link target, then just do a TREE_CONNECT 457 * to it. Otherwise, cache the dfs referral and then mark current tcp ses for 458 * reconnect so either the demultiplex thread or the echo worker will reconnect to 459 * newly resolved target. 460 */ 461 if (dfs_cache_find(xid, root_ses, cifs_sb->local_nls, cifs_remap(cifs_sb), target, 462 NULL, &ntl)) { 463 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, cifs_sb->local_nls); 464 if (rc) 465 continue; 466 467 rc = cifs_update_super_prepath(cifs_sb, prefix); 468 } else { 469 /* Target is another dfs share */ 470 rc = update_server_fullpath(server, cifs_sb, target); 471 dfs_cache_free_tgts(tl); 472 473 if (!rc) { 474 rc = -EREMOTE; 475 list_replace_init(&ntl.tl_list, &tl->tl_list); 476 } else 477 dfs_cache_free_tgts(&ntl); 478 } 479 break; 480 } 481 482 out: 483 kfree(share); 484 kfree(prefix); 485 486 return rc; 487 } 488 489 static int tree_connect_dfs_target(const unsigned int xid, struct cifs_tcon *tcon, 490 struct cifs_sb_info *cifs_sb, char *tree, bool islink, 491 struct dfs_cache_tgt_list *tl) 492 { 493 int rc; 494 int num_links = 0; 495 struct TCP_Server_Info *server = tcon->ses->server; 496 char *old_fullpath = server->leaf_fullpath; 497 498 do { 499 rc = __tree_connect_dfs_target(xid, tcon, cifs_sb, tree, islink, tl); 500 if (!rc || rc != -EREMOTE) 501 break; 502 } while (rc = -ELOOP, ++num_links < MAX_NESTED_LINKS); 503 /* 504 * If we couldn't tree connect to any targets from last referral path, then 505 * retry it from newly resolved dfs referral. 506 */ 507 if (rc && server->leaf_fullpath != old_fullpath) 508 cifs_signal_cifsd_for_reconnect(server, true); 509 510 dfs_cache_free_tgts(tl); 511 return rc; 512 } 513 514 int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const struct nls_table *nlsc) 515 { 516 int rc; 517 struct TCP_Server_Info *server = tcon->ses->server; 518 const struct smb_version_operations *ops = server->ops; 519 struct dfs_cache_tgt_list tl = DFS_CACHE_TGT_LIST_INIT(tl); 520 struct cifs_sb_info *cifs_sb = NULL; 521 struct super_block *sb = NULL; 522 struct dfs_info3_param ref = {0}; 523 char *tree; 524 525 /* only send once per connect */ 526 spin_lock(&tcon->tc_lock); 527 if (tcon->status == TID_GOOD) { 528 spin_unlock(&tcon->tc_lock); 529 return 0; 530 } 531 532 if (tcon->status != TID_NEW && 533 tcon->status != TID_NEED_TCON) { 534 spin_unlock(&tcon->tc_lock); 535 return -EHOSTDOWN; 536 } 537 538 tcon->status = TID_IN_TCON; 539 spin_unlock(&tcon->tc_lock); 540 541 tree = kzalloc(MAX_TREE_SIZE, GFP_KERNEL); 542 if (!tree) { 543 rc = -ENOMEM; 544 goto out; 545 } 546 547 if (tcon->ipc) { 548 cifs_server_lock(server); 549 scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname); 550 cifs_server_unlock(server); 551 rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc); 552 goto out; 553 } 554 555 sb = cifs_get_dfs_tcon_super(tcon); 556 if (!IS_ERR(sb)) 557 cifs_sb = CIFS_SB(sb); 558 559 /* 560 * Tree connect to last share in @tcon->tree_name whether dfs super or 561 * cached dfs referral was not found. 562 */ 563 if (!cifs_sb || !server->leaf_fullpath || 564 dfs_cache_noreq_find(server->leaf_fullpath + 1, &ref, &tl)) { 565 rc = ops->tree_connect(xid, tcon->ses, tcon->tree_name, tcon, 566 cifs_sb ? cifs_sb->local_nls : nlsc); 567 goto out; 568 } 569 570 rc = tree_connect_dfs_target(xid, tcon, cifs_sb, tree, ref.server_type == DFS_TYPE_LINK, 571 &tl); 572 free_dfs_info_param(&ref); 573 574 out: 575 kfree(tree); 576 cifs_put_tcp_super(sb); 577 578 if (rc) { 579 spin_lock(&tcon->tc_lock); 580 if (tcon->status == TID_IN_TCON) 581 tcon->status = TID_NEED_TCON; 582 spin_unlock(&tcon->tc_lock); 583 } else { 584 spin_lock(&tcon->tc_lock); 585 if (tcon->status == TID_IN_TCON) 586 tcon->status = TID_GOOD; 587 spin_unlock(&tcon->tc_lock); 588 tcon->need_reconnect = false; 589 } 590 591 return rc; 592 } 593