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