Finish removal of iconv_convenience in public API's.
[bbaumbach/samba-autobuild/.git] / source4 / ntvfs / posix / pvfs_resolve.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    POSIX NTVFS backend - filename resolution
5
6    Copyright (C) Andrew Tridgell 2004
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 /*
23   this is the core code for converting a filename from the format as
24   given by a client to a posix filename, including any case-matching
25   required, and checks for legal characters
26 */
27
28
29 #include "includes.h"
30 #include "vfs_posix.h"
31 #include "system/dir.h"
32 #include "param/param.h"
33
34 /**
35   compare two filename components. This is where the name mangling hook will go
36 */
37 static int component_compare(struct pvfs_state *pvfs, const char *comp, const char *name)
38 {
39         int ret;
40
41         ret = strcasecmp_m(comp, name);
42
43         if (ret != 0) {
44                 char *shortname = pvfs_short_name_component(pvfs, name);
45                 if (shortname) {
46                         ret = strcasecmp_m(comp, shortname);
47                         talloc_free(shortname);
48                 }
49         }
50
51         return ret;
52 }
53
54 /*
55   search for a filename in a case insensitive fashion
56
57   TODO: add a cache for previously resolved case-insensitive names
58   TODO: add mangled name support
59 */
60 static NTSTATUS pvfs_case_search(struct pvfs_state *pvfs,
61                                  struct pvfs_filename *name,
62                                  unsigned int flags)
63 {
64         /* break into a series of components */
65         int num_components;
66         char **components;
67         char *p, *partial_name;
68         int i;
69
70         /* break up the full name info pathname components */
71         num_components=2;
72         p = name->full_name + strlen(pvfs->base_directory) + 1;
73
74         for (;*p;p++) {
75                 if (*p == '/') {
76                         num_components++;
77                 }
78         }
79
80         components = talloc_array(name, char *, num_components);
81         p = name->full_name + strlen(pvfs->base_directory);
82         *p++ = 0;
83
84         components[0] = name->full_name;
85
86         for (i=1;i<num_components;i++) {
87                 components[i] = p;
88                 p = strchr(p, '/');
89                 if (p) *p++ = 0;
90                 if (pvfs_is_reserved_name(pvfs, components[i])) {
91                         return NT_STATUS_ACCESS_DENIED;
92                 }
93         }
94
95         partial_name = talloc_strdup(name, components[0]);
96         if (!partial_name) {
97                 return NT_STATUS_NO_MEMORY;
98         }
99
100         /* for each component, check if it exists as-is, and if not then
101            do a directory scan */
102         for (i=1;i<num_components;i++) {
103                 char *test_name;
104                 DIR *dir;
105                 struct dirent *de;
106                 char *long_component;
107
108                 /* possibly remap from the short name cache */
109                 long_component = pvfs_mangled_lookup(pvfs, name, components[i]);
110                 if (long_component) {
111                         components[i] = long_component;
112                 }
113
114                 test_name = talloc_asprintf(name, "%s/%s", partial_name, components[i]);
115                 if (!test_name) {
116                         return NT_STATUS_NO_MEMORY;
117                 }
118
119                 /* check if this component exists as-is */
120                 if (stat(test_name, &name->st) == 0) {
121                         if (i<num_components-1 && !S_ISDIR(name->st.st_mode)) {
122                                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
123                         }
124                         talloc_free(partial_name);
125                         partial_name = test_name;
126                         if (i == num_components - 1) {
127                                 name->exists = true;
128                         }
129                         continue;
130                 }
131
132                 /* the filesystem might be case insensitive, in which
133                    case a search is pointless unless the name is
134                    mangled */
135                 if ((pvfs->flags & PVFS_FLAG_CI_FILESYSTEM) &&
136                     !pvfs_is_mangled_component(pvfs, components[i])) {
137                         if (i < num_components-1) {
138                                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
139                         }
140                         partial_name = test_name;
141                         continue;
142                 }
143                 
144                 dir = opendir(partial_name);
145                 if (!dir) {
146                         return pvfs_map_errno(pvfs, errno);
147                 }
148
149                 while ((de = readdir(dir))) {
150                         if (component_compare(pvfs, components[i], de->d_name) == 0) {
151                                 break;
152                         }
153                 }
154
155                 if (!de) {
156                         if (i < num_components-1) {
157                                 closedir(dir);
158                                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
159                         }
160                 } else {
161                         components[i] = talloc_strdup(name, de->d_name);
162                 }
163                 test_name = talloc_asprintf(name, "%s/%s", partial_name, components[i]);
164                 talloc_free(partial_name);
165                 partial_name = test_name;
166
167                 closedir(dir);
168         }
169
170         if (!name->exists) {
171                 if (stat(partial_name, &name->st) == 0) {
172                         name->exists = true;
173                 }
174         }
175
176         talloc_free(name->full_name);
177         name->full_name = partial_name;
178
179         if (name->exists) {
180                 return pvfs_fill_dos_info(pvfs, name, flags, -1);
181         }
182
183         return NT_STATUS_OK;
184 }
185
186 /*
187   parse a alternate data stream name
188 */
189 static NTSTATUS parse_stream_name(struct pvfs_filename *name,
190                                   const char *s)
191 {
192         char *p, *stream_name;
193         if (s[1] == '\0') {
194                 return NT_STATUS_OBJECT_NAME_INVALID;
195         }
196         name->stream_name = stream_name = talloc_strdup(name, s+1);
197         if (name->stream_name == NULL) {
198                 return NT_STATUS_NO_MEMORY;
199         }
200
201         p = stream_name;
202
203         while (*p) {
204                 size_t c_size;
205                 codepoint_t c = next_codepoint(p, &c_size);
206
207                 switch (c) {
208                 case '/':
209                 case '\\':
210                         return NT_STATUS_OBJECT_NAME_INVALID;
211                 case ':':
212                         *p= 0;
213                         p++;
214                         if (*p == '\0') {
215                                 return NT_STATUS_OBJECT_NAME_INVALID;
216                         }
217                         if (strcasecmp_m(p, "$DATA") != 0) {
218                                 if (strchr_m(p, ':')) {
219                                         return NT_STATUS_OBJECT_NAME_INVALID;
220                                 }
221                                 return NT_STATUS_INVALID_PARAMETER;
222                         }
223                         c_size = 0;
224                         p--;
225                         break;
226                 }
227
228                 p += c_size;
229         }
230
231         if (strcmp(name->stream_name, "") == 0) {
232                 /*
233                  * we don't set stream_name to NULL, here
234                  * as this would be wrong for directories
235                  *
236                  * pvfs_fill_dos_info() will set it to NULL
237                  * if it's not a directory.
238                  */
239                 name->stream_id = 0;
240         } else {
241                 name->stream_id = pvfs_name_hash(name->stream_name, 
242                                                  strlen(name->stream_name));
243         }
244                                                  
245         return NT_STATUS_OK;    
246 }
247
248
249 /*
250   convert a CIFS pathname to a unix pathname. Note that this does NOT
251   take into account case insensitivity, and in fact does not access
252   the filesystem at all. It is merely a reformatting and charset
253   checking routine.
254
255   errors are returned if the filename is illegal given the flags
256 */
257 static NTSTATUS pvfs_unix_path(struct pvfs_state *pvfs, const char *cifs_name,
258                                unsigned int flags, struct pvfs_filename *name)
259 {
260         char *ret, *p, *p_start;
261         NTSTATUS status;
262
263         name->original_name = talloc_strdup(name, cifs_name);
264
265         /* remove any :$DATA */
266         p = strrchr(name->original_name, ':');
267         if (p && strcasecmp_m(p, ":$DATA") == 0) {
268                 if (p > name->original_name && p[-1] == ':') {
269                         p--;
270                 }
271                 *p = 0;
272         }
273
274         name->stream_name = NULL;
275         name->stream_id = 0;
276         name->has_wildcard = false;
277
278         while (*cifs_name == '\\') {
279                 cifs_name++;
280         }
281
282         if (*cifs_name == 0) {
283                 name->full_name = talloc_asprintf(name, "%s/.", pvfs->base_directory);
284                 if (name->full_name == NULL) {
285                         return NT_STATUS_NO_MEMORY;
286                 }
287                 return NT_STATUS_OK;
288         }
289
290         ret = talloc_asprintf(name, "%s/%s", pvfs->base_directory, cifs_name);
291         if (ret == NULL) {
292                 return NT_STATUS_NO_MEMORY;
293         }
294
295         p = ret + strlen(pvfs->base_directory) + 1;
296
297         /* now do an in-place conversion of '\' to '/', checking
298            for legal characters */
299         p_start = p;
300
301         while (*p) {
302                 size_t c_size;
303                 codepoint_t c = next_codepoint(p, &c_size);
304
305                 if (c <= 0x1F) {
306                         return NT_STATUS_OBJECT_NAME_INVALID;
307                 }
308
309                 switch (c) {
310                 case '\\':
311                         if (name->has_wildcard) {
312                                 /* wildcards are only allowed in the last part
313                                    of a name */
314                                 return NT_STATUS_OBJECT_NAME_INVALID;
315                         }
316                         if (p > p_start && (p[1] == '\\' || p[1] == '\0')) {
317                                 /* see if it is definately a "\\" or
318                                  * a trailing "\". If it is then fail here,
319                                  * and let the next layer up try again after
320                                  * pvfs_reduce_name() if it wants to. This is
321                                  * much more efficient on average than always
322                                  * scanning for these separately
323                                  */
324                                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
325                         } else {
326                                 *p = '/';
327                         }
328                         break;
329                 case ':':
330                         if (!(flags & PVFS_RESOLVE_STREAMS)) {
331                                 return NT_STATUS_OBJECT_NAME_INVALID;
332                         }
333                         if (name->has_wildcard) {
334                                 return NT_STATUS_OBJECT_NAME_INVALID;
335                         }
336                         status = parse_stream_name(name, p);
337                         if (!NT_STATUS_IS_OK(status)) {
338                                 return status;
339                         }
340                         *p-- = 0;
341                         break;
342                 case '*':
343                 case '>':
344                 case '<':
345                 case '?':
346                 case '"':
347                         if (!(flags & PVFS_RESOLVE_WILDCARD)) {
348                                 return NT_STATUS_OBJECT_NAME_INVALID;
349                         }
350                         name->has_wildcard = true;
351                         break;
352                 case '/':
353                 case '|':
354                         return NT_STATUS_OBJECT_NAME_INVALID;
355                 case '.':
356                         /* see if it is definately a .. or
357                            . component. If it is then fail here, and
358                            let the next layer up try again after
359                            pvfs_reduce_name() if it wants to. This is
360                            much more efficient on average than always
361                            scanning for these separately */
362                         if (p[1] == '.' && 
363                             (p[2] == 0 || p[2] == '\\') &&
364                             (p == p_start || p[-1] == '/')) {
365                                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
366                         }
367                         if ((p[1] == 0 || p[1] == '\\') &&
368                             (p == p_start || p[-1] == '/')) {
369                                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
370                         }
371                         break;
372                 }
373
374                 p += c_size;
375         }
376
377         name->full_name = ret;
378
379         return NT_STATUS_OK;
380 }
381
382
383 /*
384   reduce a name that contains .. components or repeated \ separators
385   return NULL if it can't be reduced
386 */
387 static NTSTATUS pvfs_reduce_name(TALLOC_CTX *mem_ctx, 
388                                  const char **fname, unsigned int flags)
389 {
390         codepoint_t c;
391         size_t c_size, len;
392         int i, num_components, err_count;
393         char **components;
394         char *p, *s, *ret;
395
396         s = talloc_strdup(mem_ctx, *fname);
397         if (s == NULL) return NT_STATUS_NO_MEMORY;
398
399         for (num_components=1, p=s; *p; p += c_size) {
400                 c = next_codepoint(p, &c_size);
401                 if (c == '\\') num_components++;
402         }
403
404         components = talloc_array(s, char *, num_components+1);
405         if (components == NULL) {
406                 talloc_free(s);
407                 return NT_STATUS_NO_MEMORY;
408         }
409
410         components[0] = s;
411         for (i=0, p=s; *p; p += c_size) {
412                 c = next_codepoint(p, &c_size);
413                 if (c == '\\') {
414                         *p = 0;
415                         components[++i] = p+1;
416                 }
417         }
418         components[i+1] = NULL;
419
420         /*
421           rather bizarre!
422
423           '.' components are not allowed, but the rules for what error
424           code to give don't seem to make sense. This is a close
425           approximation.
426         */
427         for (err_count=i=0;components[i];i++) {
428                 if (strcmp(components[i], "") == 0) {
429                         continue;
430                 }
431                 if (ISDOT(components[i]) || err_count) {
432                         err_count++;
433                 }
434         }
435         if (err_count) {
436                 if (flags & PVFS_RESOLVE_WILDCARD) err_count--;
437
438                 if (err_count==1) {
439                         return NT_STATUS_OBJECT_NAME_INVALID;
440                 } else {
441                         return NT_STATUS_OBJECT_PATH_NOT_FOUND;
442                 }
443         }
444
445         /* remove any null components */
446         for (i=0;components[i];i++) {
447                 if (strcmp(components[i], "") == 0) {
448                         memmove(&components[i], &components[i+1], 
449                                 sizeof(char *)*(num_components-i));
450                         i--;
451                         continue;
452                 }
453                 if (ISDOTDOT(components[i])) {
454                         if (i < 1) return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
455                         memmove(&components[i-1], &components[i+1], 
456                                 sizeof(char *)*(num_components-i));
457                         i -= 2;
458                         continue;
459                 }
460         }
461
462         if (components[0] == NULL) {
463                 talloc_free(s);
464                 *fname = talloc_strdup(mem_ctx, "\\");
465                 return NT_STATUS_OK;
466         }
467
468         for (len=i=0;components[i];i++) {
469                 len += strlen(components[i]) + 1;
470         }
471
472         /* rebuild the name */
473         ret = talloc_array(mem_ctx, char, len+1);
474         if (ret == NULL) {
475                 talloc_free(s);
476                 return NT_STATUS_NO_MEMORY;
477         }
478
479         for (len=0,i=0;components[i];i++) {
480                 size_t len1 = strlen(components[i]);
481                 ret[len] = '\\';
482                 memcpy(ret+len+1, components[i], len1);
483                 len += len1 + 1;
484         }       
485         ret[len] = 0;
486
487         talloc_set_name_const(ret, ret);
488
489         talloc_free(s);
490
491         *fname = ret;
492         
493         return NT_STATUS_OK;
494 }
495
496
497 /*
498   resolve a name from relative client format to a struct pvfs_filename
499   the memory for the filename is made as a talloc child of 'name'
500
501   flags include:
502      PVFS_RESOLVE_NO_WILDCARD = wildcards are considered illegal characters
503      PVFS_RESOLVE_STREAMS     = stream names are allowed
504
505      TODO: ../ collapsing, and outside share checking
506 */
507 NTSTATUS pvfs_resolve_name(struct pvfs_state *pvfs, 
508                            struct ntvfs_request *req,
509                            const char *cifs_name,
510                            unsigned int flags, struct pvfs_filename **name)
511 {
512         NTSTATUS status;
513
514         *name = talloc(req, struct pvfs_filename);
515         if (*name == NULL) {
516                 return NT_STATUS_NO_MEMORY;
517         }
518
519         (*name)->exists = false;
520         (*name)->stream_exists = false;
521
522         if (!(pvfs->fs_attribs & FS_ATTR_NAMED_STREAMS)) {
523                 flags &= ~PVFS_RESOLVE_STREAMS;
524         }
525
526         /* SMB2 doesn't allow a leading slash */
527         if (req->ctx->protocol == PROTOCOL_SMB2 &&
528             *cifs_name == '\\') {
529                 return NT_STATUS_INVALID_PARAMETER;
530         }
531
532         /* do the basic conversion to a unix formatted path,
533            also checking for allowable characters */
534         status = pvfs_unix_path(pvfs, cifs_name, flags, *name);
535
536         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
537                 /* it might contain .. components which need to be reduced */
538                 status = pvfs_reduce_name(*name, &cifs_name, flags);
539                 if (!NT_STATUS_IS_OK(status)) {
540                         return status;
541                 }
542                 status = pvfs_unix_path(pvfs, cifs_name, flags, *name);
543         }
544
545         if (!NT_STATUS_IS_OK(status)) {
546                 return status;
547         }
548
549         /* if it has a wildcard then no point doing a stat() of the
550            full name. Instead We need check if the directory exists 
551          */
552         if ((*name)->has_wildcard) {
553                 const char *p;
554                 char *dir_name, *saved_name;
555                 p = strrchr((*name)->full_name, '/');
556                 if (p == NULL) {
557                         /* root directory wildcard is OK */
558                         return NT_STATUS_OK;
559                 }
560                 dir_name = talloc_strndup(*name, (*name)->full_name, (p-(*name)->full_name));
561                 if (stat(dir_name, &(*name)->st) == 0) {
562                         talloc_free(dir_name);
563                         return NT_STATUS_OK;
564                 }
565                 /* we need to search for a matching name */
566                 saved_name = (*name)->full_name;
567                 (*name)->full_name = dir_name;
568                 status = pvfs_case_search(pvfs, *name, flags);
569                 if (!NT_STATUS_IS_OK(status)) {
570                         /* the directory doesn't exist */
571                         (*name)->full_name = saved_name;
572                         return status;
573                 }
574                 /* it does exist, but might need a case change */
575                 if (dir_name != (*name)->full_name) {
576                         (*name)->full_name = talloc_asprintf(*name, "%s%s",
577                                                              (*name)->full_name, p);
578                         NT_STATUS_HAVE_NO_MEMORY((*name)->full_name);
579                 } else {
580                         (*name)->full_name = saved_name;
581                         talloc_free(dir_name);
582                 }
583                 return NT_STATUS_OK;
584         }
585
586         /* if we can stat() the full name now then we are done */
587         if (stat((*name)->full_name, &(*name)->st) == 0) {
588                 (*name)->exists = true;
589                 return pvfs_fill_dos_info(pvfs, *name, flags, -1);
590         }
591
592         /* search for a matching filename */
593         status = pvfs_case_search(pvfs, *name, flags);
594
595         return status;
596 }
597
598
599 /*
600   do a partial resolve, returning a pvfs_filename structure given a
601   base path and a relative component. It is an error if the file does
602   not exist. No case-insensitive matching is done.
603
604   this is used in places like directory searching where we need a pvfs_filename
605   to pass to a function, but already know the unix base directory and component
606 */
607 NTSTATUS pvfs_resolve_partial(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
608                               const char *unix_dir, const char *fname,
609                               unsigned int flags, struct pvfs_filename **name)
610 {
611         NTSTATUS status;
612
613         *name = talloc(mem_ctx, struct pvfs_filename);
614         if (*name == NULL) {
615                 return NT_STATUS_NO_MEMORY;
616         }
617
618         (*name)->full_name = talloc_asprintf(*name, "%s/%s", unix_dir, fname);
619         if ((*name)->full_name == NULL) {
620                 return NT_STATUS_NO_MEMORY;
621         }
622
623         if (stat((*name)->full_name, &(*name)->st) == -1) {
624                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
625         }
626
627         (*name)->exists = true;
628         (*name)->stream_exists = true;
629         (*name)->has_wildcard = false;
630         (*name)->original_name = talloc_strdup(*name, fname);
631         (*name)->stream_name = NULL;
632         (*name)->stream_id = 0;
633
634         status = pvfs_fill_dos_info(pvfs, *name, flags, -1);
635
636         return status;
637 }
638
639
640 /*
641   fill in the pvfs_filename info for an open file, given the current
642   info for a (possibly) non-open file. This is used by places that need
643   to update the pvfs_filename stat information, and by pvfs_open()
644 */
645 NTSTATUS pvfs_resolve_name_fd(struct pvfs_state *pvfs, int fd,
646                               struct pvfs_filename *name, unsigned int flags)
647 {
648         dev_t device = (dev_t)0;
649         ino_t inode = 0;
650
651         if (name->exists) {
652                 device = name->st.st_dev;
653                 inode = name->st.st_ino;
654         }
655
656         if (fd == -1) {
657                 if (stat(name->full_name, &name->st) == -1) {
658                         return NT_STATUS_INVALID_HANDLE;
659                 }
660         } else {
661                 if (fstat(fd, &name->st) == -1) {
662                         return NT_STATUS_INVALID_HANDLE;
663                 }
664         }
665
666         if (name->exists &&
667             (device != name->st.st_dev || inode != name->st.st_ino)) {
668                 /* the file we are looking at has changed! this could
669                  be someone trying to exploit a race
670                  condition. Certainly we don't want to continue
671                  operating on this file */
672                 DEBUG(0,("pvfs: WARNING: file '%s' changed during resolve - failing\n",
673                          name->full_name));
674                 return NT_STATUS_UNEXPECTED_IO_ERROR;
675         }
676
677         name->exists = true;
678         
679         return pvfs_fill_dos_info(pvfs, name, flags, fd);
680 }
681
682 /*
683   fill in the pvfs_filename info for an open file, given the current
684   info for a (possibly) non-open file. This is used by places that need
685   to update the pvfs_filename stat information, and the path
686   after a possible rename on a different handle.
687 */
688 NTSTATUS pvfs_resolve_name_handle(struct pvfs_state *pvfs,
689                                   struct pvfs_file_handle *h)
690 {
691         NTSTATUS status;
692
693         if (h->have_opendb_entry) {
694                 struct odb_lock *lck;
695                 char *name = NULL;
696
697                 lck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
698                 if (lck == NULL) {
699                         DEBUG(0,("%s: failed to lock file '%s' in opendb\n",
700                                  __FUNCTION__, h->name->full_name));
701                         /* we were supposed to do a blocking lock, so something
702                            is badly wrong! */
703                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
704                 }
705
706                 status = odb_get_path(lck, (const char **) &name);
707                 if (NT_STATUS_IS_OK(status)) {
708                         /*
709                          * This relies an the fact that
710                          * renames of open files are only
711                          * allowed by setpathinfo() and setfileinfo()
712                          * and there're only renames within the same
713                          * directory supported
714                          */
715                         if (strcmp(h->name->full_name, name) != 0) {
716                                 const char *orig_dir;
717                                 const char *new_file;
718                                 char *new_orig;
719                                 char *delim;
720
721                                 delim = strrchr(name, '/');
722                                 if (!delim) {
723                                         talloc_free(lck);
724                                         return NT_STATUS_INTERNAL_ERROR;
725                                 }
726
727                                 new_file = delim + 1;
728                                 delim = strrchr(h->name->original_name, '\\');
729                                 if (delim) {
730                                         delim[0] = '\0';
731                                         orig_dir = h->name->original_name;
732                                         new_orig = talloc_asprintf(h->name, "%s\\%s",
733                                                                    orig_dir, new_file);
734                                         if (!new_orig) {
735                                                 talloc_free(lck);
736                                                 return NT_STATUS_NO_MEMORY;
737                                         }
738                                 } else {
739                                         new_orig = talloc_strdup(h->name, new_file);
740                                         if (!new_orig) {
741                                                 talloc_free(lck);
742                                                 return NT_STATUS_NO_MEMORY;
743                                         }
744                                 }
745
746                                 talloc_free(h->name->original_name);
747                                 talloc_free(h->name->full_name);
748                                 h->name->full_name = talloc_steal(h->name, name);
749                                 h->name->original_name = new_orig;
750                         }
751                 }
752
753                 talloc_free(lck);
754         }
755
756         /*
757          * TODO: pass PVFS_RESOLVE_NO_OPENDB and get
758          *       the write time from odb_lock() above.
759          */
760         status = pvfs_resolve_name_fd(pvfs, h->fd, h->name, 0);
761         NT_STATUS_NOT_OK_RETURN(status);
762
763         if (!null_nttime(h->write_time.close_time)) {
764                 h->name->dos.write_time = h->write_time.close_time;
765         }
766
767         return NT_STATUS_OK;
768 }
769
770
771 /*
772   resolve the parent of a given name
773 */
774 NTSTATUS pvfs_resolve_parent(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
775                              const struct pvfs_filename *child,
776                              struct pvfs_filename **name)
777 {
778         NTSTATUS status;
779         char *p;
780
781         *name = talloc(mem_ctx, struct pvfs_filename);
782         if (*name == NULL) {
783                 return NT_STATUS_NO_MEMORY;
784         }
785
786         (*name)->full_name = talloc_strdup(*name, child->full_name);
787         if ((*name)->full_name == NULL) {
788                 return NT_STATUS_NO_MEMORY;
789         }
790
791         p = strrchr_m((*name)->full_name, '/');
792         if (p == NULL) {
793                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
794         }
795
796         /* this handles the root directory */
797         if (p == (*name)->full_name) {
798                 p[1] = 0;
799         } else {
800                 p[0] = 0;
801         }
802
803         if (stat((*name)->full_name, &(*name)->st) == -1) {
804                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
805         }
806
807         (*name)->exists = true;
808         (*name)->stream_exists = true;
809         (*name)->has_wildcard = false;
810         /* we can't get the correct 'original_name', but for the purposes
811            of this call this is close enough */
812         (*name)->original_name = talloc_strdup(*name, child->original_name);
813         if ((*name)->original_name == NULL) {
814                 return NT_STATUS_NO_MEMORY;
815         }
816         (*name)->stream_name = NULL;
817         (*name)->stream_id = 0;
818
819         status = pvfs_fill_dos_info(pvfs, *name, PVFS_RESOLVE_NO_OPENDB, -1);
820
821         return status;
822 }