a5800aa85b35b2b2156fb1f596668fa8833611b4
[kai/samba.git] / source3 / smbd / filename.c
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 get_real_filename(connection_struct *conn, const char *path,
30                               const char *name, TALLOC_CTX *mem_ctx,
31                               char **found_name);
32 static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
33                                   connection_struct *conn,
34                                   const char *orig_path,
35                                   const char *basepath,
36                                   const char *streamname,
37                                   SMB_STRUCT_STAT *pst,
38                                   char **path);
39
40 /****************************************************************************
41  Mangle the 2nd name and check if it is then equal to the first name.
42 ****************************************************************************/
43
44 static bool mangled_equal(const char *name1,
45                         const char *name2,
46                         const struct share_params *p)
47 {
48         char mname[13];
49
50         if (!name_to_8_3(name2, mname, False, p)) {
51                 return False;
52         }
53         return strequal(name1, mname);
54 }
55
56 /****************************************************************************
57  Cope with the differing wildcard and non-wildcard error cases.
58 ****************************************************************************/
59
60 static NTSTATUS determine_path_error(const char *name,
61                         bool allow_wcard_last_component)
62 {
63         const char *p;
64
65         if (!allow_wcard_last_component) {
66                 /* Error code within a pathname. */
67                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
68         }
69
70         /* We're terminating here so we
71          * can be a little slower and get
72          * the error code right. Windows
73          * treats the last part of the pathname
74          * separately I think, so if the last
75          * component is a wildcard then we treat
76          * this ./ as "end of component" */
77
78         p = strchr(name, '/');
79
80         if (!p && (ms_has_wild(name) || ISDOT(name))) {
81                 /* Error code at the end of a pathname. */
82                 return NT_STATUS_OBJECT_NAME_INVALID;
83         } else {
84                 /* Error code within a pathname. */
85                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
86         }
87 }
88
89 /****************************************************************************
90 This routine is called to convert names from the dos namespace to unix
91 namespace. It needs to handle any case conversions, mangling, format
92 changes etc.
93
94 We assume that we have already done a chdir() to the right "root" directory
95 for this service.
96
97 The function will return an NTSTATUS error if some part of the name except for
98 the last part cannot be resolved, else NT_STATUS_OK.
99
100 Note NT_STATUS_OK doesn't mean the name exists or is valid, just that we didn't
101 get any fatal errors that should immediately terminate the calling
102 SMB processing whilst resolving.
103
104 If the saved_last_component != 0, then the unmodified last component
105 of the pathname is returned there. If saved_last_component == 0 then nothing
106 is returned there.
107
108 If last_component_wcard is true then a MS wildcard was detected and
109 should be allowed in the last component of the path only.
110
111 On exit from unix_convert, if *pst was not null, then the file stat
112 struct will be returned if the file exists and was found, if not this
113 stat struct will be filled with zeros (and this can be detected by checking
114 for nlinks = 0, which can never be true for any file).
115 ****************************************************************************/
116
117 NTSTATUS unix_convert(TALLOC_CTX *ctx,
118                         connection_struct *conn,
119                         const char *orig_path,
120                         bool allow_wcard_last_component,
121                         char **pp_conv_path,
122                         char **pp_saved_last_component,
123                         SMB_STRUCT_STAT *pst)
124 {
125         SMB_STRUCT_STAT st;
126         char *start, *end;
127         char *dirpath = NULL;
128         char *name = NULL;
129         char *stream = NULL;
130         bool component_was_mangled = False;
131         bool name_has_wildcard = False;
132         NTSTATUS result;
133
134         SET_STAT_INVALID(*pst);
135         *pp_conv_path = NULL;
136         if(pp_saved_last_component) {
137                 *pp_saved_last_component = NULL;
138         }
139
140         if (conn->printer) {
141                 /* we don't ever use the filenames on a printer share as a
142                         filename - so don't convert them */
143                 if (!(*pp_conv_path = talloc_strdup(ctx,orig_path))) {
144                         return NT_STATUS_NO_MEMORY;
145                 }
146                 return NT_STATUS_OK;
147         }
148
149         DEBUG(5, ("unix_convert called on file \"%s\"\n", orig_path));
150
151         /*
152          * Conversion to basic unix format is already done in
153          * check_path_syntax().
154          */
155
156         /*
157          * Names must be relative to the root of the service - any leading /.
158          * and trailing /'s should have been trimmed by check_path_syntax().
159          */
160
161 #ifdef DEVELOPER
162         SMB_ASSERT(*orig_path != '/');
163 #endif
164
165         /*
166          * If we trimmed down to a single '\0' character
167          * then we should use the "." directory to avoid
168          * searching the cache, but not if we are in a
169          * printing share.
170          * As we know this is valid we can return true here.
171          */
172
173         if (!*orig_path) {
174                 if (!(name = talloc_strdup(ctx,"."))) {
175                         return NT_STATUS_NO_MEMORY;
176                 }
177                 if (SMB_VFS_STAT(conn,name,&st) == 0) {
178                         *pst = st;
179                 } else {
180                         return map_nt_error_from_unix(errno);
181                 }
182                 DEBUG(5,("conversion finished \"\" -> %s\n",name));
183                 goto done;
184         }
185
186         if (orig_path[0] == '.' && (orig_path[1] == '/' ||
187                                 orig_path[1] == '\0')) {
188                 /* Start of pathname can't be "." only. */
189                 if (orig_path[1] == '\0' || orig_path[2] == '\0') {
190                         result = NT_STATUS_OBJECT_NAME_INVALID;
191                 } else {
192                         result =determine_path_error(
193                                 &orig_path[2], allow_wcard_last_component);
194                 }
195                 return result;
196         }
197
198         if (!(name = talloc_strdup(ctx, orig_path))) {
199                 DEBUG(0, ("talloc_strdup failed\n"));
200                 return NT_STATUS_NO_MEMORY;
201         }
202
203         /*
204          * Large directory fix normalization. If we're case sensitive, and
205          * the case preserving parameters are set to "no", normalize the case of
206          * the incoming filename from the client WHETHER IT EXISTS OR NOT !
207          * This is in conflict with the current (3.0.20) man page, but is
208          * what people expect from the "large directory howto". I'll update
209          * the man page. Thanks to jht@samba.org for finding this. JRA.
210          */
211
212         if (conn->case_sensitive && !conn->case_preserve &&
213                         !conn->short_case_preserve) {
214                 strnorm(name, lp_defaultcase(SNUM(conn)));
215         }
216
217         /*
218          * Ensure saved_last_component is valid even if file exists.
219          */
220
221         if(pp_saved_last_component) {
222                 end = strrchr_m(name, '/');
223                 if (end) {
224                         *pp_saved_last_component = talloc_strdup(ctx, end + 1);
225                 } else {
226                         *pp_saved_last_component = talloc_strdup(ctx,
227                                                         name);
228                 }
229         }
230
231         if (!lp_posix_pathnames()) {
232                 stream = strchr_m(name, ':');
233
234                 if (stream != NULL) {
235                         char *tmp = talloc_strdup(ctx, stream);
236                         if (tmp == NULL) {
237                                 TALLOC_FREE(name);
238                                 return NT_STATUS_NO_MEMORY;
239                         }
240                         *stream = '\0';
241                         stream = tmp;
242                 }
243         }
244
245         start = name;
246
247         /* If we're providing case insentive semantics or
248          * the underlying filesystem is case insensitive,
249          * then a case-normalized hit in the stat-cache is
250          * authoratitive. JRA.
251          */
252
253         if((!conn->case_sensitive || !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) &&
254                         stat_cache_lookup(conn, &name, &dirpath, &start, &st)) {
255                 *pst = st;
256                 goto done;
257         }
258
259         /*
260          * Make sure "dirpath" is an allocated string, we use this for
261          * building the directories with asprintf and free it.
262          */
263
264         if ((dirpath == NULL) && (!(dirpath = talloc_strdup(ctx,"")))) {
265                 DEBUG(0, ("talloc_strdup failed\n"));
266                 TALLOC_FREE(name);
267                 return NT_STATUS_NO_MEMORY;
268         }
269
270         /*
271          * stat the name - if it exists then we are all done!
272          */
273
274         if (SMB_VFS_STAT(conn,name,&st) == 0) {
275                 /* Ensure we catch all names with in "/."
276                    this is disallowed under Windows. */
277                 const char *p = strstr(name, "/."); /* mb safe. */
278                 if (p) {
279                         if (p[2] == '/') {
280                                 /* Error code within a pathname. */
281                                 result = NT_STATUS_OBJECT_PATH_NOT_FOUND;
282                                 goto fail;
283                         } else if (p[2] == '\0') {
284                                 /* Error code at the end of a pathname. */
285                                 result = NT_STATUS_OBJECT_NAME_INVALID;
286                                 goto fail;
287                         }
288                 }
289                 stat_cache_add(orig_path, name, conn->case_sensitive);
290                 DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
291                 *pst = st;
292                 goto done;
293         }
294
295         DEBUG(5,("unix_convert begin: name = %s, dirpath = %s, start = %s\n",
296                                 name, dirpath, start));
297
298         /*
299          * A special case - if we don't have any mangling chars and are case
300          * sensitive or the underlying filesystem is case insentive then searching
301          * won't help.
302          */
303
304         if ((conn->case_sensitive || !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) &&
305                         !mangle_is_mangled(name, conn->params)) {
306                 goto done;
307         }
308
309         /*
310          * is_mangled() was changed to look at an entire pathname, not
311          * just a component. JRA.
312          */
313
314         if (mangle_is_mangled(start, conn->params)) {
315                 component_was_mangled = True;
316         }
317
318         /*
319          * Now we need to recursively match the name against the real
320          * directory structure.
321          */
322
323         /*
324          * Match each part of the path name separately, trying the names
325          * as is first, then trying to scan the directory for matching names.
326          */
327
328         for (; start ; start = (end?end+1:(char *)NULL)) {
329                 /*
330                  * Pinpoint the end of this section of the filename.
331                  */
332                 /* mb safe. '/' can't be in any encoded char. */
333                 end = strchr(start, '/');
334
335                 /*
336                  * Chop the name at this point.
337                  */
338                 if (end) {
339                         *end = 0;
340                 }
341
342                 if (pp_saved_last_component) {
343                         TALLOC_FREE(*pp_saved_last_component);
344                         *pp_saved_last_component = talloc_strdup(ctx,
345                                                         end ? end + 1 : start);
346                         if (!*pp_saved_last_component) {
347                                 DEBUG(0, ("talloc failed\n"));
348                                 return NT_STATUS_NO_MEMORY;
349                         }
350                 }
351
352                 /* The name cannot have a component of "." */
353
354                 if (ISDOT(start)) {
355                         if (!end)  {
356                                 /* Error code at the end of a pathname. */
357                                 result = NT_STATUS_OBJECT_NAME_INVALID;
358                         } else {
359                                 result = determine_path_error(end+1,
360                                                 allow_wcard_last_component);
361                         }
362                         goto fail;
363                 }
364
365                 /* The name cannot have a wildcard if it's not
366                    the last component. */
367
368                 name_has_wildcard = ms_has_wild(start);
369
370                 /* Wildcard not valid anywhere. */
371                 if (name_has_wildcard && !allow_wcard_last_component) {
372                         result = NT_STATUS_OBJECT_NAME_INVALID;
373                         goto fail;
374                 }
375
376                 /* Wildcards never valid within a pathname. */
377                 if (name_has_wildcard && end) {
378                         result = NT_STATUS_OBJECT_NAME_INVALID;
379                         goto fail;
380                 }
381
382                 /*
383                  * Check if the name exists up to this point.
384                  */
385
386                 if (SMB_VFS_STAT(conn,name, &st) == 0) {
387                         /*
388                          * It exists. it must either be a directory or this must
389                          * be the last part of the path for it to be OK.
390                          */
391                         if (end && !(st.st_mode & S_IFDIR)) {
392                                 /*
393                                  * An intermediate part of the name isn't
394                                  * a directory.
395                                  */
396                                 DEBUG(5,("Not a dir %s\n",start));
397                                 *end = '/';
398                                 /*
399                                  * We need to return the fact that the
400                                  * intermediate name resolution failed. This
401                                  * is used to return an error of ERRbadpath
402                                  * rather than ERRbadfile. Some Windows
403                                  * applications depend on the difference between
404                                  * these two errors.
405                                  */
406                                 result = NT_STATUS_OBJECT_PATH_NOT_FOUND;
407                                 goto fail;
408                         }
409
410                         if (!end) {
411                                 /*
412                                  * We just scanned for, and found the end of
413                                  * the path. We must return the valid stat
414                                  * struct. JRA.
415                                  */
416
417                                 *pst = st;
418                         }
419
420                 } else {
421                         char *found_name = NULL;
422
423                         /* Stat failed - ensure we don't use it. */
424                         SET_STAT_INVALID(st);
425
426                         /*
427                          * Reset errno so we can detect
428                          * directory open errors.
429                          */
430                         errno = 0;
431
432                         /*
433                          * Try to find this part of the path in the directory.
434                          */
435
436                         if (name_has_wildcard ||
437                             !get_real_filename(conn, dirpath, start,
438                                                talloc_tos(), &found_name)) {
439                                 char *unmangled;
440
441                                 if (end) {
442                                         /*
443                                          * An intermediate part of the name
444                                          * can't be found.
445                                          */
446                                         DEBUG(5,("Intermediate not found %s\n",
447                                                         start));
448                                         *end = '/';
449
450                                         /*
451                                          * We need to return the fact that the
452                                          * intermediate name resolution failed.
453                                          * This is used to return an error of
454                                          * ERRbadpath rather than ERRbadfile.
455                                          * Some Windows applications depend on
456                                          * the difference between these two
457                                          * errors.
458                                          */
459
460                                         /*
461                                          * ENOENT, ENOTDIR and ELOOP all map
462                                          * to NT_STATUS_OBJECT_PATH_NOT_FOUND
463                                          * in the filename walk.
464                                          */
465
466                                         if (errno == ENOENT ||
467                                                         errno == ENOTDIR ||
468                                                         errno == ELOOP) {
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 get_real_filename(connection_struct *conn, const char *path,
773                               const char *name, TALLOC_CTX *mem_ctx,
774                               char **found_name)
775 {
776         struct smb_Dir *cur_dir;
777         const char *dname;
778         bool mangled;
779         char *unmangled_name = NULL;
780         long curpos;
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(talloc_tos(), 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(mem_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 }