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