8c5806d93ffceac1047b268cfbd65622ae702f18
[ira/wip.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                                  uint_t 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 smb_iconv_convenience *ic,
190                                   struct pvfs_filename *name,
191                                   const char *s)
192 {
193         char *p, *stream_name;
194         if (s[1] == '\0') {
195                 return NT_STATUS_OBJECT_NAME_INVALID;
196         }
197         name->stream_name = stream_name = talloc_strdup(name, s+1);
198         if (name->stream_name == NULL) {
199                 return NT_STATUS_NO_MEMORY;
200         }
201
202         p = stream_name;
203
204         while (*p) {
205                 size_t c_size;
206                 codepoint_t c = next_codepoint_convenience(ic, p, &c_size);
207
208                 switch (c) {
209                 case '/':
210                 case '\\':
211                         return NT_STATUS_OBJECT_NAME_INVALID;
212                 case ':':
213                         *p= 0;
214                         p++;
215                         if (*p == '\0') {
216                                 return NT_STATUS_OBJECT_NAME_INVALID;
217                         }
218                         if (strcasecmp_m(p, "$DATA") != 0) {
219                                 if (strchr_m(p, ':')) {
220                                         return NT_STATUS_OBJECT_NAME_INVALID;
221                                 }
222                                 return NT_STATUS_INVALID_PARAMETER;
223                         }
224                         c_size = 0;
225                         p--;
226                         break;
227                 }
228
229                 p += c_size;
230         }
231
232         if (strcmp(name->stream_name, "") == 0) {
233                 /*
234                  * we don't set stream_name to NULL, here
235                  * as this would be wrong for directories
236                  *
237                  * pvfs_fill_dos_info() will set it to NULL
238                  * if it's not a directory.
239                  */
240                 name->stream_id = 0;
241         } else {
242                 name->stream_id = pvfs_name_hash(name->stream_name, 
243                                                  strlen(name->stream_name));
244         }
245                                                  
246         return NT_STATUS_OK;    
247 }
248
249
250 /*
251   convert a CIFS pathname to a unix pathname. Note that this does NOT
252   take into account case insensitivity, and in fact does not access
253   the filesystem at all. It is merely a reformatting and charset
254   checking routine.
255
256   errors are returned if the filename is illegal given the flags
257 */
258 static NTSTATUS pvfs_unix_path(struct pvfs_state *pvfs, const char *cifs_name,
259                                uint_t flags, struct pvfs_filename *name)
260 {
261         char *ret, *p, *p_start;
262         struct smb_iconv_convenience *ic = NULL;
263         NTSTATUS status;
264
265         name->original_name = talloc_strdup(name, cifs_name);
266         name->stream_name = NULL;
267         name->stream_id = 0;
268         name->has_wildcard = false;
269
270         while (*cifs_name == '\\') {
271                 cifs_name++;
272         }
273
274         if (*cifs_name == 0) {
275                 name->full_name = talloc_asprintf(name, "%s/.", pvfs->base_directory);
276                 if (name->full_name == NULL) {
277                         return NT_STATUS_NO_MEMORY;
278                 }
279                 return NT_STATUS_OK;
280         }
281
282         ret = talloc_asprintf(name, "%s/%s", pvfs->base_directory, cifs_name);
283         if (ret == NULL) {
284                 return NT_STATUS_NO_MEMORY;
285         }
286
287         p = ret + strlen(pvfs->base_directory) + 1;
288
289         /* now do an in-place conversion of '\' to '/', checking
290            for legal characters */
291         p_start = p;
292
293         ic = lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx);
294         while (*p) {
295                 size_t c_size;
296                 codepoint_t c = next_codepoint_convenience(ic, p, &c_size);
297
298                 if (c <= 0x1F) {
299                         return NT_STATUS_OBJECT_NAME_INVALID;
300                 }
301
302                 switch (c) {
303                 case '\\':
304                         if (name->has_wildcard) {
305                                 /* wildcards are only allowed in the last part
306                                    of a name */
307                                 return NT_STATUS_OBJECT_NAME_INVALID;
308                         }
309                         if (p > p_start && (p[1] == '\\' || p[1] == '\0')) {
310                                 /* see if it is definately a "\\" or
311                                  * a trailing "\". If it is then fail here,
312                                  * and let the next layer up try again after
313                                  * pvfs_reduce_name() if it wants to. This is
314                                  * much more efficient on average than always
315                                  * scanning for these separately
316                                  */
317                                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
318                         } else {
319                                 *p = '/';
320                         }
321                         break;
322                 case ':':
323                         if (!(flags & PVFS_RESOLVE_STREAMS)) {
324                                 return NT_STATUS_OBJECT_NAME_INVALID;
325                         }
326                         if (name->has_wildcard) {
327                                 return NT_STATUS_OBJECT_NAME_INVALID;
328                         }
329                         status = parse_stream_name(ic, name, p);
330                         if (!NT_STATUS_IS_OK(status)) {
331                                 return status;
332                         }
333                         *p-- = 0;
334                         break;
335                 case '*':
336                 case '>':
337                 case '<':
338                 case '?':
339                 case '"':
340                         if (!(flags & PVFS_RESOLVE_WILDCARD)) {
341                                 return NT_STATUS_OBJECT_NAME_INVALID;
342                         }
343                         name->has_wildcard = true;
344                         break;
345                 case '/':
346                 case '|':
347                         return NT_STATUS_OBJECT_NAME_INVALID;
348                 case '.':
349                         /* see if it is definately a .. or
350                            . component. If it is then fail here, and
351                            let the next layer up try again after
352                            pvfs_reduce_name() if it wants to. This is
353                            much more efficient on average than always
354                            scanning for these separately */
355                         if (p[1] == '.' && 
356                             (p[2] == 0 || p[2] == '\\') &&
357                             (p == p_start || p[-1] == '/')) {
358                                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
359                         }
360                         if ((p[1] == 0 || p[1] == '\\') &&
361                             (p == p_start || p[-1] == '/')) {
362                                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
363                         }
364                         break;
365                 }
366
367                 p += c_size;
368         }
369
370         name->full_name = ret;
371
372         return NT_STATUS_OK;
373 }
374
375
376 /*
377   reduce a name that contains .. components or repeated \ separators
378   return NULL if it can't be reduced
379 */
380 static NTSTATUS pvfs_reduce_name(TALLOC_CTX *mem_ctx, 
381                                  struct smb_iconv_convenience *iconv_convenience, 
382                                  const char **fname, uint_t flags)
383 {
384         codepoint_t c;
385         size_t c_size, len;
386         int i, num_components, err_count;
387         char **components;
388         char *p, *s, *ret;
389
390         s = talloc_strdup(mem_ctx, *fname);
391         if (s == NULL) return NT_STATUS_NO_MEMORY;
392
393         for (num_components=1, p=s; *p; p += c_size) {
394                 c = next_codepoint_convenience(iconv_convenience, p, &c_size);
395                 if (c == '\\') num_components++;
396         }
397
398         components = talloc_array(s, char *, num_components+1);
399         if (components == NULL) {
400                 talloc_free(s);
401                 return NT_STATUS_NO_MEMORY;
402         }
403
404         components[0] = s;
405         for (i=0, p=s; *p; p += c_size) {
406                 c = next_codepoint_convenience(iconv_convenience, p, &c_size);
407                 if (c == '\\') {
408                         *p = 0;
409                         components[++i] = p+1;
410                 }
411         }
412         components[i+1] = NULL;
413
414         /*
415           rather bizarre!
416
417           '.' components are not allowed, but the rules for what error
418           code to give don't seem to make sense. This is a close
419           approximation.
420         */
421         for (err_count=i=0;components[i];i++) {
422                 if (strcmp(components[i], "") == 0) {
423                         continue;
424                 }
425                 if (ISDOT(components[i]) || err_count) {
426                         err_count++;
427                 }
428         }
429         if (err_count) {
430                 if (flags & PVFS_RESOLVE_WILDCARD) err_count--;
431
432                 if (err_count==1) {
433                         return NT_STATUS_OBJECT_NAME_INVALID;
434                 } else {
435                         return NT_STATUS_OBJECT_PATH_NOT_FOUND;
436                 }
437         }
438
439         /* remove any null components */
440         for (i=0;components[i];i++) {
441                 if (strcmp(components[i], "") == 0) {
442                         memmove(&components[i], &components[i+1], 
443                                 sizeof(char *)*(num_components-i));
444                         i--;
445                         continue;
446                 }
447                 if (ISDOTDOT(components[i])) {
448                         if (i < 1) return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
449                         memmove(&components[i-1], &components[i+1], 
450                                 sizeof(char *)*(num_components-i));
451                         i -= 2;
452                         continue;
453                 }
454         }
455
456         if (components[0] == NULL) {
457                 talloc_free(s);
458                 *fname = talloc_strdup(mem_ctx, "\\");
459                 return NT_STATUS_OK;
460         }
461
462         for (len=i=0;components[i];i++) {
463                 len += strlen(components[i]) + 1;
464         }
465
466         /* rebuild the name */
467         ret = talloc_array(mem_ctx, char, len+1);
468         if (ret == NULL) {
469                 talloc_free(s);
470                 return NT_STATUS_NO_MEMORY;
471         }
472
473         for (len=0,i=0;components[i];i++) {
474                 size_t len1 = strlen(components[i]);
475                 ret[len] = '\\';
476                 memcpy(ret+len+1, components[i], len1);
477                 len += len1 + 1;
478         }       
479         ret[len] = 0;
480
481         talloc_set_name_const(ret, ret);
482
483         talloc_free(s);
484
485         *fname = ret;
486         
487         return NT_STATUS_OK;
488 }
489
490
491 /*
492   resolve a name from relative client format to a struct pvfs_filename
493   the memory for the filename is made as a talloc child of 'name'
494
495   flags include:
496      PVFS_RESOLVE_NO_WILDCARD = wildcards are considered illegal characters
497      PVFS_RESOLVE_STREAMS     = stream names are allowed
498
499      TODO: ../ collapsing, and outside share checking
500 */
501 NTSTATUS pvfs_resolve_name(struct pvfs_state *pvfs, 
502                            struct ntvfs_request *req,
503                            const char *cifs_name,
504                            uint_t flags, struct pvfs_filename **name)
505 {
506         NTSTATUS status;
507
508         *name = talloc(req, struct pvfs_filename);
509         if (*name == NULL) {
510                 return NT_STATUS_NO_MEMORY;
511         }
512
513         (*name)->exists = false;
514         (*name)->stream_exists = false;
515
516         if (!(pvfs->fs_attribs & FS_ATTR_NAMED_STREAMS)) {
517                 flags &= ~PVFS_RESOLVE_STREAMS;
518         }
519
520         /* SMB2 doesn't allow a leading slash */
521         if (req->ctx->protocol == PROTOCOL_SMB2 &&
522             *cifs_name == '\\') {
523                 return NT_STATUS_INVALID_PARAMETER;
524         }
525
526         /* do the basic conversion to a unix formatted path,
527            also checking for allowable characters */
528         status = pvfs_unix_path(pvfs, cifs_name, flags, *name);
529
530         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
531                 /* it might contain .. components which need to be reduced */
532                 status = pvfs_reduce_name(*name, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx), &cifs_name, flags);
533                 if (!NT_STATUS_IS_OK(status)) {
534                         return status;
535                 }
536                 status = pvfs_unix_path(pvfs, cifs_name, flags, *name);
537         }
538
539         if (!NT_STATUS_IS_OK(status)) {
540                 return status;
541         }
542
543         /* if it has a wildcard then no point doing a stat() of the
544            full name. Instead We need check if the directory exists 
545          */
546         if ((*name)->has_wildcard) {
547                 const char *p;
548                 char *dir_name, *saved_name;
549                 p = strrchr((*name)->full_name, '/');
550                 if (p == NULL) {
551                         /* root directory wildcard is OK */
552                         return NT_STATUS_OK;
553                 }
554                 dir_name = talloc_strndup(*name, (*name)->full_name, (p-(*name)->full_name));
555                 if (stat(dir_name, &(*name)->st) == 0) {
556                         talloc_free(dir_name);
557                         return NT_STATUS_OK;
558                 }
559                 /* we need to search for a matching name */
560                 saved_name = (*name)->full_name;
561                 (*name)->full_name = dir_name;
562                 status = pvfs_case_search(pvfs, *name, flags);
563                 if (!NT_STATUS_IS_OK(status)) {
564                         /* the directory doesn't exist */
565                         (*name)->full_name = saved_name;
566                         return status;
567                 }
568                 /* it does exist, but might need a case change */
569                 if (dir_name != (*name)->full_name) {
570                         (*name)->full_name = talloc_asprintf(*name, "%s%s",
571                                                              (*name)->full_name, p);
572                         NT_STATUS_HAVE_NO_MEMORY((*name)->full_name);
573                 } else {
574                         (*name)->full_name = saved_name;
575                         talloc_free(dir_name);
576                 }
577                 return NT_STATUS_OK;
578         }
579
580         /* if we can stat() the full name now then we are done */
581         if (stat((*name)->full_name, &(*name)->st) == 0) {
582                 (*name)->exists = true;
583                 return pvfs_fill_dos_info(pvfs, *name, flags, -1);
584         }
585
586         /* search for a matching filename */
587         status = pvfs_case_search(pvfs, *name, flags);
588
589         return status;
590 }
591
592
593 /*
594   do a partial resolve, returning a pvfs_filename structure given a
595   base path and a relative component. It is an error if the file does
596   not exist. No case-insensitive matching is done.
597
598   this is used in places like directory searching where we need a pvfs_filename
599   to pass to a function, but already know the unix base directory and component
600 */
601 NTSTATUS pvfs_resolve_partial(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
602                               const char *unix_dir, const char *fname,
603                               uint_t flags, struct pvfs_filename **name)
604 {
605         NTSTATUS status;
606
607         *name = talloc(mem_ctx, struct pvfs_filename);
608         if (*name == NULL) {
609                 return NT_STATUS_NO_MEMORY;
610         }
611
612         (*name)->full_name = talloc_asprintf(*name, "%s/%s", unix_dir, fname);
613         if ((*name)->full_name == NULL) {
614                 return NT_STATUS_NO_MEMORY;
615         }
616
617         if (stat((*name)->full_name, &(*name)->st) == -1) {
618                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
619         }
620
621         (*name)->exists = true;
622         (*name)->stream_exists = true;
623         (*name)->has_wildcard = false;
624         (*name)->original_name = talloc_strdup(*name, fname);
625         (*name)->stream_name = NULL;
626         (*name)->stream_id = 0;
627
628         status = pvfs_fill_dos_info(pvfs, *name, flags, -1);
629
630         return status;
631 }
632
633
634 /*
635   fill in the pvfs_filename info for an open file, given the current
636   info for a (possibly) non-open file. This is used by places that need
637   to update the pvfs_filename stat information, and by pvfs_open()
638 */
639 NTSTATUS pvfs_resolve_name_fd(struct pvfs_state *pvfs, int fd,
640                               struct pvfs_filename *name, uint_t flags)
641 {
642         dev_t device = (dev_t)0;
643         ino_t inode = 0;
644
645         if (name->exists) {
646                 device = name->st.st_dev;
647                 inode = name->st.st_ino;
648         }
649
650         if (fd == -1) {
651                 if (stat(name->full_name, &name->st) == -1) {
652                         return NT_STATUS_INVALID_HANDLE;
653                 }
654         } else {
655                 if (fstat(fd, &name->st) == -1) {
656                         return NT_STATUS_INVALID_HANDLE;
657                 }
658         }
659
660         if (name->exists &&
661             (device != name->st.st_dev || inode != name->st.st_ino)) {
662                 /* the file we are looking at has changed! this could
663                  be someone trying to exploit a race
664                  condition. Certainly we don't want to continue
665                  operating on this file */
666                 DEBUG(0,("pvfs: WARNING: file '%s' changed during resolve - failing\n",
667                          name->full_name));
668                 return NT_STATUS_UNEXPECTED_IO_ERROR;
669         }
670
671         name->exists = true;
672         
673         return pvfs_fill_dos_info(pvfs, name, flags, fd);
674 }
675
676 /*
677   fill in the pvfs_filename info for an open file, given the current
678   info for a (possibly) non-open file. This is used by places that need
679   to update the pvfs_filename stat information, and the path
680   after a possible rename on a different handle.
681 */
682 NTSTATUS pvfs_resolve_name_handle(struct pvfs_state *pvfs,
683                                   struct pvfs_file_handle *h)
684 {
685         NTSTATUS status;
686
687         if (h->have_opendb_entry) {
688                 struct odb_lock *lck;
689                 const char *name = NULL;
690
691                 lck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
692                 if (lck == NULL) {
693                         DEBUG(0,("%s: failed to lock file '%s' in opendb\n",
694                                  __FUNCTION__, h->name->full_name));
695                         /* we were supposed to do a blocking lock, so something
696                            is badly wrong! */
697                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
698                 }
699
700                 status = odb_get_path(lck, &name);
701                 if (NT_STATUS_IS_OK(status)) {
702                         /*
703                          * This relies an the fact that
704                          * renames of open files are only
705                          * allowed by setpathinfo() and setfileinfo()
706                          * and there're only renames within the same
707                          * directory supported
708                          */
709                         if (strcmp(h->name->full_name, name) != 0) {
710                                 const char *orig_dir;
711                                 const char *new_file;
712                                 const char *new_orig;
713                                 char *delim;
714
715                                 delim = strrchr(name, '/');
716                                 if (!delim) {
717                                         talloc_free(lck);
718                                         return NT_STATUS_INTERNAL_ERROR;
719                                 }
720
721                                 new_file = delim + 1;
722                                 delim = strrchr(h->name->original_name, '\\');
723                                 if (delim) {
724                                         delim[0] = '\0';
725                                         orig_dir = h->name->original_name;
726                                         new_orig = talloc_asprintf(h->name, "%s\\%s",
727                                                                    orig_dir, new_file);
728                                         if (!new_orig) {
729                                                 talloc_free(lck);
730                                                 return NT_STATUS_NO_MEMORY;
731                                         }
732                                 } else {
733                                         new_orig = talloc_strdup(h->name, new_file);
734                                         if (!new_orig) {
735                                                 talloc_free(lck);
736                                                 return NT_STATUS_NO_MEMORY;
737                                         }
738                                 }
739
740                                 talloc_free(h->name->original_name);
741                                 talloc_free(h->name->full_name);
742                                 h->name->full_name = talloc_steal(h->name, name);
743                                 h->name->original_name = new_orig;
744                         }
745                 }
746
747                 talloc_free(lck);
748         }
749
750         /*
751          * TODO: pass PVFS_RESOLVE_NO_OPENDB and get
752          *       the write time from odb_lock() above.
753          */
754         status = pvfs_resolve_name_fd(pvfs, h->fd, h->name, 0);
755         NT_STATUS_NOT_OK_RETURN(status);
756
757         if (!null_nttime(h->write_time.close_time)) {
758                 h->name->dos.write_time = h->write_time.close_time;
759         }
760
761         return NT_STATUS_OK;
762 }
763
764
765 /*
766   resolve the parent of a given name
767 */
768 NTSTATUS pvfs_resolve_parent(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
769                              const struct pvfs_filename *child,
770                              struct pvfs_filename **name)
771 {
772         NTSTATUS status;
773         char *p;
774
775         *name = talloc(mem_ctx, struct pvfs_filename);
776         if (*name == NULL) {
777                 return NT_STATUS_NO_MEMORY;
778         }
779
780         (*name)->full_name = talloc_strdup(*name, child->full_name);
781         if ((*name)->full_name == NULL) {
782                 return NT_STATUS_NO_MEMORY;
783         }
784
785         p = strrchr_m((*name)->full_name, '/');
786         if (p == NULL) {
787                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
788         }
789
790         /* this handles the root directory */
791         if (p == (*name)->full_name) {
792                 p[1] = 0;
793         } else {
794                 p[0] = 0;
795         }
796
797         if (stat((*name)->full_name, &(*name)->st) == -1) {
798                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
799         }
800
801         (*name)->exists = true;
802         (*name)->stream_exists = true;
803         (*name)->has_wildcard = false;
804         /* we can't get the correct 'original_name', but for the purposes
805            of this call this is close enough */
806         (*name)->original_name = talloc_strdup(*name, child->original_name);
807         if ((*name)->original_name == NULL) {
808                 return NT_STATUS_NO_MEMORY;
809         }
810         (*name)->stream_name = NULL;
811         (*name)->stream_id = 0;
812
813         status = pvfs_fill_dos_info(pvfs, *name, PVFS_RESOLVE_NO_OPENDB, -1);
814
815         return status;
816 }