?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use rpccli_samr_LookupNames() in net.
[Samba/gebeck_regimport.git] / source3 / smbd / msdfs.c
blob8ffa0f7751cb4ce1cd0d1d0c9cb0a2143ab71da4
1 /*
2 Unix SMB/Netbios implementation.
3 Version 3.0
4 MSDFS services for Samba
5 Copyright (C) Shirish Kalele 2000
6 Copyright (C) Jeremy Allison 2007
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21 */
22
23 #define DBGC_CLASS DBGC_MSDFS
24 #include "includes.h"
25
26 extern uint32 global_client_caps;
27
28 /**********************************************************************
29 Parse a DFS pathname of the form \hostname\service\reqpath
30 into the dfs_path structure.
31 If POSIX pathnames is true, the pathname may also be of the
32 form /hostname/service/reqpath.
33 We cope with either here.
34
35 Unfortunately, due to broken clients who might set the
36 SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES bit and then
37 send a local path, we have to cope with that too....
38
39 This version does everything using pointers within one copy of the
40 pathname string, talloced on the struct dfs_path pointer (which
41 must be talloced). This may be too clever to live....
42 JRA.
43 **********************************************************************/
44
45 static NTSTATUS parse_dfs_path(const char *pathname,
46 bool allow_wcards,
47 struct dfs_path *pdp, /* MUST BE TALLOCED */
48 bool *ppath_contains_wcard)
49 {
50 char *pathname_local;
51 char *p,*temp;
52 char *eos_ptr;
53 NTSTATUS status = NT_STATUS_OK;
54 char sepchar;
55
56 ZERO_STRUCTP(pdp);
57
58 /*
59 * This is the only talloc we should need to do
60 * on the struct dfs_path. All the pointers inside
61 * it should point to offsets within this string.
62 */
63
64 pathname_local = talloc_strdup(pdp, pathname);
65 if (!pathname_local) {
66 return NT_STATUS_NO_MEMORY;
67 }
68 /* Get a pointer to the terminating '\0' */
69 eos_ptr = &pathname_local[strlen(pathname_local)];
70 p = temp = pathname_local;
71
72 pdp->posix_path = (lp_posix_pathnames() && *pathname == '/');
73
74 sepchar = pdp->posix_path ? '/' : '\\';
75
76 if (*pathname != sepchar) {
77 DEBUG(10,("parse_dfs_path: path %s doesn't start with %c\n",
78 pathname, sepchar ));
79 /*
80 * Possibly client sent a local path by mistake.
81 * Try and convert to a local path.
82 */
83
84 pdp->hostname = eos_ptr; /* "" */
85 pdp->servicename = eos_ptr; /* "" */
86
87 /* We've got no info about separators. */
88 pdp->posix_path = lp_posix_pathnames();
89 p = temp;
90 DEBUG(10,("parse_dfs_path: trying to convert %s to a "
91 "local path\n",
92 temp));
93 goto local_path;
94 }
95
96 /*
97 * Safe to use on talloc'ed string as it only shrinks.
98 * It also doesn't affect the eos_ptr.
99 */
100 trim_char(temp,sepchar,sepchar);
101
102 DEBUG(10,("parse_dfs_path: temp = |%s| after trimming %c's\n",
103 temp, sepchar));
104
105 /* Now tokenize. */
106 /* Parse out hostname. */
107 p = strchr_m(temp,sepchar);
108 if(p == NULL) {
109 DEBUG(10,("parse_dfs_path: can't parse hostname from path %s\n",
110 temp));
111 /*
112 * Possibly client sent a local path by mistake.
113 * Try and convert to a local path.
114 */
115
116 pdp->hostname = eos_ptr; /* "" */
117 pdp->servicename = eos_ptr; /* "" */
118
119 p = temp;
120 DEBUG(10,("parse_dfs_path: trying to convert %s "
121 "to a local path\n",
122 temp));
123 goto local_path;
124 }
125 *p = '\0';
126 pdp->hostname = temp;
127
128 DEBUG(10,("parse_dfs_path: hostname: %s\n",pdp->hostname));
129
130 /* If we got a hostname, is it ours (or an IP address) ? */
131 if (!is_myname_or_ipaddr(pdp->hostname)) {
132 /* Repair path. */
133 *p = sepchar;
134 DEBUG(10,("parse_dfs_path: hostname %s isn't ours. "
135 "Try local path from path %s\n",
136 pdp->hostname, temp));
137 /*
138 * Possibly client sent a local path by mistake.
139 * Try and convert to a local path.
140 */
141
142 pdp->hostname = eos_ptr; /* "" */
143 pdp->servicename = eos_ptr; /* "" */
144
145 p = temp;
146 DEBUG(10,("parse_dfs_path: trying to convert %s "
147 "to a local path\n",
148 temp));
149 goto local_path;
150 }
151
152 /* Parse out servicename. */
153 temp = p+1;
154 p = strchr_m(temp,sepchar);
155 if(p == NULL) {
156 pdp->servicename = temp;
157 pdp->reqpath = eos_ptr; /* "" */
158 return NT_STATUS_OK;
159 }
160 *p = '\0';
161 pdp->servicename = temp;
162 DEBUG(10,("parse_dfs_path: servicename: %s\n",pdp->servicename));
163
164 p++;
165
166 local_path:
167
168 *ppath_contains_wcard = False;
169
170 pdp->reqpath = p;
171
172 /* Rest is reqpath. */
173 if (pdp->posix_path) {
174 status = check_path_syntax_posix(pdp->reqpath);
175 } else {
176 if (allow_wcards) {
177 status = check_path_syntax_wcard(pdp->reqpath,
178 ppath_contains_wcard);
179 } else {
180 status = check_path_syntax(pdp->reqpath);
181 }
182 }
183
184 if (!NT_STATUS_IS_OK(status)) {
185 DEBUG(10,("parse_dfs_path: '%s' failed with %s\n",
186 p, nt_errstr(status) ));
187 return status;
188 }
189
190 DEBUG(10,("parse_dfs_path: rest of the path: %s\n",pdp->reqpath));
191 return NT_STATUS_OK;
192 }
193
194 /********************************************************
195 Fake up a connection struct for the VFS layer.
196 Note this CHANGES CWD !!!! JRA.
197 *********************************************************/
198
199 static NTSTATUS create_conn_struct(TALLOC_CTX *ctx,
200 connection_struct *conn,
201 int snum,
202 const char *path)
203 {
204 char *connpath;
205
206 ZERO_STRUCTP(conn);
207
208 connpath = talloc_strdup(ctx, path);
209 if (!connpath) {
210 return NT_STATUS_NO_MEMORY;
211 }
212 connpath = talloc_string_sub(ctx,
213 connpath,
214 "%S",
215 lp_servicename(snum));
216 if (!connpath) {
217 return NT_STATUS_NO_MEMORY;
218 }
219
220 /* needed for smbd_vfs_init() */
221
222 if ((conn->mem_ctx=talloc_init("connection_struct")) == NULL) {
223 DEBUG(0,("talloc_init(connection_struct) failed!\n"));
224 return NT_STATUS_NO_MEMORY;
225 }
226
227 if (!(conn->params = TALLOC_ZERO_P(conn->mem_ctx,
228 struct share_params))) {
229 DEBUG(0, ("TALLOC failed\n"));
230 return NT_STATUS_NO_MEMORY;
231 }
232
233 conn->params->service = snum;
234
235 set_conn_connectpath(conn, connpath);
236
237 if (!smbd_vfs_init(conn)) {
238 NTSTATUS status = map_nt_error_from_unix(errno);
239 DEBUG(0,("create_conn_struct: smbd_vfs_init failed.\n"));
240 conn_free_internal(conn);
241 return status;
242 }
243
244 /*
245 * Windows seems to insist on doing trans2getdfsreferral() calls on
246 * the IPC$ share as the anonymous user. If we try to chdir as that
247 * user we will fail.... WTF ? JRA.
248 */
249
250 if (vfs_ChDir(conn,conn->connectpath) != 0) {
251 NTSTATUS status = map_nt_error_from_unix(errno);
252 DEBUG(3,("create_conn_struct: Can't ChDir to new conn path %s. "
253 "Error was %s\n",
254 conn->connectpath, strerror(errno) ));
255 conn_free_internal(conn);
256 return status;
257 }
258
259 return NT_STATUS_OK;
260 }
261
262 /**********************************************************************
263 Parse the contents of a symlink to verify if it is an msdfs referral
264 A valid referral is of the form:
265
266 msdfs:server1\share1,server2\share2
267 msdfs:server1\share1\pathname,server2\share2\pathname
268 msdfs:server1/share1,server2/share2
269 msdfs:server1/share1/pathname,server2/share2/pathname.
270
271 Note that the alternate paths returned here must be of the canonicalized
272 form:
273
274 \server\share or
275 \server\share\path\to\file,
276
277 even in posix path mode. This is because we have no knowledge if the
278 server we're referring to understands posix paths.
279 **********************************************************************/
280
281 static bool parse_msdfs_symlink(TALLOC_CTX *ctx,
282 const char *target,
283 struct referral **preflist,
284 int *refcount)
285 {
286 char *temp = NULL;
287 char *prot;
288 char **alt_path = NULL;
289 int count = 0, i;
290 struct referral *reflist;
291 char *saveptr;
292
293 temp = talloc_strdup(ctx, target);
294 if (!temp) {
295 return False;
296 }
297 prot = strtok_r(temp, ":", &saveptr);
298 if (!prot) {
299 DEBUG(0,("parse_msdfs_symlink: invalid path !\n"));
300 return False;
301 }
302
303 alt_path = TALLOC_ARRAY(ctx, char *, MAX_REFERRAL_COUNT);
304 if (!alt_path) {
305 return False;
306 }
307
308 /* parse out the alternate paths */
309 while((count<MAX_REFERRAL_COUNT) &&
310 ((alt_path[count] = strtok_r(NULL, ",", &saveptr)) != NULL)) {
311 count++;
312 }
313
314 DEBUG(10,("parse_msdfs_symlink: count=%d\n", count));
315
316 if (count) {
317 reflist = *preflist = TALLOC_ZERO_ARRAY(ctx,
318 struct referral, count);
319 if(reflist == NULL) {
320 TALLOC_FREE(alt_path);
321 return False;
322 }
323 } else {
324 reflist = *preflist = NULL;
325 }
326
327 for(i=0;i<count;i++) {
328 char *p;
329
330 /* Canonicalize link target.
331 * Replace all /'s in the path by a \ */
332 string_replace(alt_path[i], '/', '\\');
333
334 /* Remove leading '\\'s */
335 p = alt_path[i];
336 while (*p && (*p == '\\')) {
337 p++;
338 }
339
340 reflist[i].alternate_path = talloc_asprintf(ctx,
341 "\\%s",
342 p);
343 if (!reflist[i].alternate_path) {
344 return False;
345 }
346
347 reflist[i].proximity = 0;
348 reflist[i].ttl = REFERRAL_TTL;
349 DEBUG(10, ("parse_msdfs_symlink: Created alt path: %s\n",
350 reflist[i].alternate_path));
351 *refcount += 1;
352 }
353
354 TALLOC_FREE(alt_path);
355 return True;
356 }
357
358 /**********************************************************************
359 Returns true if the unix path is a valid msdfs symlink and also
360 returns the target string from inside the link.
361 **********************************************************************/
362
363 static bool is_msdfs_link_internal(TALLOC_CTX *ctx,
364 connection_struct *conn,
365 const char *path,
366 char **pp_link_target,
367 SMB_STRUCT_STAT *sbufp)
368 {
369 SMB_STRUCT_STAT st;
370 int referral_len = 0;
371 char link_target_buf[7];
372 size_t bufsize = 0;
373 char *link_target = NULL;
374
375 if (pp_link_target) {
376 bufsize = 1024;
377 link_target = TALLOC_ARRAY(ctx, char, bufsize);
378 if (!link_target) {
379 return False;
380 }
381 *pp_link_target = link_target;
382 } else {
383 bufsize = sizeof(link_target_buf);
384 link_target = link_target_buf;
385 }
386
387 if (sbufp == NULL) {
388 sbufp = &st;
389 }
390
391 if (SMB_VFS_LSTAT(conn, path, sbufp) != 0) {
392 DEBUG(5,("is_msdfs_link_read_target: %s does not exist.\n",
393 path));
394 goto err;
395 }
396
397 if (!S_ISLNK(sbufp->st_mode)) {
398 DEBUG(5,("is_msdfs_link_read_target: %s is not a link.\n",
399 path));
400 goto err;
401 }
402
403 referral_len = SMB_VFS_READLINK(conn, path, link_target, bufsize - 1);
404 if (referral_len == -1) {
405 DEBUG(0,("is_msdfs_link_read_target: Error reading "
406 "msdfs link %s: %s\n",
407 path, strerror(errno)));
408 goto err;
409 }
410 link_target[referral_len] = '\0';
411
412 DEBUG(5,("is_msdfs_link_internal: %s -> %s\n",path,
413 link_target));
414
415 if (!strnequal(link_target, "msdfs:", 6)) {
416 goto err;
417 }
418 return True;
419
420 err:
421
422 if (link_target != link_target_buf) {
423 TALLOC_FREE(link_target);
424 }
425 return False;
426 }
427
428 /**********************************************************************
429 Returns true if the unix path is a valid msdfs symlink.
430 **********************************************************************/
431
432 bool is_msdfs_link(connection_struct *conn,
433 const char *path,
434 SMB_STRUCT_STAT *sbufp)
435 {
436 return is_msdfs_link_internal(talloc_tos(),
437 conn,
438 path,
439 NULL,
440 sbufp);
441 }
442
443 /*****************************************************************
444 Used by other functions to decide if a dfs path is remote,
445 and to get the list of referred locations for that remote path.
446
447 search_flag: For findfirsts, dfs links themselves are not
448 redirected, but paths beyond the links are. For normal smb calls,
449 even dfs links need to be redirected.
450
451 consumedcntp: how much of the dfs path is being redirected. the client
452 should try the remaining path on the redirected server.
453
454 If this returns NT_STATUS_PATH_NOT_COVERED the contents of the msdfs
455 link redirect are in targetpath.
456 *****************************************************************/
457
458 static NTSTATUS dfs_path_lookup(TALLOC_CTX *ctx,
459 connection_struct *conn,
460 const char *dfspath, /* Incoming complete dfs path */
461 const struct dfs_path *pdp, /* Parsed out
462 server+share+extrapath. */
463 bool search_flag, /* Called from a findfirst ? */
464 int *consumedcntp,
465 char **pp_targetpath)
466 {
467 char *p = NULL;
468 char *q = NULL;
469 SMB_STRUCT_STAT sbuf;
470 NTSTATUS status;
471 char *localpath = NULL;
472 char *canon_dfspath = NULL; /* Canonicalized dfs path. (only '/'
473 components). */
474
475 DEBUG(10,("dfs_path_lookup: Conn path = %s reqpath = %s\n",
476 conn->connectpath, pdp->reqpath));
477
478 /*
479 * Note the unix path conversion here we're doing we can
480 * throw away. We're looking for a symlink for a dfs
481 * resolution, if we don't find it we'll do another
482 * unix_convert later in the codepath.
483 * If we needed to remember what we'd resolved in
484 * dp->reqpath (as the original code did) we'd
485 * copy (localhost, dp->reqpath) on any code
486 * path below that returns True - but I don't
487 * think this is needed. JRA.
488 */
489
490 status = unix_convert(ctx, conn, pdp->reqpath, search_flag, &localpath,
491 NULL, &sbuf);
492 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status,
493 NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
494 return status;
495 }
496
497 /* Optimization - check if we can redirect the whole path. */
498
499 if (is_msdfs_link_internal(ctx, conn, localpath, pp_targetpath, NULL)) {
500 if (search_flag) {
501 DEBUG(6,("dfs_path_lookup (FindFirst) No redirection "
502 "for dfs link %s.\n", dfspath));
503 return NT_STATUS_OK;
504 }
505
506 DEBUG(6,("dfs_path_lookup: %s resolves to a "
507 "valid dfs link %s.\n", dfspath,
508 pp_targetpath ? *pp_targetpath : ""));
509
510 if (consumedcntp) {
511 *consumedcntp = strlen(dfspath);
512 }
513 return NT_STATUS_PATH_NOT_COVERED;
514 }
515
516 /* Prepare to test only for '/' components in the given path,
517 * so if a Windows path replace all '\\' characters with '/'.
518 * For a POSIX DFS path we know all separators are already '/'. */
519
520 canon_dfspath = talloc_strdup(ctx, dfspath);
521 if (!canon_dfspath) {
522 return NT_STATUS_NO_MEMORY;
523 }
524 if (!pdp->posix_path) {
525 string_replace(canon_dfspath, '\\', '/');
526 }
527
528 /*
529 * localpath comes out of unix_convert, so it has
530 * no trailing backslash. Make sure that canon_dfspath hasn't either.
531 * Fix for bug #4860 from Jan Martin <Jan.Martin@rwedea.com>.
532 */
533
534 trim_char(canon_dfspath,0,'/');
535
536 /*
537 * Redirect if any component in the path is a link.
538 * We do this by walking backwards through the
539 * local path, chopping off the last component
540 * in both the local path and the canonicalized
541 * DFS path. If we hit a DFS link then we're done.
542 */
543
544 p = strrchr_m(localpath, '/');
545 if (consumedcntp) {
546 q = strrchr_m(canon_dfspath, '/');
547 }
548
549 while (p) {
550 *p = '\0';
551 if (q) {
552 *q = '\0';
553 }
554
555 if (is_msdfs_link_internal(ctx, conn,
556 localpath, pp_targetpath, NULL)) {
557 DEBUG(4, ("dfs_path_lookup: Redirecting %s because "
558 "parent %s is dfs link\n", dfspath, localpath));
559
560 if (consumedcntp) {
561 *consumedcntp = strlen(canon_dfspath);
562 DEBUG(10, ("dfs_path_lookup: Path consumed: %s "
563 "(%d)\n",
564 canon_dfspath,
565 *consumedcntp));
566 }
567
568 return NT_STATUS_PATH_NOT_COVERED;
569 }
570
571 /* Step back on the filesystem. */
572 p = strrchr_m(localpath, '/');
573
574 if (consumedcntp) {
575 /* And in the canonicalized dfs path. */
576 q = strrchr_m(canon_dfspath, '/');
577 }
578 }
579
580 return NT_STATUS_OK;
581 }
582
583 /*****************************************************************
584 Decides if a dfs pathname should be redirected or not.
585 If not, the pathname is converted to a tcon-relative local unix path
586
587 search_wcard_flag: this flag performs 2 functions both related
588 to searches. See resolve_dfs_path() and parse_dfs_path_XX()
589 for details.
590
591 This function can return NT_STATUS_OK, meaning use the returned path as-is
592 (mapped into a local path).
593 or NT_STATUS_NOT_COVERED meaning return a DFS redirect, or
594 any other NT_STATUS error which is a genuine error to be
595 returned to the client.
596 *****************************************************************/
597
598 static NTSTATUS dfs_redirect(TALLOC_CTX *ctx,
599 connection_struct *conn,
600 const char *path_in,
601 bool search_wcard_flag,
602 char **pp_path_out,
603 bool *ppath_contains_wcard)
604 {
605 NTSTATUS status;
606 struct dfs_path *pdp = TALLOC_P(ctx, struct dfs_path);
607
608 if (!pdp) {
609 return NT_STATUS_NO_MEMORY;
610 }
611
612 status = parse_dfs_path(path_in, search_wcard_flag, pdp,
613 ppath_contains_wcard);
614 if (!NT_STATUS_IS_OK(status)) {
615 TALLOC_FREE(pdp);
616 return status;
617 }
618
619 if (pdp->reqpath[0] == '\0') {
620 TALLOC_FREE(pdp);
621 *pp_path_out = talloc_strdup(ctx, "");
622 if (!*pp_path_out) {
623 return NT_STATUS_NO_MEMORY;
624 }
625 DEBUG(5,("dfs_redirect: self-referral.\n"));
626 return NT_STATUS_OK;
627 }
628
629 /* If dfs pathname for a non-dfs share, convert to tcon-relative
630 path and return OK */
631
632 if (!lp_msdfs_root(SNUM(conn))) {
633 *pp_path_out = talloc_strdup(ctx, pdp->reqpath);
634 TALLOC_FREE(pdp);
635 if (!*pp_path_out) {
636 return NT_STATUS_NO_MEMORY;
637 }
638 return NT_STATUS_OK;
639 }
640
641 /* If it looked like a local path (zero hostname/servicename)
642 * just treat as a tcon-relative path. */
643
644 if (pdp->hostname[0] == '\0' && pdp->servicename[0] == '\0') {
645 *pp_path_out = talloc_strdup(ctx, pdp->reqpath);
646 TALLOC_FREE(pdp);
647 if (!*pp_path_out) {
648 return NT_STATUS_NO_MEMORY;
649 }
650 return NT_STATUS_OK;
651 }
652
653 if (!( strequal(pdp->servicename, lp_servicename(SNUM(conn)))
654 || (strequal(pdp->servicename, HOMES_NAME)
655 && strequal(lp_servicename(SNUM(conn)),
656 get_current_username()) )) ) {
657
658 /* The given sharename doesn't match this connection. */
659 TALLOC_FREE(pdp);
660
661 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
662 }
663
664 status = dfs_path_lookup(ctx, conn, path_in, pdp,
665 search_wcard_flag, NULL, NULL);
666 if (!NT_STATUS_IS_OK(status)) {
667 if (NT_STATUS_EQUAL(status, NT_STATUS_PATH_NOT_COVERED)) {
668 DEBUG(3,("dfs_redirect: Redirecting %s\n", path_in));
669 } else {
670 DEBUG(10,("dfs_redirect: dfs_path_lookup "
671 "failed for %s with %s\n",
672 path_in, nt_errstr(status) ));
673 }
674 return status;
675 }
676
677 DEBUG(3,("dfs_redirect: Not redirecting %s.\n", path_in));
678
679 /* Form non-dfs tcon-relative path */
680 *pp_path_out = talloc_strdup(ctx, pdp->reqpath);
681 TALLOC_FREE(pdp);
682 if (!*pp_path_out) {
683 return NT_STATUS_NO_MEMORY;
684 }
685
686 DEBUG(3,("dfs_redirect: Path %s converted to non-dfs path %s\n",
687 path_in,
688 *pp_path_out));
689
690 return NT_STATUS_OK;
691 }
692
693 /**********************************************************************
694 Return a self referral.
695 **********************************************************************/
696
697 static NTSTATUS self_ref(TALLOC_CTX *ctx,
698 const char *dfs_path,
699 struct junction_map *jucn,
700 int *consumedcntp,
701 bool *self_referralp)
702 {
703 struct referral *ref;
704
705 *self_referralp = True;
706
707 jucn->referral_count = 1;
708 if((ref = TALLOC_ZERO_P(ctx, struct referral)) == NULL) {
709 return NT_STATUS_NO_MEMORY;
710 }
711
712 ref->alternate_path = talloc_strdup(ctx, dfs_path);
713 if (!ref->alternate_path) {
714 return NT_STATUS_NO_MEMORY;
715 }
716 ref->proximity = 0;
717 ref->ttl = REFERRAL_TTL;
718 jucn->referral_list = ref;
719 *consumedcntp = strlen(dfs_path);
720 return NT_STATUS_OK;
721 }
722
723 /**********************************************************************
724 Gets valid referrals for a dfs path and fills up the
725 junction_map structure.
726 **********************************************************************/
727
728 NTSTATUS get_referred_path(TALLOC_CTX *ctx,
729 const char *dfs_path,
730 struct junction_map *jucn,
731 int *consumedcntp,
732 bool *self_referralp)
733 {
734 struct connection_struct conns;
735 struct connection_struct *conn = &conns;
736 char *targetpath = NULL;
737 int snum;
738 NTSTATUS status = NT_STATUS_NOT_FOUND;
739 bool dummy;
740 struct dfs_path *pdp = TALLOC_P(ctx, struct dfs_path);
741
742 if (!pdp) {
743 return NT_STATUS_NO_MEMORY;
744 }
745
746 ZERO_STRUCT(conns);
747 *self_referralp = False;
748
749 status = parse_dfs_path(dfs_path, False, pdp, &dummy);
750 if (!NT_STATUS_IS_OK(status)) {
751 return status;
752 }
753
754 /* Verify hostname in path */
755 if (!is_myname_or_ipaddr(pdp->hostname)) {
756 DEBUG(3, ("get_referred_path: Invalid hostname %s in path %s\n",
757 pdp->hostname, dfs_path));
758 TALLOC_FREE(pdp);
759 return NT_STATUS_NOT_FOUND;
760 }
761
762 jucn->service_name = talloc_strdup(ctx, pdp->servicename);
763 jucn->volume_name = talloc_strdup(ctx, pdp->reqpath);
764 if (!jucn->service_name || !jucn->volume_name) {
765 TALLOC_FREE(pdp);
766 return NT_STATUS_NO_MEMORY;
767 }
768
769 /* Verify the share is a dfs root */
770 snum = lp_servicenumber(jucn->service_name);
771 if(snum < 0) {
772 fstring service_name;
773 fstrcpy(service_name, jucn->service_name);
774 if ((snum = find_service(service_name)) < 0) {
775 return NT_STATUS_NOT_FOUND;
776 }
777 TALLOC_FREE(jucn->service_name);
778 jucn->service_name = talloc_strdup(ctx, service_name);
779 if (!jucn->service_name) {
780 TALLOC_FREE(pdp);
781 return NT_STATUS_NO_MEMORY;
782 }
783 }
784
785 if (!lp_msdfs_root(snum) && (*lp_msdfs_proxy(snum) == '\0')) {
786 DEBUG(3,("get_referred_path: |%s| in dfs path %s is not "
787 "a dfs root.\n",
788 pdp->servicename, dfs_path));
789 TALLOC_FREE(pdp);
790 return NT_STATUS_NOT_FOUND;
791 }
792
793 /*
794 * Self referrals are tested with a anonymous IPC connection and
795 * a GET_DFS_REFERRAL call to \\server\share. (which means
796 * dp.reqpath[0] points to an empty string). create_conn_struct cd's
797 * into the directory and will fail if it cannot (as the anonymous
798 * user). Cope with this.
799 */
800
801 if (pdp->reqpath[0] == '\0') {
802 char *tmp;
803 struct referral *ref;
804
805 if (*lp_msdfs_proxy(snum) == '\0') {
806 TALLOC_FREE(pdp);
807 return self_ref(ctx,
808 dfs_path,
809 jucn,
810 consumedcntp,
811 self_referralp);
812 }
813
814 /*
815 * It's an msdfs proxy share. Redirect to
816 * the configured target share.
817 */
818
819 jucn->referral_count = 1;
820 if ((ref = TALLOC_ZERO_P(ctx, struct referral)) == NULL) {
821 TALLOC_FREE(pdp);
822 return NT_STATUS_NO_MEMORY;
823 }
824
825 if (!(tmp = talloc_strdup(ctx, lp_msdfs_proxy(snum)))) {
826 TALLOC_FREE(pdp);
827 return NT_STATUS_NO_MEMORY;
828 }
829
830 trim_string(tmp, "\\", 0);
831
832 ref->alternate_path = talloc_asprintf(ctx, "\\%s", tmp);
833 TALLOC_FREE(tmp);
834
835 if (!ref->alternate_path) {
836 TALLOC_FREE(pdp);
837 return NT_STATUS_NO_MEMORY;
838 }
839
840 if (pdp->reqpath[0] != '\0') {
841 ref->alternate_path = talloc_asprintf_append(
842 ref->alternate_path,
843 "%s",
844 pdp->reqpath);
845 if (!ref->alternate_path) {
846 TALLOC_FREE(pdp);
847 return NT_STATUS_NO_MEMORY;
848 }
849 }
850 ref->proximity = 0;
851 ref->ttl = REFERRAL_TTL;
852 jucn->referral_list = ref;
853 *consumedcntp = strlen(dfs_path);
854 TALLOC_FREE(pdp);
855 return NT_STATUS_OK;
856 }
857
858 status = create_conn_struct(ctx, conn, snum, lp_pathname(snum));
859 if (!NT_STATUS_IS_OK(status)) {
860 TALLOC_FREE(pdp);
861 return status;
862 }
863
864 /* If this is a DFS path dfs_lookup should return
865 * NT_STATUS_PATH_NOT_COVERED. */
866
867 status = dfs_path_lookup(ctx, conn, dfs_path, pdp,
868 False, consumedcntp, &targetpath);
869
870 if (!NT_STATUS_EQUAL(status, NT_STATUS_PATH_NOT_COVERED)) {
871 DEBUG(3,("get_referred_path: No valid referrals for path %s\n",
872 dfs_path));
873 conn_free_internal(conn);
874 TALLOC_FREE(pdp);
875 return status;
876 }
877
878 /* We know this is a valid dfs link. Parse the targetpath. */
879 if (!parse_msdfs_symlink(ctx, targetpath,
880 &jucn->referral_list,
881 &jucn->referral_count)) {
882 DEBUG(3,("get_referred_path: failed to parse symlink "
883 "target %s\n", targetpath ));
884 conn_free_internal(conn);
885 TALLOC_FREE(pdp);
886 return NT_STATUS_NOT_FOUND;
887 }
888
889 conn_free_internal(conn);
890 TALLOC_FREE(pdp);
891 return NT_STATUS_OK;
892 }
893
894 static int setup_ver2_dfs_referral(const char *pathname,
895 char **ppdata,
896 struct junction_map *junction,
897 int consumedcnt,
898 bool self_referral)
899 {
900 char* pdata = *ppdata;
901
902 smb_ucs2_t *uni_requestedpath = NULL;
903 int uni_reqpathoffset1,uni_reqpathoffset2;
904 int uni_curroffset;
905 int requestedpathlen=0;
906 int offset;
907 int reply_size = 0;
908 int i=0;
909
910 DEBUG(10,("Setting up version2 referral\nRequested path:\n"));
911
912 requestedpathlen = rpcstr_push_talloc(talloc_tos(),
913 &uni_requestedpath, pathname);
914 if (uni_requestedpath == NULL || requestedpathlen == 0) {
915 return -1;
916 }
917
918 if (DEBUGLVL(10)) {
919 dump_data(0, (unsigned char *)uni_requestedpath,
920 requestedpathlen);
921 }
922
923 DEBUG(10,("ref count = %u\n",junction->referral_count));
924
925 uni_reqpathoffset1 = REFERRAL_HEADER_SIZE +
926 VERSION2_REFERRAL_SIZE * junction->referral_count;
927
928 uni_reqpathoffset2 = uni_reqpathoffset1 + requestedpathlen;
929
930 uni_curroffset = uni_reqpathoffset2 + requestedpathlen;
931
932 reply_size = REFERRAL_HEADER_SIZE +
933 VERSION2_REFERRAL_SIZE*junction->referral_count +
934 2 * requestedpathlen;
935 DEBUG(10,("reply_size: %u\n",reply_size));
936
937 /* add up the unicode lengths of all the referral paths */
938 for(i=0;i<junction->referral_count;i++) {
939 DEBUG(10,("referral %u : %s\n",
940 i,
941 junction->referral_list[i].alternate_path));
942 reply_size +=
943 (strlen(junction->referral_list[i].alternate_path)+1)*2;
944 }
945
946 DEBUG(10,("reply_size = %u\n",reply_size));
947 /* add the unexplained 0x16 bytes */
948 reply_size += 0x16;
949
950 pdata = (char *)SMB_REALLOC(pdata,reply_size);
951 if(pdata == NULL) {
952 DEBUG(0,("Realloc failed!\n"));
953 return -1;
954 }
955 *ppdata = pdata;
956
957 /* copy in the dfs requested paths.. required for offset calculations */
958 memcpy(pdata+uni_reqpathoffset1,uni_requestedpath,requestedpathlen);
959 memcpy(pdata+uni_reqpathoffset2,uni_requestedpath,requestedpathlen);
960
961 /* create the header */
962 SSVAL(pdata,0,consumedcnt * 2); /* path consumed */
963 /* number of referral in this pkt */
964 SSVAL(pdata,2,junction->referral_count);
965 if(self_referral) {
966 SIVAL(pdata,4,DFSREF_REFERRAL_SERVER | DFSREF_STORAGE_SERVER);
967 } else {
968 SIVAL(pdata,4,DFSREF_STORAGE_SERVER);
969 }
970
971 offset = 8;
972 /* add the referral elements */
973 for(i=0;i<junction->referral_count;i++) {
974 struct referral* ref = &junction->referral_list[i];
975 int unilen;
976
977 SSVAL(pdata,offset,2); /* version 2 */
978 SSVAL(pdata,offset+2,VERSION2_REFERRAL_SIZE);
979 if(self_referral) {
980 SSVAL(pdata,offset+4,1);
981 } else {
982 SSVAL(pdata,offset+4,0);
983 }
984
985 /* ref_flags :use path_consumed bytes? */
986 SSVAL(pdata,offset+6,0);
987 SIVAL(pdata,offset+8,ref->proximity);
988 SIVAL(pdata,offset+12,ref->ttl);
989
990 SSVAL(pdata,offset+16,uni_reqpathoffset1-offset);
991 SSVAL(pdata,offset+18,uni_reqpathoffset2-offset);
992 /* copy referred path into current offset */
993 unilen = rpcstr_push(pdata+uni_curroffset,
994 ref->alternate_path,
995 reply_size - uni_curroffset,
996 STR_UNICODE);
997
998 SSVAL(pdata,offset+20,uni_curroffset-offset);
999
1000 uni_curroffset += unilen;
1001 offset += VERSION2_REFERRAL_SIZE;
1002 }
1003 /* add in the unexplained 22 (0x16) bytes at the end */
1004 memset(pdata+uni_curroffset,'\0',0x16);
1005 return reply_size;
1006 }
1007
1008 static int setup_ver3_dfs_referral(const char *pathname,
1009 char **ppdata,
1010 struct junction_map *junction,
1011 int consumedcnt,
1012 bool self_referral)
1013 {
1014 char *pdata = *ppdata;
1015
1016 smb_ucs2_t *uni_reqpath = NULL;
1017 int uni_reqpathoffset1, uni_reqpathoffset2;
1018 int uni_curroffset;
1019 int reply_size = 0;
1020
1021 int reqpathlen = 0;
1022 int offset,i=0;
1023
1024 DEBUG(10,("setting up version3 referral\n"));
1025
1026 reqpathlen = rpcstr_push_talloc(talloc_tos(), &uni_reqpath, pathname);
1027 if (uni_reqpath == NULL || reqpathlen == 0) {
1028 return -1;
1029 }
1030
1031 if (DEBUGLVL(10)) {
1032 dump_data(0, (unsigned char *)uni_reqpath,
1033 reqpathlen);
1034 }
1035
1036 uni_reqpathoffset1 = REFERRAL_HEADER_SIZE +
1037 VERSION3_REFERRAL_SIZE * junction->referral_count;
1038 uni_reqpathoffset2 = uni_reqpathoffset1 + reqpathlen;
1039 reply_size = uni_curroffset = uni_reqpathoffset2 + reqpathlen;
1040
1041 for(i=0;i<junction->referral_count;i++) {
1042 DEBUG(10,("referral %u : %s\n",
1043 i,
1044 junction->referral_list[i].alternate_path));
1045 reply_size +=
1046 (strlen(junction->referral_list[i].alternate_path)+1)*2;
1047 }
1048
1049 pdata = (char *)SMB_REALLOC(pdata,reply_size);
1050 if(pdata == NULL) {
1051 DEBUG(0,("version3 referral setup:"
1052 "malloc failed for Realloc!\n"));
1053 return -1;
1054 }
1055 *ppdata = pdata;
1056
1057 /* create the header */
1058 SSVAL(pdata,0,consumedcnt * 2); /* path consumed */
1059 SSVAL(pdata,2,junction->referral_count); /* number of referral */
1060 if(self_referral) {
1061 SIVAL(pdata,4,DFSREF_REFERRAL_SERVER | DFSREF_STORAGE_SERVER);
1062 } else {
1063 SIVAL(pdata,4,DFSREF_STORAGE_SERVER);
1064 }
1065
1066 /* copy in the reqpaths */
1067 memcpy(pdata+uni_reqpathoffset1,uni_reqpath,reqpathlen);
1068 memcpy(pdata+uni_reqpathoffset2,uni_reqpath,reqpathlen);
1069
1070 offset = 8;
1071 for(i=0;i<junction->referral_count;i++) {
1072 struct referral* ref = &(junction->referral_list[i]);
1073 int unilen;
1074
1075 SSVAL(pdata,offset,3); /* version 3 */
1076 SSVAL(pdata,offset+2,VERSION3_REFERRAL_SIZE);
1077 if(self_referral) {
1078 SSVAL(pdata,offset+4,1);
1079 } else {
1080 SSVAL(pdata,offset+4,0);
1081 }
1082
1083 /* ref_flags :use path_consumed bytes? */
1084 SSVAL(pdata,offset+6,0);
1085 SIVAL(pdata,offset+8,ref->ttl);
1086
1087 SSVAL(pdata,offset+12,uni_reqpathoffset1-offset);
1088 SSVAL(pdata,offset+14,uni_reqpathoffset2-offset);
1089 /* copy referred path into current offset */
1090 unilen = rpcstr_push(pdata+uni_curroffset,ref->alternate_path,
1091 reply_size - uni_curroffset,
1092 STR_UNICODE | STR_TERMINATE);
1093 SSVAL(pdata,offset+16,uni_curroffset-offset);
1094 /* copy 0x10 bytes of 00's in the ServiceSite GUID */
1095 memset(pdata+offset+18,'\0',16);
1096
1097 uni_curroffset += unilen;
1098 offset += VERSION3_REFERRAL_SIZE;
1099 }
1100 return reply_size;
1101 }
1102
1103 /******************************************************************
1104 Set up the DFS referral for the dfs pathname. This call returns
1105 the amount of the path covered by this server, and where the
1106 client should be redirected to. This is the meat of the
1107 TRANS2_GET_DFS_REFERRAL call.
1108 ******************************************************************/
1109
1110 int setup_dfs_referral(connection_struct *orig_conn,
1111 const char *dfs_path,
1112 int max_referral_level,
1113 char **ppdata, NTSTATUS *pstatus)
1114 {
1115 struct junction_map *junction = NULL;
1116 int consumedcnt = 0;
1117 bool self_referral = False;
1118 int reply_size = 0;
1119 char *pathnamep = NULL;
1120 char *local_dfs_path = NULL;
1121 TALLOC_CTX *ctx;
1122
1123 if (!(ctx=talloc_init("setup_dfs_referral"))) {
1124 *pstatus = NT_STATUS_NO_MEMORY;
1125 return -1;
1126 }
1127
1128 /* get the junction entry */
1129 if (!dfs_path) {
1130 talloc_destroy(ctx);
1131 *pstatus = NT_STATUS_NOT_FOUND;
1132 return -1;
1133 }
1134
1135 /*
1136 * Trim pathname sent by client so it begins with only one backslash.
1137 * Two backslashes confuse some dfs clients
1138 */
1139
1140 local_dfs_path = talloc_strdup(ctx,dfs_path);
1141 if (!local_dfs_path) {
1142 *pstatus = NT_STATUS_NO_MEMORY;
1143 talloc_destroy(ctx);
1144 return -1;
1145 }
1146 pathnamep = local_dfs_path;
1147 while (IS_DIRECTORY_SEP(pathnamep[0]) &&
1148 IS_DIRECTORY_SEP(pathnamep[1])) {
1149 pathnamep++;
1150 }
1151
1152 junction = TALLOC_ZERO_P(ctx, struct junction_map);
1153 if (!junction) {
1154 *pstatus = NT_STATUS_NO_MEMORY;
1155 talloc_destroy(ctx);
1156 return -1;
1157 }
1158
1159 /* The following call can change cwd. */
1160 *pstatus = get_referred_path(ctx, pathnamep, junction,
1161 &consumedcnt, &self_referral);
1162 if (!NT_STATUS_IS_OK(*pstatus)) {
1163 vfs_ChDir(orig_conn,orig_conn->connectpath);
1164 talloc_destroy(ctx);
1165 return -1;
1166 }
1167 vfs_ChDir(orig_conn,orig_conn->connectpath);
1168
1169 if (!self_referral) {
1170 pathnamep[consumedcnt] = '\0';
1171
1172 if( DEBUGLVL( 3 ) ) {
1173 int i=0;
1174 dbgtext("setup_dfs_referral: Path %s to "
1175 "alternate path(s):",
1176 pathnamep);
1177 for(i=0;i<junction->referral_count;i++)
1178 dbgtext(" %s",
1179 junction->referral_list[i].alternate_path);
1180 dbgtext(".\n");
1181 }
1182 }
1183
1184 /* create the referral depeding on version */
1185 DEBUG(10,("max_referral_level :%d\n",max_referral_level));
1186
1187 if (max_referral_level < 2) {
1188 max_referral_level = 2;
1189 }
1190 if (max_referral_level > 3) {
1191 max_referral_level = 3;
1192 }
1193
1194 switch(max_referral_level) {
1195 case 2:
1196 reply_size = setup_ver2_dfs_referral(pathnamep,
1197 ppdata, junction,
1198 consumedcnt, self_referral);
1199 break;
1200 case 3:
1201 reply_size = setup_ver3_dfs_referral(pathnamep, ppdata,
1202 junction, consumedcnt, self_referral);
1203 break;
1204 default:
1205 DEBUG(0,("setup_dfs_referral: Invalid dfs referral "
1206 "version: %d\n",
1207 max_referral_level));
1208 talloc_destroy(ctx);
1209 *pstatus = NT_STATUS_INVALID_LEVEL;
1210 return -1;
1211 }
1212
1213 if (DEBUGLVL(10)) {
1214 DEBUGADD(0,("DFS Referral pdata:\n"));
1215 dump_data(0,(uint8 *)*ppdata,reply_size);
1216 }
1217
1218 talloc_destroy(ctx);
1219 *pstatus = NT_STATUS_OK;
1220 return reply_size;
1221 }
1222
1223 /**********************************************************************
1224 The following functions are called by the NETDFS RPC pipe functions
1225 **********************************************************************/
1226
1227 /*********************************************************************
1228 Creates a junction structure from a DFS pathname
1229 **********************************************************************/
1230
1231 bool create_junction(TALLOC_CTX *ctx,
1232 const char *dfs_path,
1233 struct junction_map *jucn)
1234 {
1235 int snum;
1236 bool dummy;
1237 struct dfs_path *pdp = TALLOC_P(ctx,struct dfs_path);
1238 NTSTATUS status;
1239
1240 if (!pdp) {
1241 return False;
1242 }
1243 status = parse_dfs_path(dfs_path, False, pdp, &dummy);
1244 if (!NT_STATUS_IS_OK(status)) {
1245 return False;
1246 }
1247
1248 /* check if path is dfs : validate first token */
1249 if (!is_myname_or_ipaddr(pdp->hostname)) {
1250 DEBUG(4,("create_junction: Invalid hostname %s "
1251 "in dfs path %s\n",
1252 pdp->hostname, dfs_path));
1253 TALLOC_FREE(pdp);
1254 return False;
1255 }
1256
1257 /* Check for a non-DFS share */
1258 snum = lp_servicenumber(pdp->servicename);
1259
1260 if(snum < 0 || !lp_msdfs_root(snum)) {
1261 DEBUG(4,("create_junction: %s is not an msdfs root.\n",
1262 pdp->servicename));
1263 TALLOC_FREE(pdp);
1264 return False;
1265 }
1266
1267 jucn->service_name = talloc_strdup(ctx, pdp->servicename);
1268 jucn->volume_name = talloc_strdup(ctx, pdp->reqpath);
1269 jucn->comment = talloc_strdup(ctx, lp_comment(snum));
1270
1271 TALLOC_FREE(pdp);
1272 if (!jucn->service_name || !jucn->volume_name || ! jucn->comment) {
1273 return False;
1274 }
1275 return True;
1276 }
1277
1278 /**********************************************************************
1279 Forms a valid Unix pathname from the junction
1280 **********************************************************************/
1281
1282 static bool junction_to_local_path(const struct junction_map *jucn,
1283 char **pp_path_out,
1284 connection_struct *conn_out)
1285 {
1286 int snum;
1287
1288 snum = lp_servicenumber(jucn->service_name);
1289 if(snum < 0) {
1290 return False;
1291 }
1292 if (!NT_STATUS_IS_OK(create_conn_struct(talloc_tos(),
1293 conn_out, snum,
1294 lp_pathname(snum)))) {
1295 return False;
1296 }
1297
1298 *pp_path_out = talloc_asprintf(conn_out->mem_ctx,
1299 "%s/%s",
1300 lp_pathname(snum),
1301 jucn->volume_name);
1302 if (!*pp_path_out) {
1303 return False;
1304 }
1305 return True;
1306 }
1307
1308 bool create_msdfs_link(const struct junction_map *jucn,
1309 bool exists)
1310 {
1311 char *path = NULL;
1312 char *msdfs_link = NULL;
1313 connection_struct conns;
1314 connection_struct *conn = &conns;
1315 int i=0;
1316 bool insert_comma = False;
1317 bool ret = False;
1318
1319 ZERO_STRUCT(conns);
1320
1321 if(!junction_to_local_path(jucn, &path, conn)) {
1322 return False;
1323 }
1324
1325 /* Form the msdfs_link contents */
1326 msdfs_link = talloc_strdup(conn->mem_ctx, "msdfs:");
1327 if (!msdfs_link) {
1328 goto out;
1329 }
1330 for(i=0; i<jucn->referral_count; i++) {
1331 char *refpath = jucn->referral_list[i].alternate_path;
1332
1333 /* Alternate paths always use Windows separators. */
1334 trim_char(refpath, '\\', '\\');
1335 if(*refpath == '\0') {
1336 if (i == 0) {
1337 insert_comma = False;
1338 }
1339 continue;
1340 }
1341 if (i > 0 && insert_comma) {
1342 msdfs_link = talloc_asprintf_append_buffer(msdfs_link,
1343 ",%s",
1344 refpath);
1345 } else {
1346 msdfs_link = talloc_asprintf_append_buffer(msdfs_link,
1347 "%s",
1348 refpath);
1349 }
1350
1351 if (!msdfs_link) {
1352 goto out;
1353 }
1354 if (!insert_comma) {
1355 insert_comma = True;
1356 }
1357 }
1358
1359 DEBUG(5,("create_msdfs_link: Creating new msdfs link: %s -> %s\n",
1360 path, msdfs_link));
1361
1362 if(exists) {
1363 if(SMB_VFS_UNLINK(conn,path)!=0) {
1364 goto out;
1365 }
1366 }
1367
1368 if(SMB_VFS_SYMLINK(conn, msdfs_link, path) < 0) {
1369 DEBUG(1,("create_msdfs_link: symlink failed "
1370 "%s -> %s\nError: %s\n",
1371 path, msdfs_link, strerror(errno)));
1372 goto out;
1373 }
1374
1375 ret = True;
1376
1377 out:
1378
1379 conn_free_internal(conn);
1380 return ret;
1381 }
1382
1383 bool remove_msdfs_link(const struct junction_map *jucn)
1384 {
1385 char *path = NULL;
1386 connection_struct conns;
1387 connection_struct *conn = &conns;
1388 bool ret = False;
1389
1390 ZERO_STRUCT(conns);
1391
1392 if( junction_to_local_path(jucn, &path, conn) ) {
1393 if( SMB_VFS_UNLINK(conn, path) == 0 ) {
1394 ret = True;
1395 }
1396 }
1397
1398 conn_free_internal(conn);
1399 return ret;
1400 }
1401
1402 /*********************************************************************
1403 Return the number of DFS links at the root of this share.
1404 *********************************************************************/
1405
1406 static int count_dfs_links(TALLOC_CTX *ctx, int snum)
1407 {
1408 size_t cnt = 0;
1409 SMB_STRUCT_DIR *dirp = NULL;
1410 char *dname = NULL;
1411 const char *connect_path = lp_pathname(snum);
1412 const char *msdfs_proxy = lp_msdfs_proxy(snum);
1413 connection_struct conn;
1414
1415 ZERO_STRUCT(conn);
1416
1417 if(*connect_path == '\0') {
1418 return 0;
1419 }
1420
1421 /*
1422 * Fake up a connection struct for the VFS layer.
1423 */
1424
1425 if (!NT_STATUS_IS_OK(create_conn_struct(talloc_tos(),
1426 &conn, snum, connect_path))) {
1427 return 0;
1428 }
1429
1430 /* Count a link for the msdfs root - convention */
1431 cnt = 1;
1432
1433 /* No more links if this is an msdfs proxy. */
1434 if (*msdfs_proxy != '\0') {
1435 goto out;
1436 }
1437
1438 /* Now enumerate all dfs links */
1439 dirp = SMB_VFS_OPENDIR(&conn, ".", NULL, 0);
1440 if(!dirp) {
1441 goto out;
1442 }
1443
1444 while ((dname = vfs_readdirname(&conn, dirp)) != NULL) {
1445 if (is_msdfs_link(&conn,
1446 dname,
1447 NULL)) {
1448 cnt++;
1449 }
1450 }
1451
1452 SMB_VFS_CLOSEDIR(&conn,dirp);
1453
1454 out:
1455
1456 conn_free_internal(&conn);
1457 return cnt;
1458 }
1459
1460 /*********************************************************************
1461 *********************************************************************/
1462
1463 static int form_junctions(TALLOC_CTX *ctx,
1464 int snum,
1465 struct junction_map *jucn,
1466 size_t jn_remain)
1467 {
1468 size_t cnt = 0;
1469 SMB_STRUCT_DIR *dirp = NULL;
1470 char *dname = NULL;
1471 const char *connect_path = lp_pathname(snum);
1472 char *service_name = lp_servicename(snum);
1473 const char *msdfs_proxy = lp_msdfs_proxy(snum);
1474 connection_struct conn;
1475 struct referral *ref = NULL;
1476
1477 ZERO_STRUCT(conn);
1478
1479 if (jn_remain == 0) {
1480 return 0;
1481 }
1482
1483 if(*connect_path == '\0') {
1484 return 0;
1485 }
1486
1487 /*
1488 * Fake up a connection struct for the VFS layer.
1489 */
1490
1491 if (!NT_STATUS_IS_OK(create_conn_struct(ctx, &conn, snum, connect_path))) {
1492 return 0;
1493 }
1494
1495 /* form a junction for the msdfs root - convention
1496 DO NOT REMOVE THIS: NT clients will not work with us
1497 if this is not present
1498 */
1499 jucn[cnt].service_name = talloc_strdup(ctx,service_name);
1500 jucn[cnt].volume_name = talloc_strdup(ctx, "");
1501 if (!jucn[cnt].service_name || jucn[cnt].volume_name) {
1502 goto out;
1503 }
1504 jucn[cnt].referral_count = 1;
1505
1506 ref = jucn[cnt].referral_list = TALLOC_ZERO_P(ctx, struct referral);
1507 if (jucn[cnt].referral_list == NULL) {
1508 goto out;
1509 }
1510
1511 ref->proximity = 0;
1512 ref->ttl = REFERRAL_TTL;
1513 if (*msdfs_proxy != '\0') {
1514 ref->alternate_path = talloc_strdup(ctx,
1515 msdfs_proxy);
1516 } else {
1517 ref->alternate_path = talloc_asprintf(ctx,
1518 "\\\\%s\\%s",
1519 get_local_machine_name(),
1520 service_name);
1521 }
1522
1523 if (!ref->alternate_path) {
1524 goto out;
1525 }
1526 cnt++;
1527
1528 /* Don't enumerate if we're an msdfs proxy. */
1529 if (*msdfs_proxy != '\0') {
1530 goto out;
1531 }
1532
1533 /* Now enumerate all dfs links */
1534 dirp = SMB_VFS_OPENDIR(&conn, ".", NULL, 0);
1535 if(!dirp) {
1536 goto out;
1537 }
1538
1539 while ((dname = vfs_readdirname(&conn, dirp)) != NULL) {
1540 char *link_target = NULL;
1541 if (cnt >= jn_remain) {
1542 SMB_VFS_CLOSEDIR(&conn,dirp);
1543 DEBUG(2, ("form_junctions: ran out of MSDFS "
1544 "junction slots"));
1545 goto out;
1546 }
1547 if (is_msdfs_link_internal(ctx,
1548 &conn,
1549 dname, &link_target,
1550 NULL)) {
1551 if (parse_msdfs_symlink(ctx,
1552 link_target,
1553 &jucn[cnt].referral_list,
1554 &jucn[cnt].referral_count)) {
1555
1556 jucn[cnt].service_name = talloc_strdup(ctx,
1557 service_name);
1558 jucn[cnt].volume_name = talloc_strdup(ctx,
1559 dname);
1560 if (!jucn[cnt].service_name ||
1561 !jucn[cnt].volume_name) {
1562 goto out;
1563 }
1564 cnt++;
1565 }
1566 }
1567 }
1568
1569 out:
1570
1571 if (dirp) {
1572 SMB_VFS_CLOSEDIR(&conn,dirp);
1573 }
1574
1575 conn_free_internal(&conn);
1576 return cnt;
1577 }
1578
1579 struct junction_map *enum_msdfs_links(TALLOC_CTX *ctx, size_t *p_num_jn)
1580 {
1581 struct junction_map *jn = NULL;
1582 int i=0;
1583 size_t jn_count = 0;
1584 int sharecount = 0;
1585
1586 *p_num_jn = 0;
1587 if(!lp_host_msdfs()) {
1588 return NULL;
1589 }
1590
1591 /* Ensure all the usershares are loaded. */
1592 become_root();
1593 load_registry_shares();
1594 sharecount = load_usershare_shares();
1595 unbecome_root();
1596
1597 for(i=0;i < sharecount;i++) {
1598 if(lp_msdfs_root(i)) {
1599 jn_count += count_dfs_links(ctx, i);
1600 }
1601 }
1602 if (jn_count == 0) {
1603 return NULL;
1604 }
1605 jn = TALLOC_ARRAY(ctx, struct junction_map, jn_count);
1606 if (!jn) {
1607 return NULL;
1608 }
1609 for(i=0; i < sharecount; i++) {
1610 if (*p_num_jn >= jn_count) {
1611 break;
1612 }
1613 if(lp_msdfs_root(i)) {
1614 *p_num_jn += form_junctions(ctx, i,
1615 &jn[*p_num_jn],
1616 jn_count - *p_num_jn);
1617 }
1618 }
1619 return jn;
1620 }
1621
1622 /******************************************************************************
1623 Core function to resolve a dfs pathname.
1624 ******************************************************************************/
1625
1626 NTSTATUS resolve_dfspath(TALLOC_CTX *ctx,
1627 connection_struct *conn,
1628 bool dfs_pathnames,
1629 const char *name_in,
1630 char **pp_name_out)
1631 {
1632 NTSTATUS status = NT_STATUS_OK;
1633 bool dummy;
1634 if (dfs_pathnames) {
1635 status = dfs_redirect(ctx,
1636 conn,
1637 name_in,
1638 False,
1639 pp_name_out,
1640 &dummy);
1641 } else {
1642 /*
1643 * Cheat and just return a copy of the in ptr.
1644 * Once srvstr_get_path() uses talloc it'll
1645 * be a talloced ptr anyway.
1646 */
1647 *pp_name_out = CONST_DISCARD(char *,name_in);
1648 }
1649 return status;
1650 }
1651
1652 /******************************************************************************
1653 Core function to resolve a dfs pathname possibly containing a wildcard.
1654 This function is identical to the above except for the bool param to
1655 dfs_redirect but I need this to be separate so it's really clear when
1656 we're allowing wildcards and when we're not. JRA.
1657 ******************************************************************************/
1658
1659 NTSTATUS resolve_dfspath_wcard(TALLOC_CTX *ctx,
1660 connection_struct *conn,
1661 bool dfs_pathnames,
1662 const char *name_in,
1663 char **pp_name_out,
1664 bool *ppath_contains_wcard)
1665 {
1666 NTSTATUS status = NT_STATUS_OK;
1667 if (dfs_pathnames) {
1668 status = dfs_redirect(ctx,
1669 conn,
1670 name_in,
1671 True,
1672 pp_name_out,
1673 ppath_contains_wcard);
1674 } else {
1675 /*
1676 * Cheat and just return a copy of the in ptr.
1677 * Once srvstr_get_path() uses talloc it'll
1678 * be a talloced ptr anyway.
1679 */
1680 *pp_name_out = CONST_DISCARD(char *,name_in);
1681 }
1682 return status;
1683 }
reg import