?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix more POSIX path lstat calls. Fix bug where close can return
[Samba.git] / source / smbd / filename.c
blob392264bfc0e7fc8db7bf34b06c8891297854d4c2
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 result =
469 NT_STATUS_OBJECT_PATH_NOT_FOUND;
470 }
471 else {
472 result =
473 map_nt_error_from_unix(errno);
474 }
475 goto fail;
476 }
477
478 /* ENOENT is the only valid error here. */
479 if ((errno != 0) && (errno != ENOENT)) {
480 /*
481 * ENOTDIR and ELOOP both map to
482 * NT_STATUS_OBJECT_PATH_NOT_FOUND
483 * in the filename walk.
484 */
485 if (errno == ENOTDIR ||
486 errno == ELOOP) {
487 result =
488 NT_STATUS_OBJECT_PATH_NOT_FOUND;
489 }
490 else {
491 result =
492 map_nt_error_from_unix(errno);
493 }
494 goto fail;
495 }
496
497 /*
498 * Just the last part of the name doesn't exist.
499 * We need to strupper() or strlower() it as
500 * this conversion may be used for file creation
501 * purposes. Fix inspired by
502 * Thomas Neumann <t.neumann@iku-ag.de>.
503 */
504 if (!conn->case_preserve ||
505 (mangle_is_8_3(start, False,
506 conn->params) &&
507 !conn->short_case_preserve)) {
508 strnorm(start,
509 lp_defaultcase(SNUM(conn)));
510 }
511
512 /*
513 * check on the mangled stack to see if we can
514 * recover the base of the filename.
515 */
516
517 if (mangle_is_mangled(start, conn->params)
518 && mangle_lookup_name_from_8_3(ctx,
519 start,
520 &unmangled,
521 conn->params)) {
522 char *tmp;
523 size_t start_ofs = start - name;
524
525 if (*dirpath != '\0') {
526 tmp = talloc_asprintf(ctx,
527 "%s/%s", dirpath,
528 unmangled);
529 TALLOC_FREE(unmangled);
530 }
531 else {
532 tmp = unmangled;
533 }
534 if (tmp == NULL) {
535 DEBUG(0, ("talloc failed\n"));
536 return NT_STATUS_NO_MEMORY;
537 }
538 TALLOC_FREE(name);
539 name = tmp;
540 start = name + start_ofs;
541 end = start + strlen(start);
542 }
543
544 DEBUG(5,("New file %s\n",start));
545 goto done;
546 }
547
548
549 /*
550 * Restore the rest of the string. If the string was
551 * mangled the size may have changed.
552 */
553 if (end) {
554 char *tmp;
555 size_t start_ofs = start - name;
556
557 if (*dirpath != '\0') {
558 tmp = talloc_asprintf(ctx,
559 "%s/%s/%s", dirpath,
560 found_name, end+1);
561 }
562 else {
563 tmp = talloc_asprintf(ctx,
564 "%s/%s", found_name,
565 end+1);
566 }
567 if (tmp == NULL) {
568 DEBUG(0, ("talloc_asprintf failed\n"));
569 return NT_STATUS_NO_MEMORY;
570 }
571 TALLOC_FREE(name);
572 name = tmp;
573 start = name + start_ofs;
574 end = start + strlen(found_name);
575 *end = '\0';
576 } else {
577 char *tmp;
578 size_t start_ofs = start - name;
579
580 if (*dirpath != '\0') {
581 tmp = talloc_asprintf(ctx,
582 "%s/%s", dirpath,
583 found_name);
584 } else {
585 tmp = talloc_strdup(ctx,
586 found_name);
587 }
588 if (tmp == NULL) {
589 DEBUG(0, ("talloc failed\n"));
590 return NT_STATUS_NO_MEMORY;
591 }
592 TALLOC_FREE(name);
593 name = tmp;
594 start = name + start_ofs;
595
596 /*
597 * We just scanned for, and found the end of
598 * the path. We must return a valid stat struct
599 * if it exists. JRA.
600 */
601
602 if (SMB_VFS_STAT(conn,name, &st) == 0) {
603 *pst = st;
604 } else {
605 SET_STAT_INVALID(st);
606 }
607 }
608
609 TALLOC_FREE(found_name);
610 } /* end else */
611
612 #ifdef DEVELOPER
613 /*
614 * This sucks!
615 * We should never provide different behaviors
616 * depending on DEVELOPER!!!
617 */
618 if (VALID_STAT(st)) {
619 bool delete_pending;
620 get_file_infos(vfs_file_id_from_sbuf(conn, &st),
621 &delete_pending, NULL);
622 if (delete_pending) {
623 result = NT_STATUS_DELETE_PENDING;
624 goto fail;
625 }
626 }
627 #endif
628
629 /*
630 * Add to the dirpath that we have resolved so far.
631 */
632
633 if (*dirpath != '\0') {
634 char *tmp = talloc_asprintf(ctx,
635 "%s/%s", dirpath, start);
636 if (!tmp) {
637 DEBUG(0, ("talloc_asprintf failed\n"));
638 return NT_STATUS_NO_MEMORY;
639 }
640 TALLOC_FREE(dirpath);
641 dirpath = tmp;
642 }
643 else {
644 TALLOC_FREE(dirpath);
645 if (!(dirpath = talloc_strdup(ctx,start))) {
646 DEBUG(0, ("talloc_strdup failed\n"));
647 return NT_STATUS_NO_MEMORY;
648 }
649 }
650
651 /*
652 * Don't cache a name with mangled or wildcard components
653 * as this can change the size.
654 */
655
656 if(!component_was_mangled && !name_has_wildcard) {
657 stat_cache_add(orig_path, dirpath,
658 conn->case_sensitive);
659 }
660
661 /*
662 * Restore the / that we wiped out earlier.
663 */
664 if (end) {
665 *end = '/';
666 }
667 }
668
669 /*
670 * Don't cache a name with mangled or wildcard components
671 * as this can change the size.
672 */
673
674 if(!component_was_mangled && !name_has_wildcard) {
675 stat_cache_add(orig_path, name, conn->case_sensitive);
676 }
677
678 /*
679 * The name has been resolved.
680 */
681
682 DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
683
684 done:
685 if (stream != NULL) {
686 char *tmp = NULL;
687
688 result = build_stream_path(ctx, conn, orig_path, name, stream,
689 pst, &tmp);
690 if (!NT_STATUS_IS_OK(result)) {
691 goto fail;
692 }
693
694 DEBUG(10, ("build_stream_path returned %s\n", tmp));
695
696 TALLOC_FREE(name);
697 name = tmp;
698 }
699 *pp_conv_path = name;
700 TALLOC_FREE(dirpath);
701 return NT_STATUS_OK;
702 fail:
703 DEBUG(10, ("dirpath = [%s] start = [%s]\n", dirpath, start));
704 if (*dirpath != '\0') {
705 *pp_conv_path = talloc_asprintf(ctx,
706 "%s/%s", dirpath, start);
707 } else {
708 *pp_conv_path = talloc_strdup(ctx, start);
709 }
710 if (!*pp_conv_path) {
711 DEBUG(0, ("talloc_asprintf failed\n"));
712 return NT_STATUS_NO_MEMORY;
713 }
714 TALLOC_FREE(name);
715 TALLOC_FREE(dirpath);
716 return result;
717 }
718
719 /****************************************************************************
720 Check a filename - possibly calling check_reduced_name.
721 This is called by every routine before it allows an operation on a filename.
722 It does any final confirmation necessary to ensure that the filename is
723 a valid one for the user to access.
724 ****************************************************************************/
725
726 NTSTATUS check_name(connection_struct *conn, const char *name)
727 {
728 if (IS_VETO_PATH(conn, name)) {
729 /* Is it not dot or dot dot. */
730 if (!((name[0] == '.') && (!name[1] ||
731 (name[1] == '.' && !name[2])))) {
732 DEBUG(5,("check_name: file path name %s vetoed\n",
733 name));
734 return map_nt_error_from_unix(ENOENT);
735 }
736 }
737
738 if (!lp_widelinks(SNUM(conn)) || !lp_symlinks(SNUM(conn))) {
739 NTSTATUS status = check_reduced_name(conn,name);
740 if (!NT_STATUS_IS_OK(status)) {
741 DEBUG(5,("check_name: name %s failed with %s\n",name,
742 nt_errstr(status)));
743 return status;
744 }
745 }
746
747 return NT_STATUS_OK;
748 }
749
750 /****************************************************************************
751 Check if two filenames are equal.
752 This needs to be careful about whether we are case sensitive.
753 ****************************************************************************/
754
755 static bool fname_equal(const char *name1, const char *name2,
756 bool case_sensitive)
757 {
758 /* Normal filename handling */
759 if (case_sensitive) {
760 return(strcmp(name1,name2) == 0);
761 }
762
763 return(strequal(name1,name2));
764 }
765
766 /****************************************************************************
767 Scan a directory to find a filename, matching without case sensitivity.
768 If the name looks like a mangled name then try via the mangling functions
769 ****************************************************************************/
770
771 static bool scan_directory(connection_struct *conn, const char *path,
772 char *name, char **found_name)
773 {
774 struct smb_Dir *cur_dir;
775 const char *dname;
776 bool mangled;
777 char *unmangled_name = NULL;
778 long curpos;
779 TALLOC_CTX *ctx = talloc_tos();
780
781 mangled = mangle_is_mangled(name, conn->params);
782
783 /* handle null paths */
784 if ((path == NULL) || (*path == 0)) {
785 path = ".";
786 }
787
788 /* If we have a case-sensitive filesystem, it doesn't do us any
789 * good to search for a name. If a case variation of the name was
790 * there, then the original stat(2) would have found it.
791 */
792 if (!mangled && !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
793 errno = ENOENT;
794 return False;
795 }
796
797 /*
798 * The incoming name can be mangled, and if we de-mangle it
799 * here it will not compare correctly against the filename (name2)
800 * read from the directory and then mangled by the name_to_8_3()
801 * call. We need to mangle both names or neither.
802 * (JRA).
803 *
804 * Fix for bug found by Dina Fine. If in case sensitive mode then
805 * the mangle cache is no good (3 letter extension could be wrong
806 * case - so don't demangle in this case - leave as mangled and
807 * allow the mangling of the directory entry read (which is done
808 * case insensitively) to match instead. This will lead to more
809 * false positive matches but we fail completely without it. JRA.
810 */
811
812 if (mangled && !conn->case_sensitive) {
813 mangled = !mangle_lookup_name_from_8_3(ctx,
814 name,
815 &unmangled_name,
816 conn->params);
817 if (!mangled) {
818 /* Name is now unmangled. */
819 name = unmangled_name;
820 }
821 }
822
823 /* open the directory */
824 if (!(cur_dir = OpenDir(talloc_tos(), conn, path, NULL, 0))) {
825 DEBUG(3,("scan dir didn't open dir [%s]\n",path));
826 TALLOC_FREE(unmangled_name);
827 return(False);
828 }
829
830 /* now scan for matching names */
831 curpos = 0;
832 while ((dname = ReadDirName(cur_dir, &curpos))) {
833
834 /* Is it dot or dot dot. */
835 if (ISDOT(dname) || ISDOTDOT(dname)) {
836 continue;
837 }
838
839 /*
840 * At this point dname is the unmangled name.
841 * name is either mangled or not, depending on the state
842 * of the "mangled" variable. JRA.
843 */
844
845 /*
846 * Check mangled name against mangled name, or unmangled name
847 * against unmangled name.
848 */
849
850 if ((mangled && mangled_equal(name,dname,conn->params)) ||
851 fname_equal(name, dname, conn->case_sensitive)) {
852 /* we've found the file, change it's name and return */
853 *found_name = talloc_strdup(ctx,dname);
854 TALLOC_FREE(unmangled_name);
855 TALLOC_FREE(cur_dir);
856 if (!*found_name) {
857 errno = ENOMEM;
858 return False;
859 }
860 return(True);
861 }
862 }
863
864 TALLOC_FREE(unmangled_name);
865 TALLOC_FREE(cur_dir);
866 errno = ENOENT;
867 return False;
868 }
869
870 static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
871 connection_struct *conn,
872 const char *orig_path,
873 const char *basepath,
874 const char *streamname,
875 SMB_STRUCT_STAT *pst,
876 char **path)
877 {
878 SMB_STRUCT_STAT st;
879 char *result = NULL;
880 NTSTATUS status;
881 unsigned int i, num_streams;
882 struct stream_struct *streams = NULL;
883
884 result = talloc_asprintf(mem_ctx, "%s%s", basepath, streamname);
885 if (result == NULL) {
886 return NT_STATUS_NO_MEMORY;
887 }
888
889 if (SMB_VFS_STAT(conn, result, &st) == 0) {
890 *pst = st;
891 *path = result;
892 return NT_STATUS_OK;
893 }
894
895 if (errno != ENOENT) {
896 status = map_nt_error_from_unix(errno);
897 DEBUG(10, ("vfs_stat failed: %s\n", nt_errstr(status)));
898 goto fail;
899 }
900
901 status = SMB_VFS_STREAMINFO(conn, NULL, basepath, mem_ctx,
902 &num_streams, &streams);
903
904 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
905 SET_STAT_INVALID(*pst);
906 *path = result;
907 return NT_STATUS_OK;
908 }
909
910 if (!NT_STATUS_IS_OK(status)) {
911 DEBUG(10, ("vfs_streaminfo failed: %s\n", nt_errstr(status)));
912 goto fail;
913 }
914
915 for (i=0; i<num_streams; i++) {
916 DEBUG(10, ("comparing [%s] and [%s]: ",
917 streamname, streams[i].name));
918 if (fname_equal(streamname, streams[i].name,
919 conn->case_sensitive)) {
920 DEBUGADD(10, ("equal\n"));
921 break;
922 }
923 DEBUGADD(10, ("not equal\n"));
924 }
925
926 if (i == num_streams) {
927 SET_STAT_INVALID(*pst);
928 *path = result;
929 TALLOC_FREE(streams);
930 return NT_STATUS_OK;
931 }
932
933 TALLOC_FREE(result);
934
935 result = talloc_asprintf(mem_ctx, "%s%s", basepath, streams[i].name);
936 if (result == NULL) {
937 status = NT_STATUS_NO_MEMORY;
938 goto fail;
939 }
940
941 SET_STAT_INVALID(*pst);
942
943 if (SMB_VFS_STAT(conn, result, pst) == 0) {
944 stat_cache_add(orig_path, result, conn->case_sensitive);
945 }
946
947 *path = result;
948 TALLOC_FREE(streams);
949 return NT_STATUS_OK;
950
951 fail:
952 TALLOC_FREE(result);
953 TALLOC_FREE(streams);
954 return status;
955 }
Samba GIT mirror