Context Navigation

source: branches/samba-3.2.x/source/smbd/filename.c@ 587

Visit:

Last change on this file since 587 was 228, checked in by Herwig Bauernfeind, 16 years ago
Update 3.2 branch to 3.2.6
File size: 24.7 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	filename handling routines
4	Copyright (C) Andrew Tridgell 1992-1998
5	Copyright (C) Jeremy Allison 1999-2007
6	Copyright (C) Ying Chen 2000
7	Copyright (C) Volker Lendecke 2007
8
9	This program is free software; you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation; either version 3 of the License, or
12	(at your option) any later version.
13
14	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.
18
19	You should have received a copy of the GNU General Public License
20	along with this program. If not, see <http://www.gnu.org/licenses/>.
21	*/
22
23	/*
24	* New hash table stat cache code added by Ying Chen.
25	*/
26
27	#include "includes.h"
28
29	static bool scan_directory(connection_struct conn, const char path,
30	char name, char *found_name);
31	static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
32	connection_struct *conn,
33	const char *orig_path,
34	const char *basepath,
35	const char *streamname,
36	SMB_STRUCT_STAT *pst,
37	char **path);
38
39	/****************************************************************************
40	Mangle the 2nd name and check if it is then equal to the first name.
41	****************************************************************************/
42
43	static bool mangled_equal(const char *name1,
44	const char *name2,
45	const struct share_params *p)
46	{
47	char mname[13];
48
49	if (!name_to_8_3(name2, mname, False, p)) {
50	return False;
51	}
52	return strequal(name1, mname);
53	}
54
55	/****************************************************************************
56	Cope with the differing wildcard and non-wildcard error cases.
57	****************************************************************************/
58
59	static NTSTATUS determine_path_error(const char *name,
60	bool allow_wcard_last_component)
61	{
62	const char *p;
63
64	if (!allow_wcard_last_component) {
65	/* Error code within a pathname. */
66	return NT_STATUS_OBJECT_PATH_NOT_FOUND;
67	}
68
69	/* We're terminating here so we
70	* can be a little slower and get
71	* the error code right. Windows
72	* treats the last part of the pathname
73	* separately I think, so if the last
74	* component is a wildcard then we treat
75	* this ./ as "end of component" */
76
77	p = strchr(name, '/');
78
79	if (!p && (ms_has_wild(name) \|\| ISDOT(name))) {
80	/* Error code at the end of a pathname. */
81	return NT_STATUS_OBJECT_NAME_INVALID;
82	} else {
83	/* Error code within a pathname. */
84	return NT_STATUS_OBJECT_PATH_NOT_FOUND;
85	}
86	}
87
88	/****************************************************************************
89	This routine is called to convert names from the dos namespace to unix
90	namespace. It needs to handle any case conversions, mangling, format
91	changes etc.
92
93	We assume that we have already done a chdir() to the right "root" directory
94	for this service.
95
96	The function will return an NTSTATUS error if some part of the name except for
97	the last part cannot be resolved, else NT_STATUS_OK.
98
99	Note NT_STATUS_OK doesn't mean the name exists or is valid, just that we didn't
100	get any fatal errors that should immediately terminate the calling
101	SMB processing whilst resolving.
102
103	If the saved_last_component != 0, then the unmodified last component
104	of the pathname is returned there. If saved_last_component == 0 then nothing
105	is returned there.
106
107	If last_component_wcard is true then a MS wildcard was detected and
108	should be allowed in the last component of the path only.
109
110	On exit from unix_convert, if *pst was not null, then the file stat
111	struct will be returned if the file exists and was found, if not this
112	stat struct will be filled with zeros (and this can be detected by checking
113	for nlinks = 0, which can never be true for any file).
114	****************************************************************************/
115
116	NTSTATUS unix_convert(TALLOC_CTX *ctx,
117	connection_struct *conn,
118	const char *orig_path,
119	bool allow_wcard_last_component,
120	char **pp_conv_path,
121	char **pp_saved_last_component,
122	SMB_STRUCT_STAT *pst)
123	{
124	SMB_STRUCT_STAT st;
125	char start, end;
126	char *dirpath = NULL;
127	char *name = NULL;
128	char *stream = NULL;
129	bool component_was_mangled = False;
130	bool name_has_wildcard = False;
131	NTSTATUS result;
132
133	SET_STAT_INVALID(*pst);
134	*pp_conv_path = NULL;
135	if(pp_saved_last_component) {
136	*pp_saved_last_component = NULL;
137	}
138
139	if (conn->printer) {
140	/* we don't ever use the filenames on a printer share as a
141	filename - so don't convert them */
142	if (!(*pp_conv_path = talloc_strdup(ctx,orig_path))) {
143	return NT_STATUS_NO_MEMORY;
144	}
145	return NT_STATUS_OK;
146	}
147
148	DEBUG(5, ("unix_convert called on file \"%s\"\n", orig_path));
149
150	/*
151	* Conversion to basic unix format is already done in
152	* check_path_syntax().
153	*/
154
155	/*
156	* Names must be relative to the root of the service - any leading /.
157	* and trailing /'s should have been trimmed by check_path_syntax().
158	*/
159
160	#ifdef DEVELOPER
161	SMB_ASSERT(*orig_path != '/');
162	#endif
163
164	/*
165	* If we trimmed down to a single '\0' character
166	* then we should use the "." directory to avoid
167	* searching the cache, but not if we are in a
168	* printing share.
169	* As we know this is valid we can return true here.
170	*/
171
172	if (!*orig_path) {
173	if (!(name = talloc_strdup(ctx,"."))) {
174	return NT_STATUS_NO_MEMORY;
175	}
176	if (SMB_VFS_STAT(conn,name,&st) == 0) {
177	*pst = st;
178	} else {
179	return map_nt_error_from_unix(errno);
180	}
181	DEBUG(5,("conversion finished \"\" -> %s\n",name));
182	goto done;
183	}
184
185	if (orig_path[0] == '.' && (orig_path[1] == '/' \|\|
186	orig_path[1] == '\0')) {
187	/* Start of pathname can't be "." only. */
188	if (orig_path[1] == '\0' \|\| orig_path[2] == '\0') {
189	result = NT_STATUS_OBJECT_NAME_INVALID;
190	} else {
191	result =determine_path_error(
192	&orig_path[2], allow_wcard_last_component);
193	}
194	return result;
195	}
196
197	if (!(name = talloc_strdup(ctx, orig_path))) {
198	DEBUG(0, ("talloc_strdup failed\n"));
199	return NT_STATUS_NO_MEMORY;
200	}
201
202	/*
203	* Large directory fix normalization. If we're case sensitive, and
204	* the case preserving parameters are set to "no", normalize the case of
205	* the incoming filename from the client WHETHER IT EXISTS OR NOT !
206	* This is in conflict with the current (3.0.20) man page, but is
207	* what people expect from the "large directory howto". I'll update
208	* the man page. Thanks to jht@samba.org for finding this. JRA.
209	*/
210
211	if (conn->case_sensitive && !conn->case_preserve &&
212	!conn->short_case_preserve) {
213	strnorm(name, lp_defaultcase(SNUM(conn)));
214	}
215
216	/*
217	* Ensure saved_last_component is valid even if file exists.
218	*/
219
220	if(pp_saved_last_component) {
221	end = strrchr_m(name, '/');
222	if (end) {
223	*pp_saved_last_component = talloc_strdup(ctx, end + 1);
224	} else {
225	*pp_saved_last_component = talloc_strdup(ctx,
226	name);
227	}
228	}
229
230	if (!lp_posix_pathnames()) {
231	stream = strchr_m(name, ':');
232
233	if (stream != NULL) {
234	char *tmp = talloc_strdup(ctx, stream);
235	if (tmp == NULL) {
236	TALLOC_FREE(name);
237	return NT_STATUS_NO_MEMORY;
238	}
239	*stream = '\0';
240	stream = tmp;
241	}
242	}
243
244	start = name;
245
246	/* If we're providing case insentive semantics or
247	* the underlying filesystem is case insensitive,
248	* then a case-normalized hit in the stat-cache is
249	* authoratitive. JRA.
250	*/
251
252	if((!conn->case_sensitive \|\| !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) &&
253	stat_cache_lookup(conn, &name, &dirpath, &start, &st)) {
254	*pst = st;
255	goto done;
256	}
257
258	/*
259	* Make sure "dirpath" is an allocated string, we use this for
260	* building the directories with asprintf and free it.
261	*/
262
263	if ((dirpath == NULL) && (!(dirpath = talloc_strdup(ctx,"")))) {
264	DEBUG(0, ("talloc_strdup failed\n"));
265	TALLOC_FREE(name);
266	return NT_STATUS_NO_MEMORY;
267	}
268
269	/*
270	* stat the name - if it exists then we are all done!
271	*/
272
273	if (SMB_VFS_STAT(conn,name,&st) == 0) {
274	/* Ensure we catch all names with in "/."
275	this is disallowed under Windows. */
276	const char p = strstr(name, "/."); / mb safe. */
277	if (p) {
278	if (p[2] == '/') {
279	/* Error code within a pathname. */
280	result = NT_STATUS_OBJECT_PATH_NOT_FOUND;
281	goto fail;
282	} else if (p[2] == '\0') {
283	/* Error code at the end of a pathname. */
284	result = NT_STATUS_OBJECT_NAME_INVALID;
285	goto fail;
286	}
287	}
288	stat_cache_add(orig_path, name, conn->case_sensitive);
289	DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
290	*pst = st;
291	goto done;
292	}
293
294	DEBUG(5,("unix_convert begin: name = %s, dirpath = %s, start = %s\n",
295	name, dirpath, start));
296
297	/*
298	* A special case - if we don't have any mangling chars and are case
299	* sensitive or the underlying filesystem is case insentive then searching
300	* won't help.
301	*/
302
303	if ((conn->case_sensitive \|\| !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) &&
304	!mangle_is_mangled(name, conn->params)) {
305	goto done;
306	}
307
308	/*
309	* is_mangled() was changed to look at an entire pathname, not
310	* just a component. JRA.
311	*/
312
313	if (mangle_is_mangled(start, conn->params)) {
314	component_was_mangled = True;
315	}
316
317	/*
318	* Now we need to recursively match the name against the real
319	* directory structure.
320	*/
321
322	/*
323	* Match each part of the path name separately, trying the names
324	* as is first, then trying to scan the directory for matching names.
325	*/
326
327	for (; start ; start = (end?end+1:(char *)NULL)) {
328	/*
329	* Pinpoint the end of this section of the filename.
330	*/
331	/* mb safe. '/' can't be in any encoded char. */
332	end = strchr(start, '/');
333
334	/*
335	* Chop the name at this point.
336	*/
337	if (end) {
338	*end = 0;
339	}
340
341	if (pp_saved_last_component) {
342	TALLOC_FREE(*pp_saved_last_component);
343	*pp_saved_last_component = talloc_strdup(ctx,
344	end ? end + 1 : start);
345	if (!*pp_saved_last_component) {
346	DEBUG(0, ("talloc failed\n"));
347	return NT_STATUS_NO_MEMORY;
348	}
349	}
350
351	/* The name cannot have a component of "." */
352
353	if (ISDOT(start)) {
354	if (!end) {
355	/* Error code at the end of a pathname. */
356	result = NT_STATUS_OBJECT_NAME_INVALID;
357	} else {
358	result = determine_path_error(end+1,
359	allow_wcard_last_component);
360	}
361	goto fail;
362	}
363
364	/* The name cannot have a wildcard if it's not
365	the last component. */
366
367	name_has_wildcard = ms_has_wild(start);
368
369	/* Wildcard not valid anywhere. */
370	if (name_has_wildcard && !allow_wcard_last_component) {
371	result = NT_STATUS_OBJECT_NAME_INVALID;
372	goto fail;
373	}
374
375	/* Wildcards never valid within a pathname. */
376	if (name_has_wildcard && end) {
377	result = NT_STATUS_OBJECT_NAME_INVALID;
378	goto fail;
379	}
380
381	/*
382	* Check if the name exists up to this point.
383	*/
384
385	if (SMB_VFS_STAT(conn,name, &st) == 0) {
386	/*
387	* It exists. it must either be a directory or this must
388	* be the last part of the path for it to be OK.
389	*/
390	if (end && !(st.st_mode & S_IFDIR)) {
391	/*
392	* An intermediate part of the name isn't
393	* a directory.
394	*/
395	DEBUG(5,("Not a dir %s\n",start));
396	*end = '/';
397	/*
398	* We need to return the fact that the
399	* intermediate name resolution failed. This
400	* is used to return an error of ERRbadpath
401	* rather than ERRbadfile. Some Windows
402	* applications depend on the difference between
403	* these two errors.
404	*/
405	result = NT_STATUS_OBJECT_PATH_NOT_FOUND;
406	goto fail;
407	}
408
409	if (!end) {
410	/*
411	* We just scanned for, and found the end of
412	* the path. We must return the valid stat
413	* struct. JRA.
414	*/
415
416	*pst = st;
417	}
418
419	} else {
420	char *found_name = NULL;
421
422	/* Stat failed - ensure we don't use it. */
423	SET_STAT_INVALID(st);
424
425	/*
426	* Reset errno so we can detect
427	* directory open errors.
428	*/
429	errno = 0;
430
431	/*
432	* Try to find this part of the path in the directory.
433	*/
434
435	if (name_has_wildcard \|\|
436	!scan_directory(conn, dirpath,
437	start, &found_name)) {
438	char *unmangled;
439
440	if (end) {
441	/*
442	* An intermediate part of the name
443	* can't be found.
444	*/
445	DEBUG(5,("Intermediate not found %s\n",
446	start));
447	*end = '/';
448
449	/*
450	* We need to return the fact that the
451	* intermediate name resolution failed.
452	* This is used to return an error of
453	* ERRbadpath rather than ERRbadfile.
454	* Some Windows applications depend on
455	* the difference between these two
456	* errors.
457	*/
458
459	/*
460	* ENOENT, ENOTDIR and ELOOP all map
461	* to NT_STATUS_OBJECT_PATH_NOT_FOUND
462	* in the filename walk.
463	*/
464
465	if (errno == ENOENT \|\|
466	errno == ENOTDIR \|\|
467	errno == ELOOP) {
468	DEBUG( 0, ( "PS - ENOTDIR3\n" ) );
469	result =
470	NT_STATUS_OBJECT_PATH_NOT_FOUND;
471	}
472	else {
473	result =
474	map_nt_error_from_unix(errno);
475	}
476	goto fail;
477	}
478
479	/* ENOENT is the only valid error here. */
480	if ((errno != 0) && (errno != ENOENT)) {
481	/*
482	* ENOTDIR and ELOOP both map to
483	* NT_STATUS_OBJECT_PATH_NOT_FOUND
484	* in the filename walk.
485	*/
486	if (errno == ENOTDIR \|\|
487	errno == ELOOP) {
488	result =
489	NT_STATUS_OBJECT_PATH_NOT_FOUND;
490	}
491	else {
492	result =
493	map_nt_error_from_unix(errno);
494	}
495	goto fail;
496	}
497
498	/*
499	* Just the last part of the name doesn't exist.
500	* We need to strupper() or strlower() it as
501	* this conversion may be used for file creation
502	* purposes. Fix inspired by
503	* Thomas Neumann <t.neumann@iku-ag.de>.
504	*/
505	if (!conn->case_preserve \|\|
506	(mangle_is_8_3(start, False,
507	conn->params) &&
508	!conn->short_case_preserve)) {
509	strnorm(start,
510	lp_defaultcase(SNUM(conn)));
511	}
512
513	/*
514	* check on the mangled stack to see if we can
515	* recover the base of the filename.
516	*/
517
518	if (mangle_is_mangled(start, conn->params)
519	&& mangle_lookup_name_from_8_3(ctx,
520	start,
521	&unmangled,
522	conn->params)) {
523	char *tmp;
524	size_t start_ofs = start - name;
525
526	if (*dirpath != '\0') {
527	tmp = talloc_asprintf(ctx,
528	"%s/%s", dirpath,
529	unmangled);
530	TALLOC_FREE(unmangled);
531	}
532	else {
533	tmp = unmangled;
534	}
535	if (tmp == NULL) {
536	DEBUG(0, ("talloc failed\n"));
537	return NT_STATUS_NO_MEMORY;
538	}
539	TALLOC_FREE(name);
540	name = tmp;
541	start = name + start_ofs;
542	end = start + strlen(start);
543	}
544
545	DEBUG(5,("New file %s\n",start));
546	goto done;
547	}
548
549
550	/*
551	* Restore the rest of the string. If the string was
552	* mangled the size may have changed.
553	*/
554	if (end) {
555	char *tmp;
556	size_t start_ofs = start - name;
557
558	if (*dirpath != '\0') {
559	tmp = talloc_asprintf(ctx,
560	"%s/%s/%s", dirpath,
561	found_name, end+1);
562	}
563	else {
564	tmp = talloc_asprintf(ctx,
565	"%s/%s", found_name,
566	end+1);
567	}
568	if (tmp == NULL) {
569	DEBUG(0, ("talloc_asprintf failed\n"));
570	return NT_STATUS_NO_MEMORY;
571	}
572	TALLOC_FREE(name);
573	name = tmp;
574	start = name + start_ofs;
575	end = start + strlen(found_name);
576	*end = '\0';
577	} else {
578	char *tmp;
579	size_t start_ofs = start - name;
580
581	if (*dirpath != '\0') {
582	tmp = talloc_asprintf(ctx,
583	"%s/%s", dirpath,
584	found_name);
585	} else {
586	tmp = talloc_strdup(ctx,
587	found_name);
588	}
589	if (tmp == NULL) {
590	DEBUG(0, ("talloc failed\n"));
591	return NT_STATUS_NO_MEMORY;
592	}
593	TALLOC_FREE(name);
594	name = tmp;
595	start = name + start_ofs;
596
597	/*
598	* We just scanned for, and found the end of
599	* the path. We must return a valid stat struct
600	* if it exists. JRA.
601	*/
602
603	if (SMB_VFS_STAT(conn,name, &st) == 0) {
604	*pst = st;
605	} else {
606	SET_STAT_INVALID(st);
607	}
608	}
609
610	TALLOC_FREE(found_name);
611	} /* end else */
612
613	#ifdef DEVELOPER
614	/*
615	* This sucks!
616	* We should never provide different behaviors
617	* depending on DEVELOPER!!!
618	*/
619	if (VALID_STAT(st)) {
620	bool delete_pending;
621	get_file_infos(vfs_file_id_from_sbuf(conn, &st),
622	&delete_pending, NULL);
623	if (delete_pending) {
624	result = NT_STATUS_DELETE_PENDING;
625	goto fail;
626	}
627	}
628	#endif
629
630	/*
631	* Add to the dirpath that we have resolved so far.
632	*/
633
634	if (*dirpath != '\0') {
635	char *tmp = talloc_asprintf(ctx,
636	"%s/%s", dirpath, start);
637	if (!tmp) {
638	DEBUG(0, ("talloc_asprintf failed\n"));
639	return NT_STATUS_NO_MEMORY;
640	}
641	TALLOC_FREE(dirpath);
642	dirpath = tmp;
643	}
644	else {
645	TALLOC_FREE(dirpath);
646	if (!(dirpath = talloc_strdup(ctx,start))) {
647	DEBUG(0, ("talloc_strdup failed\n"));
648	return NT_STATUS_NO_MEMORY;
649	}
650	}
651
652	/*
653	* Don't cache a name with mangled or wildcard components
654	* as this can change the size.
655	*/
656
657	if(!component_was_mangled && !name_has_wildcard) {
658	stat_cache_add(orig_path, dirpath,
659	conn->case_sensitive);
660	}
661
662	/*
663	* Restore the / that we wiped out earlier.
664	*/
665	if (end) {
666	*end = '/';
667	}
668	}
669
670	/*
671	* Don't cache a name with mangled or wildcard components
672	* as this can change the size.
673	*/
674
675	if(!component_was_mangled && !name_has_wildcard) {
676	stat_cache_add(orig_path, name, conn->case_sensitive);
677	}
678
679	/*
680	* The name has been resolved.
681	*/
682
683	DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
684
685	done:
686	if (stream != NULL) {
687	char *tmp = NULL;
688
689	result = build_stream_path(ctx, conn, orig_path, name, stream,
690	pst, &tmp);
691	if (!NT_STATUS_IS_OK(result)) {
692	goto fail;
693	}
694
695	DEBUG(10, ("build_stream_path returned %s\n", tmp));
696
697	TALLOC_FREE(name);
698	name = tmp;
699	}
700	*pp_conv_path = name;
701	TALLOC_FREE(dirpath);
702	return NT_STATUS_OK;
703	fail:
704	DEBUG(10, ("dirpath = [%s] start = [%s]\n", dirpath, start));
705	if (*dirpath != '\0') {
706	*pp_conv_path = talloc_asprintf(ctx,
707	"%s/%s", dirpath, start);
708	} else {
709	*pp_conv_path = talloc_strdup(ctx, start);
710	}
711	if (!*pp_conv_path) {
712	DEBUG(0, ("talloc_asprintf failed\n"));
713	return NT_STATUS_NO_MEMORY;
714	}
715	TALLOC_FREE(name);
716	TALLOC_FREE(dirpath);
717	return result;
718	}
719
720	/****************************************************************************
721	Check a filename - possibly calling check_reduced_name.
722	This is called by every routine before it allows an operation on a filename.
723	It does any final confirmation necessary to ensure that the filename is
724	a valid one for the user to access.
725	****************************************************************************/
726
727	NTSTATUS check_name(connection_struct conn, const char name)
728	{
729	if (IS_VETO_PATH(conn, name)) {
730	/* Is it not dot or dot dot. */
731	if (!((name[0] == '.') && (!name[1] \|\|
732	(name[1] == '.' && !name[2])))) {
733	DEBUG(5,("check_name: file path name %s vetoed\n",
734	name));
735	return map_nt_error_from_unix(ENOENT);
736	}
737	}
738
739	if (!lp_widelinks(SNUM(conn)) \|\| !lp_symlinks(SNUM(conn))) {
740	NTSTATUS status = check_reduced_name(conn,name);
741	if (!NT_STATUS_IS_OK(status)) {
742	DEBUG(5,("check_name: name %s failed with %s\n",name,
743	nt_errstr(status)));
744	return status;
745	}
746	}
747
748	return NT_STATUS_OK;
749	}
750
751	/****************************************************************************
752	Check if two filenames are equal.
753	This needs to be careful about whether we are case sensitive.
754	****************************************************************************/
755
756	static bool fname_equal(const char name1, const char name2,
757	bool case_sensitive)
758	{
759	/* Normal filename handling */
760	if (case_sensitive) {
761	return(strcmp(name1,name2) == 0);
762	}
763
764	return(strequal(name1,name2));
765	}
766
767	/****************************************************************************
768	Scan a directory to find a filename, matching without case sensitivity.
769	If the name looks like a mangled name then try via the mangling functions
770	****************************************************************************/
771
772	static bool scan_directory(connection_struct conn, const char path,
773	char name, char *found_name)
774	{
775	struct smb_Dir *cur_dir;
776	const char *dname;
777	bool mangled;
778	char *unmangled_name = NULL;
779	long curpos;
780	TALLOC_CTX *ctx = talloc_tos();
781
782	mangled = mangle_is_mangled(name, conn->params);
783
784	/* handle null paths */
785	if ((path == NULL) \|\| (*path == 0)) {
786	path = ".";
787	}
788
789	/* If we have a case-sensitive filesystem, it doesn't do us any
790	* good to search for a name. If a case variation of the name was
791	* there, then the original stat(2) would have found it.
792	*/
793	if (!mangled && !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
794	errno = ENOENT;
795	return False;
796	}
797
798	/*
799	* The incoming name can be mangled, and if we de-mangle it
800	* here it will not compare correctly against the filename (name2)
801	* read from the directory and then mangled by the name_to_8_3()
802	* call. We need to mangle both names or neither.
803	* (JRA).
804	*
805	* Fix for bug found by Dina Fine. If in case sensitive mode then
806	* the mangle cache is no good (3 letter extension could be wrong
807	* case - so don't demangle in this case - leave as mangled and
808	* allow the mangling of the directory entry read (which is done
809	* case insensitively) to match instead. This will lead to more
810	* false positive matches but we fail completely without it. JRA.
811	*/
812
813	if (mangled && !conn->case_sensitive) {
814	mangled = !mangle_lookup_name_from_8_3(ctx,
815	name,
816	&unmangled_name,
817	conn->params);
818	if (!mangled) {
819	/* Name is now unmangled. */
820	name = unmangled_name;
821	}
822	}
823
824	/* open the directory */
825	if (!(cur_dir = OpenDir(talloc_tos(), conn, path, NULL, 0))) {
826	DEBUG(3,("scan dir didn't open dir [%s]\n",path));
827	TALLOC_FREE(unmangled_name);
828	return(False);
829	}
830
831	/* now scan for matching names */
832	curpos = 0;
833	while ((dname = ReadDirName(cur_dir, &curpos))) {
834
835	/* Is it dot or dot dot. */
836	if (ISDOT(dname) \|\| ISDOTDOT(dname)) {
837	continue;
838	}
839
840	/*
841	* At this point dname is the unmangled name.
842	* name is either mangled or not, depending on the state
843	* of the "mangled" variable. JRA.
844	*/
845
846	/*
847	* Check mangled name against mangled name, or unmangled name
848	* against unmangled name.
849	*/
850
851	if ((mangled && mangled_equal(name,dname,conn->params)) \|\|
852	fname_equal(name, dname, conn->case_sensitive)) {
853	/* we've found the file, change it's name and return */
854	*found_name = talloc_strdup(ctx,dname);
855	TALLOC_FREE(unmangled_name);
856	TALLOC_FREE(cur_dir);
857	if (!*found_name) {
858	errno = ENOMEM;
859	return False;
860	}
861	return(True);
862	}
863	}
864
865	TALLOC_FREE(unmangled_name);
866	TALLOC_FREE(cur_dir);
867	errno = ENOENT;
868	return False;
869	}
870
871	static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
872	connection_struct *conn,
873	const char *orig_path,
874	const char *basepath,
875	const char *streamname,
876	SMB_STRUCT_STAT *pst,
877	char **path)
878	{
879	SMB_STRUCT_STAT st;
880	char *result = NULL;
881	NTSTATUS status;
882	unsigned int i, num_streams;
883	struct stream_struct *streams = NULL;
884
885	result = talloc_asprintf(mem_ctx, "%s%s", basepath, streamname);
886	if (result == NULL) {
887	return NT_STATUS_NO_MEMORY;
888	}
889
890	if (SMB_VFS_STAT(conn, result, &st) == 0) {
891	*pst = st;
892	*path = result;
893	return NT_STATUS_OK;
894	}
895
896	if (errno != ENOENT) {
897	status = map_nt_error_from_unix(errno);
898	DEBUG(10, ("vfs_stat failed: %s\n", nt_errstr(status)));
899	goto fail;
900	}
901
902	status = SMB_VFS_STREAMINFO(conn, NULL, basepath, mem_ctx,
903	&num_streams, &streams);
904
905	if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
906	SET_STAT_INVALID(*pst);
907	*path = result;
908	return NT_STATUS_OK;
909	}
910
911	if (!NT_STATUS_IS_OK(status)) {
912	DEBUG(10, ("vfs_streaminfo failed: %s\n", nt_errstr(status)));
913	goto fail;
914	}
915
916	for (i=0; i<num_streams; i++) {
917	DEBUG(10, ("comparing [%s] and [%s]: ",
918	streamname, streams[i].name));
919	if (fname_equal(streamname, streams[i].name,
920	conn->case_sensitive)) {
921	DEBUGADD(10, ("equal\n"));
922	break;
923	}
924	DEBUGADD(10, ("not equal\n"));
925	}
926
927	if (i == num_streams) {
928	SET_STAT_INVALID(*pst);
929	*path = result;
930	TALLOC_FREE(streams);
931	return NT_STATUS_OK;
932	}
933
934	TALLOC_FREE(result);
935
936	result = talloc_asprintf(mem_ctx, "%s%s", basepath, streams[i].name);
937	if (result == NULL) {
938	status = NT_STATUS_NO_MEMORY;
939	goto fail;
940	}
941
942	SET_STAT_INVALID(*pst);
943
944	if (SMB_VFS_STAT(conn, result, pst) == 0) {
945	stat_cache_add(orig_path, result, conn->case_sensitive);
946	}
947
948	*path = result;
949	TALLOC_FREE(streams);
950	return NT_STATUS_OK;
951
952	fail:
953	TALLOC_FREE(result);
954	TALLOC_FREE(streams);
955	return status;
956	}

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

Download in other formats: