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;
 194         if (s[1] == '\0') {
 195                 return NT_STATUS_OBJECT_NAME_INVALID;
 196         }
 197         name->stream_name = talloc_strdup(name, s+1);
 198         if (name->stream_name == NULL) {
 199                 return NT_STATUS_NO_MEMORY;
 200         }
 201
 202         p = name->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_size(mem_ctx, 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_free(s);
 482
 483         *fname = ret;
 484
 485         return NT_STATUS_OK;
 486 }
 487
 488
 489 /*
 490   resolve a name from relative client format to a struct pvfs_filename
 491   the memory for the filename is made as a talloc child of 'name'
 492
 493   flags include:
 494      PVFS_RESOLVE_NO_WILDCARD = wildcards are considered illegal characters
 495      PVFS_RESOLVE_STREAMS     = stream names are allowed
 496
 497      TODO: ../ collapsing, and outside share checking
 498 */
 499 NTSTATUS pvfs_resolve_name(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
 500                            const char *cifs_name,
 501                            uint_t flags, struct pvfs_filename **name)
 502 {
 503         NTSTATUS status;
 504
 505         *name = talloc(mem_ctx, struct pvfs_filename);
 506         if (*name == NULL) {
 507                 return NT_STATUS_NO_MEMORY;
 508         }
 509
 510         (*name)->exists = false;
 511         (*name)->stream_exists = false;
 512
 513         if (!(pvfs->fs_attribs & FS_ATTR_NAMED_STREAMS)) {
 514                 flags &= ~PVFS_RESOLVE_STREAMS;
 515         }
 516
 517         /* do the basic conversion to a unix formatted path,
 518            also checking for allowable characters */
 519         status = pvfs_unix_path(pvfs, cifs_name, flags, *name);
 520
 521         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_SYNTAX_BAD)) {
 522                 /* it might contain .. components which need to be reduced */
 523                 status = pvfs_reduce_name(*name, lp_iconv_convenience(pvfs->ntvfs->ctx->lp_ctx), &cifs_name, flags);
 524                 if (!NT_STATUS_IS_OK(status)) {
 525                         return status;
 526                 }
 527                 status = pvfs_unix_path(pvfs, cifs_name, flags, *name);
 528         }
 529
 530         if (!NT_STATUS_IS_OK(status)) {
 531                 return status;
 532         }
 533
 534         /* if it has a wildcard then no point doing a stat() of the
 535            full name. Instead We need check if the directory exists
 536          */
 537         if ((*name)->has_wildcard) {
 538                 const char *p;
 539                 char *dir_name, *saved_name;
 540                 p = strrchr((*name)->full_name, '/');
 541                 if (p == NULL) {
 542                         /* root directory wildcard is OK */
 543                         return NT_STATUS_OK;
 544                 }
 545                 dir_name = talloc_strndup(*name, (*name)->full_name, (p-(*name)->full_name));
 546                 if (stat(dir_name, &(*name)->st) == 0) {
 547                         talloc_free(dir_name);
 548                         return NT_STATUS_OK;
 549                 }
 550                 /* we need to search for a matching name */
 551                 saved_name = (*name)->full_name;
 552                 (*name)->full_name = dir_name;
 553                 status = pvfs_case_search(pvfs, *name, flags);
 554                 if (!NT_STATUS_IS_OK(status)) {
 555                         /* the directory doesn't exist */
 556                         (*name)->full_name = saved_name;
 557                         return status;
 558                 }
 559                 /* it does exist, but might need a case change */
 560                 if (dir_name != (*name)->full_name) {
 561                         (*name)->full_name = talloc_asprintf(*name, "%s%s",
 562                                                              (*name)->full_name, p);
 563                         NT_STATUS_HAVE_NO_MEMORY((*name)->full_name);
 564                 } else {
 565                         (*name)->full_name = saved_name;
 566                         talloc_free(dir_name);
 567                 }
 568                 return NT_STATUS_OK;
 569         }
 570
 571         /* if we can stat() the full name now then we are done */
 572         if (stat((*name)->full_name, &(*name)->st) == 0) {
 573                 (*name)->exists = true;
 574                 return pvfs_fill_dos_info(pvfs, *name, flags, -1);
 575         }
 576
 577         /* search for a matching filename */
 578         status = pvfs_case_search(pvfs, *name, flags);
 579
 580         return status;
 581 }
 582
 583
 584 /*
 585   do a partial resolve, returning a pvfs_filename structure given a
 586   base path and a relative component. It is an error if the file does
 587   not exist. No case-insensitive matching is done.
 588
 589   this is used in places like directory searching where we need a pvfs_filename
 590   to pass to a function, but already know the unix base directory and component
 591 */
 592 NTSTATUS pvfs_resolve_partial(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
 593                               const char *unix_dir, const char *fname,
 594                               uint_t flags, struct pvfs_filename **name)
 595 {
 596         NTSTATUS status;
 597
 598         *name = talloc(mem_ctx, struct pvfs_filename);
 599         if (*name == NULL) {
 600                 return NT_STATUS_NO_MEMORY;
 601         }
 602
 603         (*name)->full_name = talloc_asprintf(*name, "%s/%s", unix_dir, fname);
 604         if ((*name)->full_name == NULL) {
 605                 return NT_STATUS_NO_MEMORY;
 606         }
 607
 608         if (stat((*name)->full_name, &(*name)->st) == -1) {
 609                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 610         }
 611
 612         (*name)->exists = true;
 613         (*name)->stream_exists = true;
 614         (*name)->has_wildcard = false;
 615         (*name)->original_name = talloc_strdup(*name, fname);
 616         (*name)->stream_name = NULL;
 617         (*name)->stream_id = 0;
 618
 619         status = pvfs_fill_dos_info(pvfs, *name, flags, -1);
 620
 621         return status;
 622 }
 623
 624
 625 /*
 626   fill in the pvfs_filename info for an open file, given the current
 627   info for a (possibly) non-open file. This is used by places that need
 628   to update the pvfs_filename stat information, and by pvfs_open()
 629 */
 630 NTSTATUS pvfs_resolve_name_fd(struct pvfs_state *pvfs, int fd,
 631                               struct pvfs_filename *name, uint_t flags)
 632 {
 633         dev_t device = (dev_t)0;
 634         ino_t inode = 0;
 635
 636         if (name->exists) {
 637                 device = name->st.st_dev;
 638                 inode = name->st.st_ino;
 639         }
 640
 641         if (fd == -1) {
 642                 if (stat(name->full_name, &name->st) == -1) {
 643                         return NT_STATUS_INVALID_HANDLE;
 644                 }
 645         } else {
 646                 if (fstat(fd, &name->st) == -1) {
 647                         return NT_STATUS_INVALID_HANDLE;
 648                 }
 649         }
 650
 651         if (name->exists &&
 652             (device != name->st.st_dev || inode != name->st.st_ino)) {
 653                 /* the file we are looking at has changed! this could
 654                  be someone trying to exploit a race
 655                  condition. Certainly we don't want to continue
 656                  operating on this file */
 657                 DEBUG(0,("pvfs: WARNING: file '%s' changed during resolve - failing\n",
 658                          name->full_name));
 659                 return NT_STATUS_UNEXPECTED_IO_ERROR;
 660         }
 661
 662         name->exists = true;
 663
 664         return pvfs_fill_dos_info(pvfs, name, flags, fd);
 665 }
 666
 667 /*
 668   fill in the pvfs_filename info for an open file, given the current
 669   info for a (possibly) non-open file. This is used by places that need
 670   to update the pvfs_filename stat information, and the path
 671   after a possible rename on a different handle.
 672 */
 673 NTSTATUS pvfs_resolve_name_handle(struct pvfs_state *pvfs,
 674                                   struct pvfs_file_handle *h)
 675 {
 676         NTSTATUS status;
 677
 678         if (h->have_opendb_entry) {
 679                 struct odb_lock *lck;
 680                 const char *name = NULL;
 681
 682                 lck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
 683                 if (lck == NULL) {
 684                         DEBUG(0,("%s: failed to lock file '%s' in opendb\n",
 685                                  __FUNCTION__, h->name->full_name));
 686                         /* we were supposed to do a blocking lock, so something
 687                            is badly wrong! */
 688                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 689                 }
 690
 691                 status = odb_get_path(lck, &name);
 692                 if (NT_STATUS_IS_OK(status)) {
 693                         /*
 694                          * This relies an the fact that
 695                          * renames of open files are only
 696                          * allowed by setpathinfo() and setfileinfo()
 697                          * and there're only renames within the same
 698                          * directory supported
 699                          */
 700                         if (strcmp(h->name->full_name, name) != 0) {
 701                                 const char *orig_dir;
 702                                 const char *new_file;
 703                                 const char *new_orig;
 704                                 char *delim;
 705
 706                                 delim = strrchr(name, '/');
 707                                 if (!delim) {
 708                                         talloc_free(lck);
 709                                         return NT_STATUS_INTERNAL_ERROR;
 710                                 }
 711
 712                                 new_file = delim + 1;
 713                                 delim = strrchr(h->name->original_name, '\\');
 714                                 if (delim) {
 715                                         delim[0] = '\0';
 716                                         orig_dir = h->name->original_name;
 717                                         new_orig = talloc_asprintf(h->name, "%s\\%s",
 718                                                                    orig_dir, new_file);
 719                                         if (!new_orig) {
 720                                                 talloc_free(lck);
 721                                                 return NT_STATUS_NO_MEMORY;
 722                                         }
 723                                 } else {
 724                                         new_orig = talloc_strdup(h->name, new_file);
 725                                         if (!new_orig) {
 726                                                 talloc_free(lck);
 727                                                 return NT_STATUS_NO_MEMORY;
 728                                         }
 729                                 }
 730
 731                                 talloc_free(h->name->original_name);
 732                                 talloc_free(h->name->full_name);
 733                                 h->name->full_name = talloc_steal(h->name, name);
 734                                 h->name->original_name = new_orig;
 735                         }
 736                 }
 737
 738                 talloc_free(lck);
 739         }
 740
 741         /*
 742          * TODO: pass PVFS_RESOLVE_NO_OPENDB and get
 743          *       the write time from odb_lock() above.
 744          */
 745         status = pvfs_resolve_name_fd(pvfs, h->fd, h->name, 0);
 746         NT_STATUS_NOT_OK_RETURN(status);
 747
 748         if (!null_nttime(h->write_time.close_time)) {
 749                 h->name->dos.write_time = h->write_time.close_time;
 750         }
 751
 752         return NT_STATUS_OK;
 753 }
 754
 755
 756 /*
 757   resolve the parent of a given name
 758 */
 759 NTSTATUS pvfs_resolve_parent(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
 760                              const struct pvfs_filename *child,
 761                              struct pvfs_filename **name)
 762 {
 763         NTSTATUS status;
 764         char *p;
 765
 766         *name = talloc(mem_ctx, struct pvfs_filename);
 767         if (*name == NULL) {
 768                 return NT_STATUS_NO_MEMORY;
 769         }
 770
 771         (*name)->full_name = talloc_strdup(*name, child->full_name);
 772         if ((*name)->full_name == NULL) {
 773                 return NT_STATUS_NO_MEMORY;
 774         }
 775
 776         p = strrchr_m((*name)->full_name, '/');
 777         if (p == NULL) {
 778                 return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
 779         }
 780
 781         /* this handles the root directory */
 782         if (p == (*name)->full_name) {
 783                 p[1] = 0;
 784         } else {
 785                 p[0] = 0;
 786         }
 787
 788         if (stat((*name)->full_name, &(*name)->st) == -1) {
 789                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 790         }
 791
 792         (*name)->exists = true;
 793         (*name)->stream_exists = true;
 794         (*name)->has_wildcard = false;
 795         /* we can't get the correct 'original_name', but for the purposes
 796            of this call this is close enough */
 797         (*name)->original_name = talloc_reference(*name, child->original_name);
 798         (*name)->stream_name = NULL;
 799         (*name)->stream_id = 0;
 800
 801         status = pvfs_fill_dos_info(pvfs, *name, PVFS_RESOLVE_NO_OPENDB, -1);
 802
 803         return status;
 804 }