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