source3/smbd/filename.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    filename handling routines
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 1999-2007
   6    Copyright (C) Ying Chen 2000
   7    Copyright (C) Volker Lendecke 2007
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 /*
  24  * New hash table stat cache code added by Ying Chen.
  25  */
  26
  27 #include "includes.h"
  28
  29 static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
  30                                   connection_struct *conn,
  31                                   const char *orig_path,
  32                                   struct smb_filename *smb_fname);
  33
  34 /****************************************************************************
  35  Mangle the 2nd name and check if it is then equal to the first name.
  36 ****************************************************************************/
  37
  38 static bool mangled_equal(const char *name1,
  39                         const char *name2,
  40                         const struct share_params *p)
  41 {
  42         char mname[13];
  43
  44         if (!name_to_8_3(name2, mname, False, p)) {
  45                 return False;
  46         }
  47         return strequal(name1, mname);
  48 }
  49
  50 /****************************************************************************
  51  Cope with the differing wildcard and non-wildcard error cases.
  52 ****************************************************************************/
  53
  54 static NTSTATUS determine_path_error(const char *name,
  55                         bool allow_wcard_last_component)
  56 {
  57         const char *p;
  58
  59         if (!allow_wcard_last_component) {
  60                 /* Error code within a pathname. */
  61                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
  62         }
  63
  64         /* We're terminating here so we
  65          * can be a little slower and get
  66          * the error code right. Windows
  67          * treats the last part of the pathname
  68          * separately I think, so if the last
  69          * component is a wildcard then we treat
  70          * this ./ as "end of component" */
  71
  72         p = strchr(name, '/');
  73
  74         if (!p && (ms_has_wild(name) || ISDOT(name))) {
  75                 /* Error code at the end of a pathname. */
  76                 return NT_STATUS_OBJECT_NAME_INVALID;
  77         } else {
  78                 /* Error code within a pathname. */
  79                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
  80         }
  81 }
  82
  83 /****************************************************************************
  84 This routine is called to convert names from the dos namespace to unix
  85 namespace. It needs to handle any case conversions, mangling, format changes,
  86 streams etc.
  87
  88 We assume that we have already done a chdir() to the right "root" directory
  89 for this service.
  90
  91 The function will return an NTSTATUS error if some part of the name except for
  92 the last part cannot be resolved, else NT_STATUS_OK.
  93
  94 Note NT_STATUS_OK doesn't mean the name exists or is valid, just that we
  95 didn't get any fatal errors that should immediately terminate the calling SMB
  96 processing whilst resolving.
  97
  98 If the UCF_SAVE_LCOMP flag is passed in, then the unmodified last component
  99 of the pathname is set in smb_filename->original_lcomp.
 100
 101 If UCF_ALWAYS_ALLOW_WCARD_LCOMP is passed in, then a MS wildcard was detected
 102 and should be allowed in the last component of the path only.
 103
 104 If the orig_path was a stream, smb_filename->base_name will point to the base
 105 filename, and smb_filename->stream_name will point to the stream name.  If
 106 orig_path was not a stream, then smb_filename->stream_name will be NULL.
 107
 108 On exit from unix_convert, the smb_filename->st stat struct will be populated
 109 if the file exists and was found, if not this stat struct will be filled with
 110 zeros (and this can be detected by checking for nlinks = 0, which can never be
 111 true for any file).
 112 ****************************************************************************/
 113
 114 NTSTATUS unix_convert(TALLOC_CTX *ctx,
 115                       connection_struct *conn,
 116                       const char *orig_path,
 117                       struct smb_filename **smb_fname_out,
 118                       uint32_t ucf_flags)
 119 {
 120         struct smb_filename *smb_fname = NULL;
 121         char *start, *end;
 122         char *dirpath = NULL;
 123         char *stream = NULL;
 124         bool component_was_mangled = False;
 125         bool name_has_wildcard = False;
 126         bool posix_pathnames = false;
 127         bool allow_wcard_last_component =
 128             (ucf_flags & UCF_ALWAYS_ALLOW_WCARD_LCOMP);
 129         bool save_last_component = ucf_flags & UCF_SAVE_LCOMP;
 130         NTSTATUS status;
 131         int ret = -1;
 132
 133         *smb_fname_out = NULL;
 134
 135         smb_fname = talloc_zero(ctx, struct smb_filename);
 136         if (smb_fname == NULL) {
 137                 return NT_STATUS_NO_MEMORY;
 138         }
 139
 140         if (conn->printer) {
 141                 /* we don't ever use the filenames on a printer share as a
 142                         filename - so don't convert them */
 143                 if (!(smb_fname->base_name = talloc_strdup(smb_fname,
 144                                                            orig_path))) {
 145                         status = NT_STATUS_NO_MEMORY;
 146                         goto err;
 147                 }
 148                 goto done;
 149         }
 150
 151         DEBUG(5, ("unix_convert called on file \"%s\"\n", orig_path));
 152
 153         /*
 154          * Conversion to basic unix format is already done in
 155          * check_path_syntax().
 156          */
 157
 158         /*
 159          * Names must be relative to the root of the service - any leading /.
 160          * and trailing /'s should have been trimmed by check_path_syntax().
 161          */
 162
 163 #ifdef DEVELOPER
 164         SMB_ASSERT(*orig_path != '/');
 165 #endif
 166
 167         /*
 168          * If we trimmed down to a single '\0' character
 169          * then we should use the "." directory to avoid
 170          * searching the cache, but not if we are in a
 171          * printing share.
 172          * As we know this is valid we can return true here.
 173          */
 174
 175         if (!*orig_path) {
 176                 if (!(smb_fname->base_name = talloc_strdup(smb_fname, "."))) {
 177                         status = NT_STATUS_NO_MEMORY;
 178                         goto err;
 179                 }
 180                 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
 181                         status = map_nt_error_from_unix(errno);
 182                         goto err;
 183                 }
 184                 DEBUG(5, ("conversion finished \"\" -> %s\n",
 185                           smb_fname->base_name));
 186                 goto done;
 187         }
 188
 189         if (orig_path[0] == '.' && (orig_path[1] == '/' ||
 190                                 orig_path[1] == '\0')) {
 191                 /* Start of pathname can't be "." only. */
 192                 if (orig_path[1] == '\0' || orig_path[2] == '\0') {
 193                         status = NT_STATUS_OBJECT_NAME_INVALID;
 194                 } else {
 195                         status =determine_path_error(&orig_path[2],
 196                             allow_wcard_last_component);
 197                 }
 198                 goto err;
 199         }
 200
 201         /* Start with the full orig_path as given by the caller. */
 202         if (!(smb_fname->base_name = talloc_strdup(smb_fname, orig_path))) {
 203                 DEBUG(0, ("talloc_strdup failed\n"));
 204                 status = NT_STATUS_NO_MEMORY;
 205                 goto err;
 206         }
 207
 208         /*
 209          * Large directory fix normalization. If we're case sensitive, and
 210          * the case preserving parameters are set to "no", normalize the case of
 211          * the incoming filename from the client WHETHER IT EXISTS OR NOT !
 212          * This is in conflict with the current (3.0.20) man page, but is
 213          * what people expect from the "large directory howto". I'll update
 214          * the man page. Thanks to jht@samba.org for finding this. JRA.
 215          */
 216
 217         if (conn->case_sensitive && !conn->case_preserve &&
 218                         !conn->short_case_preserve) {
 219                 strnorm(smb_fname->base_name, lp_defaultcase(SNUM(conn)));
 220         }
 221
 222         /*
 223          * Ensure saved_last_component is valid even if file exists.
 224          */
 225
 226         if(save_last_component) {
 227                 end = strrchr_m(smb_fname->base_name, '/');
 228                 if (end) {
 229                         smb_fname->original_lcomp = talloc_strdup(smb_fname,
 230                                                                   end + 1);
 231                 } else {
 232                         smb_fname->original_lcomp =
 233                             talloc_strdup(smb_fname, smb_fname->base_name);
 234                 }
 235                 if (smb_fname->original_lcomp == NULL) {
 236                         status = NT_STATUS_NO_MEMORY;
 237                         goto err;
 238                 }
 239         }
 240
 241         posix_pathnames = lp_posix_pathnames();
 242
 243         /*
 244          * Strip off the stream, and add it back when we're done with the
 245          * base_name.
 246          */
 247         if (!posix_pathnames) {
 248                 stream = strchr_m(smb_fname->base_name, ':');
 249
 250                 if (stream != NULL) {
 251                         char *tmp = talloc_strdup(smb_fname, stream);
 252                         if (tmp == NULL) {
 253                                 status = NT_STATUS_NO_MEMORY;
 254                                 goto err;
 255                         }
 256                         /*
 257                          * Since this is actually pointing into
 258                          * smb_fname->base_name this truncates base_name.
 259                          */
 260                         *stream = '\0';
 261                         stream = tmp;
 262                 }
 263         }
 264
 265         start = smb_fname->base_name;
 266
 267         /*
 268          * If we're providing case insentive semantics or
 269          * the underlying filesystem is case insensitive,
 270          * then a case-normalized hit in the stat-cache is
 271          * authoratitive. JRA.
 272          *
 273          * Note: We're only checking base_name.  The stream_name will be
 274          * added and verified in build_stream_path().
 275          */
 276
 277         if((!conn->case_sensitive || !(conn->fs_capabilities &
 278                                        FILE_CASE_SENSITIVE_SEARCH)) &&
 279             stat_cache_lookup(conn, &smb_fname->base_name, &dirpath, &start,
 280                               &smb_fname->st)) {
 281                 goto done;
 282         }
 283
 284         /*
 285          * Make sure "dirpath" is an allocated string, we use this for
 286          * building the directories with asprintf and free it.
 287          */
 288
 289         if ((dirpath == NULL) && (!(dirpath = talloc_strdup(ctx,"")))) {
 290                 DEBUG(0, ("talloc_strdup failed\n"));
 291                 status = NT_STATUS_NO_MEMORY;
 292                 goto err;
 293         }
 294
 295         /*
 296          * stat the name - if it exists then we can add the stream back (if
 297          * there was one) and be done!
 298          */
 299
 300         if (posix_pathnames) {
 301                 ret = SMB_VFS_LSTAT(conn, smb_fname);
 302         } else {
 303                 ret = SMB_VFS_STAT(conn, smb_fname);
 304         }
 305
 306         if (ret == 0) {
 307                 /* Ensure we catch all names with in "/."
 308                    this is disallowed under Windows. */
 309                 const char *p = strstr(smb_fname->base_name, "/."); /*mb safe*/
 310                 if (p) {
 311                         if (p[2] == '/') {
 312                                 /* Error code within a pathname. */
 313                                 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
 314                                 goto fail;
 315                         } else if (p[2] == '\0') {
 316                                 /* Error code at the end of a pathname. */
 317                                 status = NT_STATUS_OBJECT_NAME_INVALID;
 318                                 goto fail;
 319                         }
 320                 }
 321                 /* Add the path (not including the stream) to the cache. */
 322                 stat_cache_add(orig_path, smb_fname->base_name,
 323                                conn->case_sensitive);
 324                 DEBUG(5,("conversion of base_name finished %s -> %s\n",
 325                          orig_path, smb_fname->base_name));
 326                 goto done;
 327         }
 328
 329         DEBUG(5,("unix_convert begin: name = %s, dirpath = %s, start = %s\n",
 330                  smb_fname->base_name, dirpath, start));
 331
 332         /*
 333          * A special case - if we don't have any mangling chars and are case
 334          * sensitive or the underlying filesystem is case insentive then searching
 335          * won't help.
 336          */
 337
 338         if ((conn->case_sensitive || !(conn->fs_capabilities &
 339                                        FILE_CASE_SENSITIVE_SEARCH)) &&
 340             !mangle_is_mangled(smb_fname->base_name, conn->params)) {
 341                 goto done;
 342         }
 343
 344         /*
 345          * is_mangled() was changed to look at an entire pathname, not
 346          * just a component. JRA.
 347          */
 348
 349         if (mangle_is_mangled(start, conn->params)) {
 350                 component_was_mangled = True;
 351         }
 352
 353         /*
 354          * Now we need to recursively match the name against the real
 355          * directory structure.
 356          */
 357
 358         /*
 359          * Match each part of the path name separately, trying the names
 360          * as is first, then trying to scan the directory for matching names.
 361          */
 362
 363         for (; start ; start = (end?end+1:(char *)NULL)) {
 364                 /*
 365                  * Pinpoint the end of this section of the filename.
 366                  */
 367                 /* mb safe. '/' can't be in any encoded char. */
 368                 end = strchr(start, '/');
 369
 370                 /*
 371                  * Chop the name at this point.
 372                  */
 373                 if (end) {
 374                         *end = 0;
 375                 }
 376
 377                 if (save_last_component) {
 378                         TALLOC_FREE(smb_fname->original_lcomp);
 379                         smb_fname->original_lcomp = talloc_strdup(smb_fname,
 380                                                         end ? end + 1 : start);
 381                         if (!smb_fname->original_lcomp) {
 382                                 DEBUG(0, ("talloc failed\n"));
 383                                 status = NT_STATUS_NO_MEMORY;
 384                                 goto err;
 385                         }
 386                 }
 387
 388                 /* The name cannot have a component of "." */
 389
 390                 if (ISDOT(start)) {
 391                         if (!end)  {
 392                                 /* Error code at the end of a pathname. */
 393                                 status = NT_STATUS_OBJECT_NAME_INVALID;
 394                         } else {
 395                                 status = determine_path_error(end+1,
 396                                                 allow_wcard_last_component);
 397                         }
 398                         goto fail;
 399                 }
 400
 401                 /* The name cannot have a wildcard if it's not
 402                    the last component. */
 403
 404                 name_has_wildcard = ms_has_wild(start);
 405
 406                 /* Wildcard not valid anywhere. */
 407                 if (name_has_wildcard && !allow_wcard_last_component) {
 408                         status = NT_STATUS_OBJECT_NAME_INVALID;
 409                         goto fail;
 410                 }
 411
 412                 /* Wildcards never valid within a pathname. */
 413                 if (name_has_wildcard && end) {
 414                         status = NT_STATUS_OBJECT_NAME_INVALID;
 415                         goto fail;
 416                 }
 417
 418                 /*
 419                  * Check if the name exists up to this point.
 420                  */
 421
 422                 if (posix_pathnames) {
 423                         ret = SMB_VFS_LSTAT(conn, smb_fname);
 424                 } else {
 425                         ret = SMB_VFS_STAT(conn, smb_fname);
 426                 }
 427
 428                 if (ret == 0) {
 429                         /*
 430                          * It exists. it must either be a directory or this must
 431                          * be the last part of the path for it to be OK.
 432                          */
 433                         if (end && !S_ISDIR(smb_fname->st.st_ex_mode)) {
 434                                 /*
 435                                  * An intermediate part of the name isn't
 436                                  * a directory.
 437                                  */
 438                                 DEBUG(5,("Not a dir %s\n",start));
 439                                 *end = '/';
 440                                 /*
 441                                  * We need to return the fact that the
 442                                  * intermediate name resolution failed. This
 443                                  * is used to return an error of ERRbadpath
 444                                  * rather than ERRbadfile. Some Windows
 445                                  * applications depend on the difference between
 446                                  * these two errors.
 447                                  */
 448                                 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
 449                                 goto fail;
 450                         }
 451
 452                 } else {
 453                         char *found_name = NULL;
 454
 455                         /* Stat failed - ensure we don't use it. */
 456                         SET_STAT_INVALID(smb_fname->st);
 457
 458                         /*
 459                          * Reset errno so we can detect
 460                          * directory open errors.
 461                          */
 462                         errno = 0;
 463
 464                         /*
 465                          * Try to find this part of the path in the directory.
 466                          */
 467
 468                         if (name_has_wildcard ||
 469                             (get_real_filename(conn, dirpath, start,
 470                                                talloc_tos(),
 471                                                &found_name) == -1)) {
 472                                 char *unmangled;
 473
 474                                 if (end) {
 475                                         /*
 476                                          * An intermediate part of the name
 477                                          * can't be found.
 478                                          */
 479                                         DEBUG(5,("Intermediate not found %s\n",
 480                                                         start));
 481                                         *end = '/';
 482
 483                                         /*
 484                                          * We need to return the fact that the
 485                                          * intermediate name resolution failed.
 486                                          * This is used to return an error of
 487                                          * ERRbadpath rather than ERRbadfile.
 488                                          * Some Windows applications depend on
 489                                          * the difference between these two
 490                                          * errors.
 491                                          */
 492
 493                                         /*
 494                                          * ENOENT, ENOTDIR and ELOOP all map
 495                                          * to NT_STATUS_OBJECT_PATH_NOT_FOUND
 496                                          * in the filename walk.
 497                                          */
 498
 499                                         if (errno == ENOENT ||
 500                                                         errno == ENOTDIR ||
 501                                                         errno == ELOOP) {
 502                                                 status =
 503                                                 NT_STATUS_OBJECT_PATH_NOT_FOUND;
 504                                         }
 505                                         else {
 506                                                 status =
 507                                                 map_nt_error_from_unix(errno);
 508                                         }
 509                                         goto fail;
 510                                 }
 511
 512                                 /*
 513                                  * ENOENT/EACCESS are the only valid errors
 514                                  * here. EACCESS needs handling here for
 515                                  * "dropboxes", i.e. directories where users
 516                                  * can only put stuff with permission -wx.
 517                                  */
 518                                 if ((errno != 0) && (errno != ENOENT)
 519                                     && (errno != EACCES)) {
 520                                         /*
 521                                          * ENOTDIR and ELOOP both map to
 522                                          * NT_STATUS_OBJECT_PATH_NOT_FOUND
 523                                          * in the filename walk.
 524                                          */
 525                                         if (errno == ENOTDIR ||
 526                                                         errno == ELOOP) {
 527                                                 status =
 528                                                 NT_STATUS_OBJECT_PATH_NOT_FOUND;
 529                                         } else {
 530                                                 status =
 531                                                 map_nt_error_from_unix(errno);
 532                                         }
 533                                         goto fail;
 534                                 }
 535
 536                                 /*
 537                                  * Just the last part of the name doesn't exist.
 538                                  * We need to strupper() or strlower() it as
 539                                  * this conversion may be used for file creation
 540                                  * purposes. Fix inspired by
 541                                  * Thomas Neumann <t.neumann@iku-ag.de>.
 542                                  */
 543                                 if (!conn->case_preserve ||
 544                                     (mangle_is_8_3(start, False,
 545                                                    conn->params) &&
 546                                                  !conn->short_case_preserve)) {
 547                                         strnorm(start,
 548                                                 lp_defaultcase(SNUM(conn)));
 549                                 }
 550
 551                                 /*
 552                                  * check on the mangled stack to see if we can
 553                                  * recover the base of the filename.
 554                                  */
 555
 556                                 if (mangle_is_mangled(start, conn->params)
 557                                     && mangle_lookup_name_from_8_3(ctx,
 558                                                         start,
 559                                                         &unmangled,
 560                                                         conn->params)) {
 561                                         char *tmp;
 562                                         size_t start_ofs =
 563                                             start - smb_fname->base_name;
 564
 565                                         if (*dirpath != '\0') {
 566                                                 tmp = talloc_asprintf(
 567                                                         smb_fname, "%s/%s",
 568                                                         dirpath, unmangled);
 569                                                 TALLOC_FREE(unmangled);
 570                                         }
 571                                         else {
 572                                                 tmp = unmangled;
 573                                         }
 574                                         if (tmp == NULL) {
 575                                                 DEBUG(0, ("talloc failed\n"));
 576                                                 status = NT_STATUS_NO_MEMORY;
 577                                                 goto err;
 578                                         }
 579                                         TALLOC_FREE(smb_fname->base_name);
 580                                         smb_fname->base_name = tmp;
 581                                         start =
 582                                             smb_fname->base_name + start_ofs;
 583                                         end = start + strlen(start);
 584                                 }
 585
 586                                 DEBUG(5,("New file %s\n",start));
 587                                 goto done;
 588                         }
 589
 590
 591                         /*
 592                          * Restore the rest of the string. If the string was
 593                          * mangled the size may have changed.
 594                          */
 595                         if (end) {
 596                                 char *tmp;
 597                                 size_t start_ofs =
 598                                     start - smb_fname->base_name;
 599
 600                                 if (*dirpath != '\0') {
 601                                         tmp = talloc_asprintf(smb_fname,
 602                                                 "%s/%s/%s", dirpath,
 603                                                 found_name, end+1);
 604                                 }
 605                                 else {
 606                                         tmp = talloc_asprintf(smb_fname,
 607                                                 "%s/%s", found_name,
 608                                                 end+1);
 609                                 }
 610                                 if (tmp == NULL) {
 611                                         DEBUG(0, ("talloc_asprintf failed\n"));
 612                                         status = NT_STATUS_NO_MEMORY;
 613                                         goto err;
 614                                 }
 615                                 TALLOC_FREE(smb_fname->base_name);
 616                                 smb_fname->base_name = tmp;
 617                                 start = smb_fname->base_name + start_ofs;
 618                                 end = start + strlen(found_name);
 619                                 *end = '\0';
 620                         } else {
 621                                 char *tmp;
 622                                 size_t start_ofs =
 623                                     start - smb_fname->base_name;
 624
 625                                 if (*dirpath != '\0') {
 626                                         tmp = talloc_asprintf(smb_fname,
 627                                                 "%s/%s", dirpath,
 628                                                 found_name);
 629                                 } else {
 630                                         tmp = talloc_strdup(smb_fname,
 631                                                 found_name);
 632                                 }
 633                                 if (tmp == NULL) {
 634                                         DEBUG(0, ("talloc failed\n"));
 635                                         status = NT_STATUS_NO_MEMORY;
 636                                         goto err;
 637                                 }
 638                                 TALLOC_FREE(smb_fname->base_name);
 639                                 smb_fname->base_name = tmp;
 640                                 start = smb_fname->base_name + start_ofs;
 641
 642                                 /*
 643                                  * We just scanned for, and found the end of
 644                                  * the path. We must return a valid stat struct
 645                                  * if it exists. JRA.
 646                                  */
 647
 648                                 if (posix_pathnames) {
 649                                         ret = SMB_VFS_LSTAT(conn, smb_fname);
 650                                 } else {
 651                                         ret = SMB_VFS_STAT(conn, smb_fname);
 652                                 }
 653
 654                                 if (ret != 0) {
 655                                         SET_STAT_INVALID(smb_fname->st);
 656                                 }
 657                         }
 658
 659                         TALLOC_FREE(found_name);
 660                 } /* end else */
 661
 662 #ifdef DEVELOPER
 663                 /*
 664                  * This sucks!
 665                  * We should never provide different behaviors
 666                  * depending on DEVELOPER!!!
 667                  */
 668                 if (VALID_STAT(smb_fname->st)) {
 669                         bool delete_pending;
 670                         get_file_infos(vfs_file_id_from_sbuf(conn,
 671                                                              &smb_fname->st),
 672                                        &delete_pending, NULL);
 673                         if (delete_pending) {
 674                                 status = NT_STATUS_DELETE_PENDING;
 675                                 goto fail;
 676                         }
 677                 }
 678 #endif
 679
 680                 /*
 681                  * Add to the dirpath that we have resolved so far.
 682                  */
 683
 684                 if (*dirpath != '\0') {
 685                         char *tmp = talloc_asprintf(ctx,
 686                                         "%s/%s", dirpath, start);
 687                         if (!tmp) {
 688                                 DEBUG(0, ("talloc_asprintf failed\n"));
 689                                 status = NT_STATUS_NO_MEMORY;
 690                                 goto err;
 691                         }
 692                         TALLOC_FREE(dirpath);
 693                         dirpath = tmp;
 694                 }
 695                 else {
 696                         TALLOC_FREE(dirpath);
 697                         if (!(dirpath = talloc_strdup(ctx,start))) {
 698                                 DEBUG(0, ("talloc_strdup failed\n"));
 699                                 status = NT_STATUS_NO_MEMORY;
 700                                 goto err;
 701                         }
 702                 }
 703
 704                 /*
 705                  * Cache the dirpath thus far. Don't cache a name with mangled
 706                  * or wildcard components as this can change the size.
 707                  */
 708                 if(!component_was_mangled && !name_has_wildcard) {
 709                         stat_cache_add(orig_path, dirpath,
 710                                         conn->case_sensitive);
 711                 }
 712
 713                 /*
 714                  * Restore the / that we wiped out earlier.
 715                  */
 716                 if (end) {
 717                         *end = '/';
 718                 }
 719         }
 720
 721         /*
 722          * Cache the full path. Don't cache a name with mangled or wildcard
 723          * components as this can change the size.
 724          */
 725
 726         if(!component_was_mangled && !name_has_wildcard) {
 727                 stat_cache_add(orig_path, smb_fname->base_name,
 728                                conn->case_sensitive);
 729         }
 730
 731         /*
 732          * The name has been resolved.
 733          */
 734
 735         DEBUG(5,("conversion finished %s -> %s\n", orig_path,
 736                  smb_fname->base_name));
 737
 738  done:
 739         /* Add back the stream if one was stripped off originally. */
 740         if (stream != NULL) {
 741                 smb_fname->stream_name = stream;
 742
 743                 /* Check path now that the base_name has been converted. */
 744                 status = build_stream_path(ctx, conn, orig_path, smb_fname);
 745                 if (!NT_STATUS_IS_OK(status)) {
 746                         goto fail;
 747                 }
 748         }
 749         TALLOC_FREE(dirpath);
 750         *smb_fname_out = smb_fname;
 751         return NT_STATUS_OK;
 752  fail:
 753         DEBUG(10, ("dirpath = [%s] start = [%s]\n", dirpath, start));
 754         if (*dirpath != '\0') {
 755                 smb_fname->base_name = talloc_asprintf(smb_fname, "%s/%s",
 756                                                        dirpath, start);
 757         } else {
 758                 smb_fname->base_name = talloc_strdup(smb_fname, start);
 759         }
 760         if (!smb_fname->base_name) {
 761                 DEBUG(0, ("talloc_asprintf failed\n"));
 762                 status = NT_STATUS_NO_MEMORY;
 763                 goto err;
 764         }
 765
 766         *smb_fname_out = smb_fname;
 767         TALLOC_FREE(dirpath);
 768         return status;
 769  err:
 770         TALLOC_FREE(smb_fname);
 771         return status;
 772 }
 773
 774 /****************************************************************************
 775  Check a filename - possibly calling check_reduced_name.
 776  This is called by every routine before it allows an operation on a filename.
 777  It does any final confirmation necessary to ensure that the filename is
 778  a valid one for the user to access.
 779 ****************************************************************************/
 780
 781 NTSTATUS check_name(connection_struct *conn, const char *name)
 782 {
 783         if (IS_VETO_PATH(conn, name))  {
 784                 /* Is it not dot or dot dot. */
 785                 if (!((name[0] == '.') && (!name[1] ||
 786                                         (name[1] == '.' && !name[2])))) {
 787                         DEBUG(5,("check_name: file path name %s vetoed\n",
 788                                                 name));
 789                         return map_nt_error_from_unix(ENOENT);
 790                 }
 791         }
 792
 793         if (!lp_widelinks(SNUM(conn)) || !lp_symlinks(SNUM(conn))) {
 794                 NTSTATUS status = check_reduced_name(conn,name);
 795                 if (!NT_STATUS_IS_OK(status)) {
 796                         DEBUG(5,("check_name: name %s failed with %s\n",name,
 797                                                 nt_errstr(status)));
 798                         return status;
 799                 }
 800         }
 801
 802         return NT_STATUS_OK;
 803 }
 804
 805 /****************************************************************************
 806  Check if two filenames are equal.
 807  This needs to be careful about whether we are case sensitive.
 808 ****************************************************************************/
 809
 810 static bool fname_equal(const char *name1, const char *name2,
 811                 bool case_sensitive)
 812 {
 813         /* Normal filename handling */
 814         if (case_sensitive) {
 815                 return(strcmp(name1,name2) == 0);
 816         }
 817
 818         return(strequal(name1,name2));
 819 }
 820
 821 /****************************************************************************
 822  Scan a directory to find a filename, matching without case sensitivity.
 823  If the name looks like a mangled name then try via the mangling functions
 824 ****************************************************************************/
 825
 826 static int get_real_filename_full_scan(connection_struct *conn,
 827                                        const char *path, const char *name,
 828                                        bool mangled,
 829                                        TALLOC_CTX *mem_ctx, char **found_name)
 830 {
 831         struct smb_Dir *cur_dir;
 832         char *dname = NULL;
 833         char *unmangled_name = NULL;
 834         long curpos;
 835
 836         /* handle null paths */
 837         if ((path == NULL) || (*path == 0)) {
 838                 path = ".";
 839         }
 840
 841         /* If we have a case-sensitive filesystem, it doesn't do us any
 842          * good to search for a name. If a case variation of the name was
 843          * there, then the original stat(2) would have found it.
 844          */
 845         if (!mangled && !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
 846                 errno = ENOENT;
 847                 return -1;
 848         }
 849
 850         /*
 851          * The incoming name can be mangled, and if we de-mangle it
 852          * here it will not compare correctly against the filename (name2)
 853          * read from the directory and then mangled by the name_to_8_3()
 854          * call. We need to mangle both names or neither.
 855          * (JRA).
 856          *
 857          * Fix for bug found by Dina Fine. If in case sensitive mode then
 858          * the mangle cache is no good (3 letter extension could be wrong
 859          * case - so don't demangle in this case - leave as mangled and
 860          * allow the mangling of the directory entry read (which is done
 861          * case insensitively) to match instead. This will lead to more
 862          * false positive matches but we fail completely without it. JRA.
 863          */
 864
 865         if (mangled && !conn->case_sensitive) {
 866                 mangled = !mangle_lookup_name_from_8_3(talloc_tos(), name,
 867                                                        &unmangled_name,
 868                                                        conn->params);
 869                 if (!mangled) {
 870                         /* Name is now unmangled. */
 871                         name = unmangled_name;
 872                 }
 873         }
 874
 875         /* open the directory */
 876         if (!(cur_dir = OpenDir(talloc_tos(), conn, path, NULL, 0))) {
 877                 DEBUG(3,("scan dir didn't open dir [%s]\n",path));
 878                 TALLOC_FREE(unmangled_name);
 879                 return -1;
 880         }
 881
 882         /* now scan for matching names */
 883         curpos = 0;
 884         while ((dname = ReadDirName(cur_dir, &curpos, NULL))) {
 885
 886                 /* Is it dot or dot dot. */
 887                 if (ISDOT(dname) || ISDOTDOT(dname)) {
 888                         TALLOC_FREE(dname);
 889                         continue;
 890                 }
 891
 892                 /*
 893                  * At this point dname is the unmangled name.
 894                  * name is either mangled or not, depending on the state
 895                  * of the "mangled" variable. JRA.
 896                  */
 897
 898                 /*
 899                  * Check mangled name against mangled name, or unmangled name
 900                  * against unmangled name.
 901                  */
 902
 903                 if ((mangled && mangled_equal(name,dname,conn->params)) ||
 904                         fname_equal(name, dname, conn->case_sensitive)) {
 905                         /* we've found the file, change it's name and return */
 906                         *found_name = talloc_strdup(mem_ctx, dname);
 907                         TALLOC_FREE(unmangled_name);
 908                         TALLOC_FREE(cur_dir);
 909                         if (!*found_name) {
 910                                 errno = ENOMEM;
 911                                 TALLOC_FREE(dname);
 912                                 return -1;
 913                         }
 914                         TALLOC_FREE(dname);
 915                         return 0;
 916                 }
 917                 TALLOC_FREE(dname);
 918         }
 919
 920         TALLOC_FREE(unmangled_name);
 921         TALLOC_FREE(cur_dir);
 922         errno = ENOENT;
 923         return -1;
 924 }
 925
 926 /****************************************************************************
 927  Wrapper around the vfs get_real_filename and the full directory scan
 928  fallback.
 929 ****************************************************************************/
 930
 931 int get_real_filename(connection_struct *conn, const char *path,
 932                       const char *name, TALLOC_CTX *mem_ctx,
 933                       char **found_name)
 934 {
 935         int ret;
 936         bool mangled;
 937
 938         mangled = mangle_is_mangled(name, conn->params);
 939
 940         if (mangled) {
 941                 return get_real_filename_full_scan(conn, path, name, mangled,
 942                                                    mem_ctx, found_name);
 943         }
 944
 945         /* Try the vfs first to take advantage of case-insensitive stat. */
 946         ret = SMB_VFS_GET_REAL_FILENAME(conn, path, name, mem_ctx, found_name);
 947
 948         /*
 949          * If the case-insensitive stat was successful, or returned an error
 950          * other than EOPNOTSUPP then there is no need to fall back on the
 951          * full directory scan.
 952          */
 953         if (ret == 0 || (ret == -1 && errno != EOPNOTSUPP)) {
 954                 return ret;
 955         }
 956
 957         return get_real_filename_full_scan(conn, path, name, mangled, mem_ctx,
 958                                            found_name);
 959 }
 960
 961 static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
 962                                   connection_struct *conn,
 963                                   const char *orig_path,
 964                                   struct smb_filename *smb_fname)
 965 {
 966         NTSTATUS status;
 967         unsigned int i, num_streams;
 968         struct stream_struct *streams = NULL;
 969
 970         if (SMB_VFS_STAT(conn, smb_fname) == 0) {
 971                 DEBUG(10, ("'%s' exists\n", smb_fname_str_dbg(smb_fname)));
 972                 return NT_STATUS_OK;
 973         }
 974
 975         if (errno != ENOENT) {
 976                 DEBUG(10, ("vfs_stat failed: %s\n", strerror(errno)));
 977                 status = map_nt_error_from_unix(errno);
 978                 goto fail;
 979         }
 980
 981         /* Fall back to a case-insensitive scan of all streams on the file. */
 982         status = SMB_VFS_STREAMINFO(conn, NULL, smb_fname->base_name, mem_ctx,
 983                                     &num_streams, &streams);
 984
 985         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 986                 SET_STAT_INVALID(smb_fname->st);
 987                 return NT_STATUS_OK;
 988         }
 989
 990         if (!NT_STATUS_IS_OK(status)) {
 991                 DEBUG(10, ("vfs_streaminfo failed: %s\n", nt_errstr(status)));
 992                 goto fail;
 993         }
 994
 995         for (i=0; i<num_streams; i++) {
 996                 DEBUG(10, ("comparing [%s] and [%s]: ",
 997                            smb_fname->stream_name, streams[i].name));
 998                 if (fname_equal(smb_fname->stream_name, streams[i].name,
 999                                 conn->case_sensitive)) {
1000                         DEBUGADD(10, ("equal\n"));
1001                         break;
1002                 }
1003                 DEBUGADD(10, ("not equal\n"));
1004         }
1005
1006         /* Couldn't find the stream. */
1007         if (i == num_streams) {
1008                 SET_STAT_INVALID(smb_fname->st);
1009                 TALLOC_FREE(streams);
1010                 return NT_STATUS_OK;
1011         }
1012
1013         DEBUG(10, ("case insensitive stream. requested: %s, actual: %s\n",
1014                 smb_fname->stream_name, streams[i].name));
1015
1016
1017         TALLOC_FREE(smb_fname->stream_name);
1018         smb_fname->stream_name = talloc_strdup(smb_fname, streams[i].name);
1019         if (smb_fname->stream_name == NULL) {
1020                 status = NT_STATUS_NO_MEMORY;
1021                 goto fail;
1022         }
1023
1024         SET_STAT_INVALID(smb_fname->st);
1025
1026         if (SMB_VFS_STAT(conn, smb_fname) == 0) {
1027                 DEBUG(10, ("'%s' exists\n", smb_fname_str_dbg(smb_fname)));
1028         }
1029         status = NT_STATUS_OK;
1030  fail:
1031         TALLOC_FREE(streams);
1032         return status;
1033 }
1034
1035 /**
1036  * Go through all the steps to validate a filename.
1037  *
1038  * @param ctx           talloc_ctx to allocate memory with.
1039  * @param conn          connection struct for vfs calls.
1040  * @param dfs_path      Whether this path requires dfs resolution.
1041  * @param name_in       The unconverted name.
1042  * @param ucf_flags     flags to pass through to unix_convert().
1043  *                      UCF_ALWAYS_ALLOW_WCARD_LCOMP will be OR'd in if
1044  *                      p_cont_wcard != NULL and is true and
1045  *                      UCF_COND_ALLOW_WCARD_LCOMP.
1046  * @param p_cont_wcard  If not NULL, will be set to true if the dfs path
1047  *                      resolution detects a wildcard.
1048  * @param pp_smb_fname  The final converted name will be allocated if the
1049  *                      return is NT_STATUS_OK.
1050  *
1051  * @return NT_STATUS_OK if all operations completed succesfully, appropriate
1052  *         error otherwise.
1053  */
1054 NTSTATUS filename_convert(TALLOC_CTX *ctx,
1055                                 connection_struct *conn,
1056                                 bool dfs_path,
1057                                 const char *name_in,
1058                                 uint32_t ucf_flags,
1059                                 bool *ppath_contains_wcard,
1060                                 struct smb_filename **pp_smb_fname)
1061 {
1062         NTSTATUS status;
1063         char *fname = NULL;
1064
1065         *pp_smb_fname = NULL;
1066
1067         status = resolve_dfspath_wcard(ctx, conn,
1068                                 dfs_path,
1069                                 name_in,
1070                                 &fname,
1071                                 ppath_contains_wcard);
1072         if (!NT_STATUS_IS_OK(status)) {
1073                 DEBUG(10,("filename_convert: resolve_dfspath failed "
1074                         "for name %s with %s\n",
1075                         name_in,
1076                         nt_errstr(status) ));
1077                 return status;
1078         }
1079
1080         if (is_fake_file_path(name_in)) {
1081                 SMB_STRUCT_STAT st;
1082                 ZERO_STRUCT(st);
1083                 st.st_ex_nlink = 1;
1084                 status = create_synthetic_smb_fname_split(ctx,
1085                                                           name_in,
1086                                                           &st,
1087                                                           pp_smb_fname);
1088                 return status;
1089         }
1090
1091         /*
1092          * If the caller conditionally allows wildcard lookups, only add the
1093          * always allow if the path actually does contain a wildcard.
1094          */
1095         if (ucf_flags & UCF_COND_ALLOW_WCARD_LCOMP &&
1096             ppath_contains_wcard != NULL && *ppath_contains_wcard) {
1097                 ucf_flags |= UCF_ALWAYS_ALLOW_WCARD_LCOMP;
1098         }
1099
1100         status = unix_convert(ctx, conn, fname, pp_smb_fname, ucf_flags);
1101         if (!NT_STATUS_IS_OK(status)) {
1102                 DEBUG(10,("filename_convert: unix_convert failed "
1103                         "for name %s with %s\n",
1104                         fname,
1105                         nt_errstr(status) ));
1106                 return status;
1107         }
1108
1109         status = check_name(conn, (*pp_smb_fname)->base_name);
1110         if (!NT_STATUS_IS_OK(status)) {
1111                 DEBUG(3,("filename_convert: check_name failed "
1112                         "for name %s with %s\n",
1113                         smb_fname_str_dbg(*pp_smb_fname),
1114                         nt_errstr(status) ));
1115                 TALLOC_FREE(*pp_smb_fname);
1116                 return status;
1117         }
1118
1119         return status;
1120 }