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 #include "system/filesys.h"
  29 #include "fake_file.h"
  30 #include "smbd/smbd.h"
  31 #include "smbd/globals.h"
  32
  33 static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
  34                                   connection_struct *conn,
  35                                   const char *orig_path,
  36                                   struct smb_filename *smb_fname);
  37
  38 /****************************************************************************
  39  Mangle the 2nd name and check if it is then equal to the first name.
  40 ****************************************************************************/
  41
  42 static bool mangled_equal(const char *name1,
  43                         const char *name2,
  44                         const struct share_params *p)
  45 {
  46         char mname[13];
  47
  48         if (!name_to_8_3(name2, mname, False, p)) {
  49                 return False;
  50         }
  51         return strequal(name1, mname);
  52 }
  53
  54 /****************************************************************************
  55  Cope with the differing wildcard and non-wildcard error cases.
  56 ****************************************************************************/
  57
  58 static NTSTATUS determine_path_error(const char *name,
  59                         bool allow_wcard_last_component)
  60 {
  61         const char *p;
  62
  63         if (!allow_wcard_last_component) {
  64                 /* Error code within a pathname. */
  65                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
  66         }
  67
  68         /* We're terminating here so we
  69          * can be a little slower and get
  70          * the error code right. Windows
  71          * treats the last part of the pathname
  72          * separately I think, so if the last
  73          * component is a wildcard then we treat
  74          * this ./ as "end of component" */
  75
  76         p = strchr(name, '/');
  77
  78         if (!p && (ms_has_wild(name) || ISDOT(name))) {
  79                 /* Error code at the end of a pathname. */
  80                 return NT_STATUS_OBJECT_NAME_INVALID;
  81         } else {
  82                 /* Error code within a pathname. */
  83                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
  84         }
  85 }
  86
  87 static NTSTATUS check_for_dot_component(const struct smb_filename *smb_fname)
  88 {
  89         /* Ensure we catch all names with in "/."
  90            this is disallowed under Windows and
  91            in POSIX they've already been removed. */
  92         const char *p = strstr(smb_fname->base_name, "/."); /*mb safe*/
  93         if (p) {
  94                 if (p[2] == '/') {
  95                         /* Error code within a pathname. */
  96                         return NT_STATUS_OBJECT_PATH_NOT_FOUND;
  97                 } else if (p[2] == '\0') {
  98                         /* Error code at the end of a pathname. */
  99                         return NT_STATUS_OBJECT_NAME_INVALID;
 100                 }
 101         }
 102         return NT_STATUS_OK;
 103 }
 104
 105 /****************************************************************************
 106  Optimization for common case where the missing part
 107  is in the last component and the client already
 108  sent the correct case.
 109  Returns NT_STATUS_OK to mean continue the tree walk
 110  (possibly with modified start pointer).
 111  Any other NT_STATUS_XXX error means terminate the path
 112  lookup here.
 113 ****************************************************************************/
 114
 115 static NTSTATUS check_parent_exists(TALLOC_CTX *ctx,
 116                                 connection_struct *conn,
 117                                 bool posix_pathnames,
 118                                 const struct smb_filename *smb_fname,
 119                                 char **pp_dirpath,
 120                                 char **pp_start)
 121 {
 122         struct smb_filename parent_fname;
 123         const char *last_component = NULL;
 124         NTSTATUS status;
 125         int ret;
 126
 127         ZERO_STRUCT(parent_fname);
 128         if (!parent_dirname(ctx, smb_fname->base_name,
 129                                 &parent_fname.base_name,
 130                                 &last_component)) {
 131                 return NT_STATUS_NO_MEMORY;
 132         }
 133
 134         /*
 135          * If there was no parent component in
 136          * smb_fname->base_name of the parent name
 137          * contained a wildcard then don't do this
 138          * optimization.
 139          */
 140         if ((smb_fname->base_name == last_component) ||
 141                         ms_has_wild(parent_fname.base_name)) {
 142                 return NT_STATUS_OK;
 143         }
 144
 145         if (posix_pathnames) {
 146                 ret = SMB_VFS_LSTAT(conn, &parent_fname);
 147         } else {
 148                 ret = SMB_VFS_STAT(conn, &parent_fname);
 149         }
 150
 151         /* If the parent stat failed, just continue
 152            with the normal tree walk. */
 153
 154         if (ret == -1) {
 155                 return NT_STATUS_OK;
 156         }
 157
 158         status = check_for_dot_component(&parent_fname);
 159         if (!NT_STATUS_IS_OK(status)) {
 160                 return status;
 161         }
 162
 163         /* Parent exists - set "start" to be the
 164          * last compnent to shorten the tree walk. */
 165
 166         /*
 167          * Safe to use discard_const_p
 168          * here as last_component points
 169          * into our smb_fname->base_name.
 170          */
 171         *pp_start = discard_const_p(char, last_component);
 172
 173         /* Update dirpath. */
 174         TALLOC_FREE(*pp_dirpath);
 175         *pp_dirpath = talloc_strdup(ctx, parent_fname.base_name);
 176         if (!*pp_dirpath) {
 177                 return NT_STATUS_NO_MEMORY;
 178         }
 179
 180         DEBUG(5,("check_parent_exists: name "
 181                 "= %s, dirpath = %s, "
 182                 "start = %s\n",
 183                 smb_fname->base_name,
 184                 *pp_dirpath,
 185                 *pp_start));
 186
 187         return NT_STATUS_OK;
 188 }
 189
 190 /****************************************************************************
 191 This routine is called to convert names from the dos namespace to unix
 192 namespace. It needs to handle any case conversions, mangling, format changes,
 193 streams etc.
 194
 195 We assume that we have already done a chdir() to the right "root" directory
 196 for this service.
 197
 198 The function will return an NTSTATUS error if some part of the name except for
 199 the last part cannot be resolved, else NT_STATUS_OK.
 200
 201 Note NT_STATUS_OK doesn't mean the name exists or is valid, just that we
 202 didn't get any fatal errors that should immediately terminate the calling SMB
 203 processing whilst resolving.
 204
 205 If the UCF_SAVE_LCOMP flag is passed in, then the unmodified last component
 206 of the pathname is set in smb_filename->original_lcomp.
 207
 208 If UCF_ALWAYS_ALLOW_WCARD_LCOMP is passed in, then a MS wildcard was detected
 209 and should be allowed in the last component of the path only.
 210
 211 If the orig_path was a stream, smb_filename->base_name will point to the base
 212 filename, and smb_filename->stream_name will point to the stream name.  If
 213 orig_path was not a stream, then smb_filename->stream_name will be NULL.
 214
 215 On exit from unix_convert, the smb_filename->st stat struct will be populated
 216 if the file exists and was found, if not this stat struct will be filled with
 217 zeros (and this can be detected by checking for nlinks = 0, which can never be
 218 true for any file).
 219 ****************************************************************************/
 220
 221 NTSTATUS unix_convert(TALLOC_CTX *ctx,
 222                       connection_struct *conn,
 223                       const char *orig_path,
 224                       struct smb_filename **smb_fname_out,
 225                       uint32_t ucf_flags)
 226 {
 227         struct smb_filename *smb_fname = NULL;
 228         char *start, *end;
 229         char *dirpath = NULL;
 230         char *stream = NULL;
 231         bool component_was_mangled = False;
 232         bool name_has_wildcard = False;
 233         bool posix_pathnames = false;
 234         bool allow_wcard_last_component =
 235             (ucf_flags & UCF_ALWAYS_ALLOW_WCARD_LCOMP);
 236         bool save_last_component = ucf_flags & UCF_SAVE_LCOMP;
 237         NTSTATUS status;
 238         int ret = -1;
 239
 240         *smb_fname_out = NULL;
 241
 242         smb_fname = talloc_zero(ctx, struct smb_filename);
 243         if (smb_fname == NULL) {
 244                 return NT_STATUS_NO_MEMORY;
 245         }
 246
 247         if (conn->printer) {
 248                 /* we don't ever use the filenames on a printer share as a
 249                         filename - so don't convert them */
 250                 if (!(smb_fname->base_name = talloc_strdup(smb_fname,
 251                                                            orig_path))) {
 252                         status = NT_STATUS_NO_MEMORY;
 253                         goto err;
 254                 }
 255                 goto done;
 256         }
 257
 258         DEBUG(5, ("unix_convert called on file \"%s\"\n", orig_path));
 259
 260         /*
 261          * Conversion to basic unix format is already done in
 262          * check_path_syntax().
 263          */
 264
 265         /*
 266          * Names must be relative to the root of the service - any leading /.
 267          * and trailing /'s should have been trimmed by check_path_syntax().
 268          */
 269
 270 #ifdef DEVELOPER
 271         SMB_ASSERT(*orig_path != '/');
 272 #endif
 273
 274         /*
 275          * If we trimmed down to a single '\0' character
 276          * then we should use the "." directory to avoid
 277          * searching the cache, but not if we are in a
 278          * printing share.
 279          * As we know this is valid we can return true here.
 280          */
 281
 282         if (!*orig_path) {
 283                 if (!(smb_fname->base_name = talloc_strdup(smb_fname, "."))) {
 284                         status = NT_STATUS_NO_MEMORY;
 285                         goto err;
 286                 }
 287                 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
 288                         status = map_nt_error_from_unix(errno);
 289                         goto err;
 290                 }
 291                 DEBUG(5, ("conversion finished \"\" -> %s\n",
 292                           smb_fname->base_name));
 293                 goto done;
 294         }
 295
 296         if (orig_path[0] == '.' && (orig_path[1] == '/' ||
 297                                 orig_path[1] == '\0')) {
 298                 /* Start of pathname can't be "." only. */
 299                 if (orig_path[1] == '\0' || orig_path[2] == '\0') {
 300                         status = NT_STATUS_OBJECT_NAME_INVALID;
 301                 } else {
 302                         status =determine_path_error(&orig_path[2],
 303                             allow_wcard_last_component);
 304                 }
 305                 goto err;
 306         }
 307
 308         /* Start with the full orig_path as given by the caller. */
 309         if (!(smb_fname->base_name = talloc_strdup(smb_fname, orig_path))) {
 310                 DEBUG(0, ("talloc_strdup failed\n"));
 311                 status = NT_STATUS_NO_MEMORY;
 312                 goto err;
 313         }
 314
 315         /*
 316          * Large directory fix normalization. If we're case sensitive, and
 317          * the case preserving parameters are set to "no", normalize the case of
 318          * the incoming filename from the client WHETHER IT EXISTS OR NOT !
 319          * This is in conflict with the current (3.0.20) man page, but is
 320          * what people expect from the "large directory howto". I'll update
 321          * the man page. Thanks to jht@samba.org for finding this. JRA.
 322          */
 323
 324         if (conn->case_sensitive && !conn->case_preserve &&
 325                         !conn->short_case_preserve) {
 326                 if (!strnorm(smb_fname->base_name, lp_defaultcase(SNUM(conn)))) {
 327                         DEBUG(0, ("strnorm %s failed\n", smb_fname->base_name));
 328                         status = NT_STATUS_INVALID_PARAMETER;
 329                         goto err;
 330                 }
 331         }
 332
 333         /*
 334          * Ensure saved_last_component is valid even if file exists.
 335          */
 336
 337         if(save_last_component) {
 338                 end = strrchr_m(smb_fname->base_name, '/');
 339                 if (end) {
 340                         smb_fname->original_lcomp = talloc_strdup(smb_fname,
 341                                                                   end + 1);
 342                 } else {
 343                         smb_fname->original_lcomp =
 344                             talloc_strdup(smb_fname, smb_fname->base_name);
 345                 }
 346                 if (smb_fname->original_lcomp == NULL) {
 347                         status = NT_STATUS_NO_MEMORY;
 348                         goto err;
 349                 }
 350         }
 351
 352         posix_pathnames = (lp_posix_pathnames() ||
 353                                 (ucf_flags & UCF_POSIX_PATHNAMES));
 354
 355         /*
 356          * Strip off the stream, and add it back when we're done with the
 357          * base_name.
 358          */
 359         if (!posix_pathnames) {
 360                 stream = strchr_m(smb_fname->base_name, ':');
 361
 362                 if (stream != NULL) {
 363                         char *tmp = talloc_strdup(smb_fname, stream);
 364                         if (tmp == NULL) {
 365                                 status = NT_STATUS_NO_MEMORY;
 366                                 goto err;
 367                         }
 368                         /*
 369                          * Since this is actually pointing into
 370                          * smb_fname->base_name this truncates base_name.
 371                          */
 372                         *stream = '\0';
 373                         stream = tmp;
 374                 }
 375         }
 376
 377         start = smb_fname->base_name;
 378
 379         /*
 380          * If we're providing case insensitive semantics or
 381          * the underlying filesystem is case insensitive,
 382          * then a case-normalized hit in the stat-cache is
 383          * authoratitive. JRA.
 384          *
 385          * Note: We're only checking base_name.  The stream_name will be
 386          * added and verified in build_stream_path().
 387          */
 388
 389         if((!conn->case_sensitive || !(conn->fs_capabilities &
 390                                        FILE_CASE_SENSITIVE_SEARCH)) &&
 391             stat_cache_lookup(conn, posix_pathnames, &smb_fname->base_name, &dirpath, &start,
 392                               &smb_fname->st)) {
 393                 goto done;
 394         }
 395
 396         /*
 397          * Make sure "dirpath" is an allocated string, we use this for
 398          * building the directories with talloc_asprintf and free it.
 399          */
 400
 401         if ((dirpath == NULL) && (!(dirpath = talloc_strdup(ctx,"")))) {
 402                 DEBUG(0, ("talloc_strdup failed\n"));
 403                 status = NT_STATUS_NO_MEMORY;
 404                 goto err;
 405         }
 406
 407         /*
 408          * If we have a wildcard we must walk the path to
 409          * find where the error is, even if case sensitive
 410          * is true.
 411          */
 412
 413         name_has_wildcard = ms_has_wild(smb_fname->base_name);
 414         if (name_has_wildcard && !allow_wcard_last_component) {
 415                 /* Wildcard not valid anywhere. */
 416                 status = NT_STATUS_OBJECT_NAME_INVALID;
 417                 goto fail;
 418         }
 419
 420         DEBUG(5,("unix_convert begin: name = %s, dirpath = %s, start = %s\n",
 421                  smb_fname->base_name, dirpath, start));
 422
 423         if (!name_has_wildcard) {
 424                 /*
 425                  * stat the name - if it exists then we can add the stream back (if
 426                  * there was one) and be done!
 427                  */
 428
 429                 if (posix_pathnames) {
 430                         ret = SMB_VFS_LSTAT(conn, smb_fname);
 431                 } else {
 432                         ret = SMB_VFS_STAT(conn, smb_fname);
 433                 }
 434
 435                 if (ret == 0) {
 436                         status = check_for_dot_component(smb_fname);
 437                         if (!NT_STATUS_IS_OK(status)) {
 438                                 goto fail;
 439                         }
 440                         /* Add the path (not including the stream) to the cache. */
 441                         stat_cache_add(orig_path, smb_fname->base_name,
 442                                        conn->case_sensitive);
 443                         DEBUG(5,("conversion of base_name finished %s -> %s\n",
 444                                  orig_path, smb_fname->base_name));
 445                         goto done;
 446                 }
 447
 448                 /* Stat failed - ensure we don't use it. */
 449                 SET_STAT_INVALID(smb_fname->st);
 450
 451                 if (errno == ENOENT) {
 452                         /* Optimization when creating a new file - only
 453                            the last component doesn't exist.
 454                            NOTE : check_parent_exists() doesn't preserve errno.
 455                         */
 456                         int saved_errno = errno;
 457                         status = check_parent_exists(ctx,
 458                                                 conn,
 459                                                 posix_pathnames,
 460                                                 smb_fname,
 461                                                 &dirpath,
 462                                                 &start);
 463                         errno = saved_errno;
 464                         if (!NT_STATUS_IS_OK(status)) {
 465                                 goto fail;
 466                         }
 467                 }
 468
 469                 /*
 470                  * A special case - if we don't have any wildcards or mangling chars and are case
 471                  * sensitive or the underlying filesystem is case insensitive then searching
 472                  * won't help.
 473                  */
 474
 475                 if ((conn->case_sensitive || !(conn->fs_capabilities &
 476                                         FILE_CASE_SENSITIVE_SEARCH)) &&
 477                                 !mangle_is_mangled(smb_fname->base_name, conn->params)) {
 478
 479                         status = check_for_dot_component(smb_fname);
 480                         if (!NT_STATUS_IS_OK(status)) {
 481                                 goto fail;
 482                         }
 483
 484                         /*
 485                          * The stat failed. Could be ok as it could be
 486                          * a new file.
 487                          */
 488
 489                         if (errno == ENOTDIR || errno == ELOOP) {
 490                                 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
 491                                 goto fail;
 492                         } else if (errno == ENOENT) {
 493                                 /*
 494                                  * Was it a missing last component ?
 495                                  * or a missing intermediate component ?
 496                                  */
 497                                 struct smb_filename parent_fname;
 498                                 const char *last_component = NULL;
 499
 500                                 ZERO_STRUCT(parent_fname);
 501                                 if (!parent_dirname(ctx, smb_fname->base_name,
 502                                                         &parent_fname.base_name,
 503                                                         &last_component)) {
 504                                         status = NT_STATUS_NO_MEMORY;
 505                                         goto fail;
 506                                 }
 507                                 if (posix_pathnames) {
 508                                         ret = SMB_VFS_LSTAT(conn, &parent_fname);
 509                                 } else {
 510                                         ret = SMB_VFS_STAT(conn, &parent_fname);
 511                                 }
 512                                 if (ret == -1) {
 513                                         if (errno == ENOTDIR ||
 514                                                         errno == ENOENT ||
 515                                                         errno == ELOOP) {
 516                                                 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
 517                                                 goto fail;
 518                                         }
 519                                 }
 520
 521                                 /*
 522                                  * Missing last component is ok - new file.
 523                                  * Also deal with permission denied elsewhere.
 524                                  * Just drop out to done.
 525                                  */
 526                                 goto done;
 527                         }
 528                 }
 529         } else {
 530                 /*
 531                  * We have a wildcard in the pathname.
 532                  *
 533                  * Optimization for common case where the wildcard
 534                  * is in the last component and the client already
 535                  * sent the correct case.
 536                  * NOTE : check_parent_exists() doesn't preserve errno.
 537                  */
 538                 int saved_errno = errno;
 539                 status = check_parent_exists(ctx,
 540                                         conn,
 541                                         posix_pathnames,
 542                                         smb_fname,
 543                                         &dirpath,
 544                                         &start);
 545                 errno = saved_errno;
 546                 if (!NT_STATUS_IS_OK(status)) {
 547                         goto fail;
 548                 }
 549         }
 550
 551         /*
 552          * is_mangled() was changed to look at an entire pathname, not
 553          * just a component. JRA.
 554          */
 555
 556         if (mangle_is_mangled(start, conn->params)) {
 557                 component_was_mangled = True;
 558         }
 559
 560         /*
 561          * Now we need to recursively match the name against the real
 562          * directory structure.
 563          */
 564
 565         /*
 566          * Match each part of the path name separately, trying the names
 567          * as is first, then trying to scan the directory for matching names.
 568          */
 569
 570         for (; start ; start = (end?end+1:(char *)NULL)) {
 571                 /*
 572                  * Pinpoint the end of this section of the filename.
 573                  */
 574                 /* mb safe. '/' can't be in any encoded char. */
 575                 end = strchr(start, '/');
 576
 577                 /*
 578                  * Chop the name at this point.
 579                  */
 580                 if (end) {
 581                         *end = 0;
 582                 }
 583
 584                 if (save_last_component) {
 585                         TALLOC_FREE(smb_fname->original_lcomp);
 586                         smb_fname->original_lcomp = talloc_strdup(smb_fname,
 587                                                         end ? end + 1 : start);
 588                         if (!smb_fname->original_lcomp) {
 589                                 DEBUG(0, ("talloc failed\n"));
 590                                 status = NT_STATUS_NO_MEMORY;
 591                                 goto err;
 592                         }
 593                 }
 594
 595                 /* The name cannot have a component of "." */
 596
 597                 if (ISDOT(start)) {
 598                         if (!end)  {
 599                                 /* Error code at the end of a pathname. */
 600                                 status = NT_STATUS_OBJECT_NAME_INVALID;
 601                         } else {
 602                                 status = determine_path_error(end+1,
 603                                                 allow_wcard_last_component);
 604                         }
 605                         goto fail;
 606                 }
 607
 608                 /* The name cannot have a wildcard if it's not
 609                    the last component. */
 610
 611                 name_has_wildcard = ms_has_wild(start);
 612
 613                 /* Wildcards never valid within a pathname. */
 614                 if (name_has_wildcard && end) {
 615                         status = NT_STATUS_OBJECT_NAME_INVALID;
 616                         goto fail;
 617                 }
 618
 619                 /* Skip the stat call if it's a wildcard end. */
 620                 if (name_has_wildcard) {
 621                         DEBUG(5,("Wildcard %s\n",start));
 622                         goto done;
 623                 }
 624
 625                 /*
 626                  * Check if the name exists up to this point.
 627                  */
 628
 629                 if (posix_pathnames) {
 630                         ret = SMB_VFS_LSTAT(conn, smb_fname);
 631                 } else {
 632                         ret = SMB_VFS_STAT(conn, smb_fname);
 633                 }
 634
 635                 if (ret == 0) {
 636                         /*
 637                          * It exists. it must either be a directory or this must
 638                          * be the last part of the path for it to be OK.
 639                          */
 640                         if (end && !S_ISDIR(smb_fname->st.st_ex_mode)) {
 641                                 /*
 642                                  * An intermediate part of the name isn't
 643                                  * a directory.
 644                                  */
 645                                 DEBUG(5,("Not a dir %s\n",start));
 646                                 *end = '/';
 647                                 /*
 648                                  * We need to return the fact that the
 649                                  * intermediate name resolution failed. This
 650                                  * is used to return an error of ERRbadpath
 651                                  * rather than ERRbadfile. Some Windows
 652                                  * applications depend on the difference between
 653                                  * these two errors.
 654                                  */
 655                                 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
 656                                 goto fail;
 657                         }
 658
 659                 } else {
 660                         char *found_name = NULL;
 661
 662                         /* Stat failed - ensure we don't use it. */
 663                         SET_STAT_INVALID(smb_fname->st);
 664
 665                         /*
 666                          * Reset errno so we can detect
 667                          * directory open errors.
 668                          */
 669                         errno = 0;
 670
 671                         /*
 672                          * Try to find this part of the path in the directory.
 673                          */
 674
 675                         if (name_has_wildcard ||
 676                             (get_real_filename(conn, dirpath, start,
 677                                                talloc_tos(),
 678                                                &found_name) == -1)) {
 679                                 char *unmangled;
 680
 681                                 if (end) {
 682                                         /*
 683                                          * An intermediate part of the name
 684                                          * can't be found.
 685                                          */
 686                                         DEBUG(5,("Intermediate not found %s\n",
 687                                                         start));
 688                                         *end = '/';
 689
 690                                         /*
 691                                          * We need to return the fact that the
 692                                          * intermediate name resolution failed.
 693                                          * This is used to return an error of
 694                                          * ERRbadpath rather than ERRbadfile.
 695                                          * Some Windows applications depend on
 696                                          * the difference between these two
 697                                          * errors.
 698                                          */
 699
 700                                         /*
 701                                          * ENOENT, ENOTDIR and ELOOP all map
 702                                          * to NT_STATUS_OBJECT_PATH_NOT_FOUND
 703                                          * in the filename walk.
 704                                          */
 705
 706                                         if (errno == ENOENT ||
 707                                                         errno == ENOTDIR ||
 708                                                         errno == ELOOP) {
 709                                                 status =
 710                                                 NT_STATUS_OBJECT_PATH_NOT_FOUND;
 711                                         }
 712                                         else {
 713                                                 status =
 714                                                 map_nt_error_from_unix(errno);
 715                                         }
 716                                         goto fail;
 717                                 }
 718
 719                                 /*
 720                                  * ENOENT/EACCESS are the only valid errors
 721                                  * here. EACCESS needs handling here for
 722                                  * "dropboxes", i.e. directories where users
 723                                  * can only put stuff with permission -wx.
 724                                  */
 725                                 if ((errno != 0) && (errno != ENOENT)
 726                                     && (errno != EACCES)) {
 727                                         /*
 728                                          * ENOTDIR and ELOOP both map to
 729                                          * NT_STATUS_OBJECT_PATH_NOT_FOUND
 730                                          * in the filename walk.
 731                                          */
 732                                         if (errno == ENOTDIR ||
 733                                                         errno == ELOOP) {
 734                                                 status =
 735                                                 NT_STATUS_OBJECT_PATH_NOT_FOUND;
 736                                         } else {
 737                                                 status =
 738                                                 map_nt_error_from_unix(errno);
 739                                         }
 740                                         goto fail;
 741                                 }
 742
 743                                 /*
 744                                  * Just the last part of the name doesn't exist.
 745                                  * We need to strupper() or strlower() it as
 746                                  * this conversion may be used for file creation
 747                                  * purposes. Fix inspired by
 748                                  * Thomas Neumann <t.neumann@iku-ag.de>.
 749                                  */
 750                                 if (!conn->case_preserve ||
 751                                     (mangle_is_8_3(start, False,
 752                                                    conn->params) &&
 753                                                  !conn->short_case_preserve)) {
 754                                         if (!strnorm(start,
 755                                                         lp_defaultcase(SNUM(conn)))) {
 756                                                 DEBUG(0, ("strnorm %s failed\n",
 757                                                         start));
 758                                                 status = NT_STATUS_INVALID_PARAMETER;
 759                                                 goto err;
 760                                         }
 761                                 }
 762
 763                                 /*
 764                                  * check on the mangled stack to see if we can
 765                                  * recover the base of the filename.
 766                                  */
 767
 768                                 if (mangle_is_mangled(start, conn->params)
 769                                     && mangle_lookup_name_from_8_3(ctx,
 770                                                         start,
 771                                                         &unmangled,
 772                                                         conn->params)) {
 773                                         char *tmp;
 774                                         size_t start_ofs =
 775                                             start - smb_fname->base_name;
 776
 777                                         if (*dirpath != '\0') {
 778                                                 tmp = talloc_asprintf(
 779                                                         smb_fname, "%s/%s",
 780                                                         dirpath, unmangled);
 781                                                 TALLOC_FREE(unmangled);
 782                                         }
 783                                         else {
 784                                                 tmp = unmangled;
 785                                         }
 786                                         if (tmp == NULL) {
 787                                                 DEBUG(0, ("talloc failed\n"));
 788                                                 status = NT_STATUS_NO_MEMORY;
 789                                                 goto err;
 790                                         }
 791                                         TALLOC_FREE(smb_fname->base_name);
 792                                         smb_fname->base_name = tmp;
 793                                         start =
 794                                             smb_fname->base_name + start_ofs;
 795                                         end = start + strlen(start);
 796                                 }
 797
 798                                 DEBUG(5,("New file %s\n",start));
 799                                 goto done;
 800                         }
 801
 802
 803                         /*
 804                          * Restore the rest of the string. If the string was
 805                          * mangled the size may have changed.
 806                          */
 807                         if (end) {
 808                                 char *tmp;
 809                                 size_t start_ofs =
 810                                     start - smb_fname->base_name;
 811
 812                                 if (*dirpath != '\0') {
 813                                         tmp = talloc_asprintf(smb_fname,
 814                                                 "%s/%s/%s", dirpath,
 815                                                 found_name, end+1);
 816                                 }
 817                                 else {
 818                                         tmp = talloc_asprintf(smb_fname,
 819                                                 "%s/%s", found_name,
 820                                                 end+1);
 821                                 }
 822                                 if (tmp == NULL) {
 823                                         DEBUG(0, ("talloc_asprintf failed\n"));
 824                                         status = NT_STATUS_NO_MEMORY;
 825                                         goto err;
 826                                 }
 827                                 TALLOC_FREE(smb_fname->base_name);
 828                                 smb_fname->base_name = tmp;
 829                                 start = smb_fname->base_name + start_ofs;
 830                                 end = start + strlen(found_name);
 831                                 *end = '\0';
 832                         } else {
 833                                 char *tmp;
 834                                 size_t start_ofs =
 835                                     start - smb_fname->base_name;
 836
 837                                 if (*dirpath != '\0') {
 838                                         tmp = talloc_asprintf(smb_fname,
 839                                                 "%s/%s", dirpath,
 840                                                 found_name);
 841                                 } else {
 842                                         tmp = talloc_strdup(smb_fname,
 843                                                 found_name);
 844                                 }
 845                                 if (tmp == NULL) {
 846                                         DEBUG(0, ("talloc failed\n"));
 847                                         status = NT_STATUS_NO_MEMORY;
 848                                         goto err;
 849                                 }
 850                                 TALLOC_FREE(smb_fname->base_name);
 851                                 smb_fname->base_name = tmp;
 852                                 start = smb_fname->base_name + start_ofs;
 853
 854                                 /*
 855                                  * We just scanned for, and found the end of
 856                                  * the path. We must return a valid stat struct
 857                                  * if it exists. JRA.
 858                                  */
 859
 860                                 if (posix_pathnames) {
 861                                         ret = SMB_VFS_LSTAT(conn, smb_fname);
 862                                 } else {
 863                                         ret = SMB_VFS_STAT(conn, smb_fname);
 864                                 }
 865
 866                                 if (ret != 0) {
 867                                         SET_STAT_INVALID(smb_fname->st);
 868                                 }
 869                         }
 870
 871                         TALLOC_FREE(found_name);
 872                 } /* end else */
 873
 874 #ifdef DEVELOPER
 875                 /*
 876                  * This sucks!
 877                  * We should never provide different behaviors
 878                  * depending on DEVELOPER!!!
 879                  */
 880                 if (VALID_STAT(smb_fname->st)) {
 881                         bool delete_pending;
 882                         uint32_t name_hash;
 883
 884                         status = file_name_hash(conn,
 885                                         smb_fname_str_dbg(smb_fname),
 886                                         &name_hash);
 887                         if (!NT_STATUS_IS_OK(status)) {
 888                                 goto fail;
 889                         }
 890
 891                         get_file_infos(vfs_file_id_from_sbuf(conn,
 892                                                              &smb_fname->st),
 893                                        name_hash,
 894                                        &delete_pending, NULL);
 895                         if (delete_pending) {
 896                                 status = NT_STATUS_DELETE_PENDING;
 897                                 goto fail;
 898                         }
 899                 }
 900 #endif
 901
 902                 /*
 903                  * Add to the dirpath that we have resolved so far.
 904                  */
 905
 906                 if (*dirpath != '\0') {
 907                         char *tmp = talloc_asprintf(ctx,
 908                                         "%s/%s", dirpath, start);
 909                         if (!tmp) {
 910                                 DEBUG(0, ("talloc_asprintf failed\n"));
 911                                 status = NT_STATUS_NO_MEMORY;
 912                                 goto err;
 913                         }
 914                         TALLOC_FREE(dirpath);
 915                         dirpath = tmp;
 916                 }
 917                 else {
 918                         TALLOC_FREE(dirpath);
 919                         if (!(dirpath = talloc_strdup(ctx,start))) {
 920                                 DEBUG(0, ("talloc_strdup failed\n"));
 921                                 status = NT_STATUS_NO_MEMORY;
 922                                 goto err;
 923                         }
 924                 }
 925
 926                 /*
 927                  * Cache the dirpath thus far. Don't cache a name with mangled
 928                  * or wildcard components as this can change the size.
 929                  */
 930                 if(!component_was_mangled && !name_has_wildcard) {
 931                         stat_cache_add(orig_path, dirpath,
 932                                         conn->case_sensitive);
 933                 }
 934
 935                 /*
 936                  * Restore the / that we wiped out earlier.
 937                  */
 938                 if (end) {
 939                         *end = '/';
 940                 }
 941         }
 942
 943         /*
 944          * Cache the full path. Don't cache a name with mangled or wildcard
 945          * components as this can change the size.
 946          */
 947
 948         if(!component_was_mangled && !name_has_wildcard) {
 949                 stat_cache_add(orig_path, smb_fname->base_name,
 950                                conn->case_sensitive);
 951         }
 952
 953         /*
 954          * The name has been resolved.
 955          */
 956
 957         DEBUG(5,("conversion finished %s -> %s\n", orig_path,
 958                  smb_fname->base_name));
 959
 960  done:
 961         /* Add back the stream if one was stripped off originally. */
 962         if (stream != NULL) {
 963                 smb_fname->stream_name = stream;
 964
 965                 /* Check path now that the base_name has been converted. */
 966                 status = build_stream_path(ctx, conn, orig_path, smb_fname);
 967                 if (!NT_STATUS_IS_OK(status)) {
 968                         goto fail;
 969                 }
 970         }
 971         TALLOC_FREE(dirpath);
 972         *smb_fname_out = smb_fname;
 973         return NT_STATUS_OK;
 974  fail:
 975         DEBUG(10, ("dirpath = [%s] start = [%s]\n", dirpath, start));
 976         if (*dirpath != '\0') {
 977                 smb_fname->base_name = talloc_asprintf(smb_fname, "%s/%s",
 978                                                        dirpath, start);
 979         } else {
 980                 smb_fname->base_name = talloc_strdup(smb_fname, start);
 981         }
 982         if (!smb_fname->base_name) {
 983                 DEBUG(0, ("talloc_asprintf failed\n"));
 984                 status = NT_STATUS_NO_MEMORY;
 985                 goto err;
 986         }
 987
 988         *smb_fname_out = smb_fname;
 989         TALLOC_FREE(dirpath);
 990         return status;
 991  err:
 992         TALLOC_FREE(smb_fname);
 993         return status;
 994 }
 995
 996 /****************************************************************************
 997  Ensure a path is not vetod.
 998 ****************************************************************************/
 999
1000 NTSTATUS check_veto_path(connection_struct *conn, const char *name)
1001 {
1002         if (IS_VETO_PATH(conn, name))  {
1003                 /* Is it not dot or dot dot. */
1004                 if (!(ISDOT(name) || ISDOTDOT(name))) {
1005                         DEBUG(5,("check_veto_path: file path name %s vetoed\n",
1006                                                 name));
1007                         return map_nt_error_from_unix(ENOENT);
1008                 }
1009         }
1010         return NT_STATUS_OK;
1011 }
1012
1013 /****************************************************************************
1014  Check a filename - possibly calling check_reduced_name.
1015  This is called by every routine before it allows an operation on a filename.
1016  It does any final confirmation necessary to ensure that the filename is
1017  a valid one for the user to access.
1018 ****************************************************************************/
1019
1020 NTSTATUS check_name(connection_struct *conn, const char *name)
1021 {
1022         NTSTATUS status = check_veto_path(conn, name);
1023
1024         if (!NT_STATUS_IS_OK(status)) {
1025                 return status;
1026         }
1027
1028         if (!lp_widelinks(SNUM(conn)) || !lp_symlinks(SNUM(conn))) {
1029                 status = check_reduced_name(conn,name);
1030                 if (!NT_STATUS_IS_OK(status)) {
1031                         DEBUG(5,("check_name: name %s failed with %s\n",name,
1032                                                 nt_errstr(status)));
1033                         return status;
1034                 }
1035         }
1036
1037         return NT_STATUS_OK;
1038 }
1039
1040 /****************************************************************************
1041  Must be called as root. Creates the struct privilege_paths
1042  attached to the struct smb_request if this call is successful.
1043 ****************************************************************************/
1044
1045 static NTSTATUS check_name_with_privilege(connection_struct *conn,
1046                 struct smb_request *smbreq,
1047                 const char *name)
1048 {
1049         NTSTATUS status = check_veto_path(conn, name);
1050
1051         if (!NT_STATUS_IS_OK(status)) {
1052                 return status;
1053         }
1054         return check_reduced_name_with_privilege(conn,
1055                         name,
1056                         smbreq);
1057 }
1058
1059 /****************************************************************************
1060  Check if two filenames are equal.
1061  This needs to be careful about whether we are case sensitive.
1062 ****************************************************************************/
1063
1064 static bool fname_equal(const char *name1, const char *name2,
1065                 bool case_sensitive)
1066 {
1067         /* Normal filename handling */
1068         if (case_sensitive) {
1069                 return(strcmp(name1,name2) == 0);
1070         }
1071
1072         return(strequal(name1,name2));
1073 }
1074
1075 /****************************************************************************
1076  Scan a directory to find a filename, matching without case sensitivity.
1077  If the name looks like a mangled name then try via the mangling functions
1078 ****************************************************************************/
1079
1080 static int get_real_filename_full_scan(connection_struct *conn,
1081                                        const char *path, const char *name,
1082                                        bool mangled,
1083                                        TALLOC_CTX *mem_ctx, char **found_name)
1084 {
1085         struct smb_Dir *cur_dir;
1086         const char *dname = NULL;
1087         char *talloced = NULL;
1088         char *unmangled_name = NULL;
1089         long curpos;
1090
1091         /* handle null paths */
1092         if ((path == NULL) || (*path == 0)) {
1093                 path = ".";
1094         }
1095
1096         /* If we have a case-sensitive filesystem, it doesn't do us any
1097          * good to search for a name. If a case variation of the name was
1098          * there, then the original stat(2) would have found it.
1099          */
1100         if (!mangled && !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
1101                 errno = ENOENT;
1102                 return -1;
1103         }
1104
1105         /*
1106          * The incoming name can be mangled, and if we de-mangle it
1107          * here it will not compare correctly against the filename (name2)
1108          * read from the directory and then mangled by the name_to_8_3()
1109          * call. We need to mangle both names or neither.
1110          * (JRA).
1111          *
1112          * Fix for bug found by Dina Fine. If in case sensitive mode then
1113          * the mangle cache is no good (3 letter extension could be wrong
1114          * case - so don't demangle in this case - leave as mangled and
1115          * allow the mangling of the directory entry read (which is done
1116          * case insensitively) to match instead. This will lead to more
1117          * false positive matches but we fail completely without it. JRA.
1118          */
1119
1120         if (mangled && !conn->case_sensitive) {
1121                 mangled = !mangle_lookup_name_from_8_3(talloc_tos(), name,
1122                                                        &unmangled_name,
1123                                                        conn->params);
1124                 if (!mangled) {
1125                         /* Name is now unmangled. */
1126                         name = unmangled_name;
1127                 }
1128         }
1129
1130         /* open the directory */
1131         if (!(cur_dir = OpenDir(talloc_tos(), conn, path, NULL, 0))) {
1132                 DEBUG(3,("scan dir didn't open dir [%s]\n",path));
1133                 TALLOC_FREE(unmangled_name);
1134                 return -1;
1135         }
1136
1137         /* now scan for matching names */
1138         curpos = 0;
1139         while ((dname = ReadDirName(cur_dir, &curpos, NULL, &talloced))) {
1140
1141                 /* Is it dot or dot dot. */
1142                 if (ISDOT(dname) || ISDOTDOT(dname)) {
1143                         TALLOC_FREE(talloced);
1144                         continue;
1145                 }
1146
1147                 /*
1148                  * At this point dname is the unmangled name.
1149                  * name is either mangled or not, depending on the state
1150                  * of the "mangled" variable. JRA.
1151                  */
1152
1153                 /*
1154                  * Check mangled name against mangled name, or unmangled name
1155                  * against unmangled name.
1156                  */
1157
1158                 if ((mangled && mangled_equal(name,dname,conn->params)) ||
1159                         fname_equal(name, dname, conn->case_sensitive)) {
1160                         /* we've found the file, change it's name and return */
1161                         *found_name = talloc_strdup(mem_ctx, dname);
1162                         TALLOC_FREE(unmangled_name);
1163                         TALLOC_FREE(cur_dir);
1164                         if (!*found_name) {
1165                                 errno = ENOMEM;
1166                                 TALLOC_FREE(talloced);
1167                                 return -1;
1168                         }
1169                         TALLOC_FREE(talloced);
1170                         return 0;
1171                 }
1172                 TALLOC_FREE(talloced);
1173         }
1174
1175         TALLOC_FREE(unmangled_name);
1176         TALLOC_FREE(cur_dir);
1177         errno = ENOENT;
1178         return -1;
1179 }
1180
1181 /****************************************************************************
1182  Wrapper around the vfs get_real_filename and the full directory scan
1183  fallback.
1184 ****************************************************************************/
1185
1186 int get_real_filename(connection_struct *conn, const char *path,
1187                       const char *name, TALLOC_CTX *mem_ctx,
1188                       char **found_name)
1189 {
1190         int ret;
1191         bool mangled;
1192
1193         mangled = mangle_is_mangled(name, conn->params);
1194
1195         if (mangled) {
1196                 return get_real_filename_full_scan(conn, path, name, mangled,
1197                                                    mem_ctx, found_name);
1198         }
1199
1200         /* Try the vfs first to take advantage of case-insensitive stat. */
1201         ret = SMB_VFS_GET_REAL_FILENAME(conn, path, name, mem_ctx, found_name);
1202
1203         /*
1204          * If the case-insensitive stat was successful, or returned an error
1205          * other than EOPNOTSUPP then there is no need to fall back on the
1206          * full directory scan.
1207          */
1208         if (ret == 0 || (ret == -1 && errno != EOPNOTSUPP)) {
1209                 return ret;
1210         }
1211
1212         return get_real_filename_full_scan(conn, path, name, mangled, mem_ctx,
1213                                            found_name);
1214 }
1215
1216 static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
1217                                   connection_struct *conn,
1218                                   const char *orig_path,
1219                                   struct smb_filename *smb_fname)
1220 {
1221         NTSTATUS status;
1222         unsigned int i, num_streams = 0;
1223         struct stream_struct *streams = NULL;
1224
1225         if (SMB_VFS_STAT(conn, smb_fname) == 0) {
1226                 DEBUG(10, ("'%s' exists\n", smb_fname_str_dbg(smb_fname)));
1227                 return NT_STATUS_OK;
1228         }
1229
1230         if (errno != ENOENT) {
1231                 DEBUG(10, ("vfs_stat failed: %s\n", strerror(errno)));
1232                 status = map_nt_error_from_unix(errno);
1233                 goto fail;
1234         }
1235
1236         /* Fall back to a case-insensitive scan of all streams on the file. */
1237         status = vfs_streaminfo(conn, NULL, smb_fname->base_name, mem_ctx,
1238                                 &num_streams, &streams);
1239
1240         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
1241                 SET_STAT_INVALID(smb_fname->st);
1242                 return NT_STATUS_OK;
1243         }
1244
1245         if (!NT_STATUS_IS_OK(status)) {
1246                 DEBUG(10, ("vfs_streaminfo failed: %s\n", nt_errstr(status)));
1247                 goto fail;
1248         }
1249
1250         for (i=0; i<num_streams; i++) {
1251                 DEBUG(10, ("comparing [%s] and [%s]: ",
1252                            smb_fname->stream_name, streams[i].name));
1253                 if (fname_equal(smb_fname->stream_name, streams[i].name,
1254                                 conn->case_sensitive)) {
1255                         DEBUGADD(10, ("equal\n"));
1256                         break;
1257                 }
1258                 DEBUGADD(10, ("not equal\n"));
1259         }
1260
1261         /* Couldn't find the stream. */
1262         if (i == num_streams) {
1263                 SET_STAT_INVALID(smb_fname->st);
1264                 TALLOC_FREE(streams);
1265                 return NT_STATUS_OK;
1266         }
1267
1268         DEBUG(10, ("case insensitive stream. requested: %s, actual: %s\n",
1269                 smb_fname->stream_name, streams[i].name));
1270
1271
1272         TALLOC_FREE(smb_fname->stream_name);
1273         smb_fname->stream_name = talloc_strdup(smb_fname, streams[i].name);
1274         if (smb_fname->stream_name == NULL) {
1275                 status = NT_STATUS_NO_MEMORY;
1276                 goto fail;
1277         }
1278
1279         SET_STAT_INVALID(smb_fname->st);
1280
1281         if (SMB_VFS_STAT(conn, smb_fname) == 0) {
1282                 DEBUG(10, ("'%s' exists\n", smb_fname_str_dbg(smb_fname)));
1283         }
1284         status = NT_STATUS_OK;
1285  fail:
1286         TALLOC_FREE(streams);
1287         return status;
1288 }
1289
1290 /**
1291  * Go through all the steps to validate a filename.
1292  *
1293  * @param ctx           talloc_ctx to allocate memory with.
1294  * @param conn          connection struct for vfs calls.
1295  * @param dfs_path      Whether this path requires dfs resolution.
1296  * @param smbreq        SMB request if we're using privileges.
1297  * @param name_in       The unconverted name.
1298  * @param ucf_flags     flags to pass through to unix_convert().
1299  *                      UCF_ALWAYS_ALLOW_WCARD_LCOMP will be OR'd in if
1300  *                      p_cont_wcard != NULL and is true and
1301  *                      UCF_COND_ALLOW_WCARD_LCOMP.
1302  * @param p_cont_wcard  If not NULL, will be set to true if the dfs path
1303  *                      resolution detects a wildcard.
1304  * @param pp_smb_fname  The final converted name will be allocated if the
1305  *                      return is NT_STATUS_OK.
1306  *
1307  * @return NT_STATUS_OK if all operations completed succesfully, appropriate
1308  *         error otherwise.
1309  */
1310 static NTSTATUS filename_convert_internal(TALLOC_CTX *ctx,
1311                                 connection_struct *conn,
1312                                 bool dfs_path,
1313                                 struct smb_request *smbreq,
1314                                 const char *name_in,
1315                                 uint32_t ucf_flags,
1316                                 bool *ppath_contains_wcard,
1317                                 struct smb_filename **pp_smb_fname)
1318 {
1319         NTSTATUS status;
1320         bool allow_wcards = (ucf_flags & (UCF_COND_ALLOW_WCARD_LCOMP|UCF_ALWAYS_ALLOW_WCARD_LCOMP));
1321         char *fname = NULL;
1322
1323         *pp_smb_fname = NULL;
1324
1325         status = resolve_dfspath_wcard(ctx, conn,
1326                                 dfs_path,
1327                                 name_in,
1328                                 allow_wcards,
1329                                 !conn->sconn->using_smb2,
1330                                 &fname,
1331                                 ppath_contains_wcard);
1332         if (!NT_STATUS_IS_OK(status)) {
1333                 DEBUG(10,("filename_convert_internal: resolve_dfspath failed "
1334                         "for name %s with %s\n",
1335                         name_in,
1336                         nt_errstr(status) ));
1337                 return status;
1338         }
1339
1340         if (is_fake_file_path(name_in)) {
1341                 SMB_STRUCT_STAT st;
1342                 ZERO_STRUCT(st);
1343                 st.st_ex_nlink = 1;
1344                 *pp_smb_fname = synthetic_smb_fname_split(ctx,
1345                                                           name_in,
1346                                                           &st);
1347                 if (*pp_smb_fname == NULL) {
1348                         return NT_STATUS_NO_MEMORY;
1349                 }
1350                 return NT_STATUS_OK;
1351         }
1352
1353         /*
1354          * If the caller conditionally allows wildcard lookups, only add the
1355          * always allow if the path actually does contain a wildcard.
1356          */
1357         if (ucf_flags & UCF_COND_ALLOW_WCARD_LCOMP &&
1358             ppath_contains_wcard != NULL && *ppath_contains_wcard) {
1359                 ucf_flags |= UCF_ALWAYS_ALLOW_WCARD_LCOMP;
1360         }
1361
1362         status = unix_convert(ctx, conn, fname, pp_smb_fname, ucf_flags);
1363         if (!NT_STATUS_IS_OK(status)) {
1364                 DEBUG(10,("filename_convert_internal: unix_convert failed "
1365                         "for name %s with %s\n",
1366                         fname,
1367                         nt_errstr(status) ));
1368                 return status;
1369         }
1370
1371         if ((ucf_flags & UCF_UNIX_NAME_LOOKUP) &&
1372                         VALID_STAT((*pp_smb_fname)->st) &&
1373                         S_ISLNK((*pp_smb_fname)->st.st_ex_mode)) {
1374                 return check_veto_path(conn, (*pp_smb_fname)->base_name);
1375         }
1376
1377         if (!smbreq) {
1378                 status = check_name(conn, (*pp_smb_fname)->base_name);
1379         } else {
1380                 status = check_name_with_privilege(conn, smbreq, (*pp_smb_fname)->base_name);
1381         }
1382         if (!NT_STATUS_IS_OK(status)) {
1383                 DEBUG(3,("filename_convert_internal: check_name failed "
1384                         "for name %s with %s\n",
1385                         smb_fname_str_dbg(*pp_smb_fname),
1386                         nt_errstr(status) ));
1387                 TALLOC_FREE(*pp_smb_fname);
1388                 return status;
1389         }
1390
1391         return status;
1392 }
1393
1394 /*
1395  * Go through all the steps to validate a filename.
1396  * Non-root version.
1397  */
1398
1399 NTSTATUS filename_convert(TALLOC_CTX *ctx,
1400                                 connection_struct *conn,
1401                                 bool dfs_path,
1402                                 const char *name_in,
1403                                 uint32_t ucf_flags,
1404                                 bool *ppath_contains_wcard,
1405                                 struct smb_filename **pp_smb_fname)
1406 {
1407         return filename_convert_internal(ctx,
1408                                         conn,
1409                                         dfs_path,
1410                                         NULL,
1411                                         name_in,
1412                                         ucf_flags,
1413                                         ppath_contains_wcard,
1414                                         pp_smb_fname);
1415 }
1416
1417 /*
1418  * Go through all the steps to validate a filename.
1419  * root (privileged) version.
1420  */
1421
1422 NTSTATUS filename_convert_with_privilege(TALLOC_CTX *ctx,
1423                                 connection_struct *conn,
1424                                 struct smb_request *smbreq,
1425                                 const char *name_in,
1426                                 uint32_t ucf_flags,
1427                                 bool *ppath_contains_wcard,
1428                                 struct smb_filename **pp_smb_fname)
1429 {
1430         return filename_convert_internal(ctx,
1431                                         conn,
1432                                         smbreq->flags2 & FLAGS2_DFS_PATHNAMES,
1433                                         smbreq,
1434                                         name_in,
1435                                         ucf_flags,
1436                                         ppath_contains_wcard,
1437                                         pp_smb_fname);
1438 }