Context Navigation

source: branches/samba-3.2.x/source/smbd/msdfs.c@ 621

Visit:

Last change on this file since 621 was 272, checked in by Herwig Bauernfeind, 16 years ago
Update 3.2 to 3.2.12
File size: 42.7 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: