source/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-2004
   6    Copyright (C) Ying Chen 2000
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 /*
  24  * New hash table stat cache code added by Ying Chen.
  25  */
  26
  27 #include "includes.h"
  28
  29 static BOOL scan_directory(const char *path, char *name,size_t maxlength,
  30                            connection_struct *conn,BOOL docache);
  31
  32 /****************************************************************************
  33  Check if two filenames are equal.
  34  This needs to be careful about whether we are case sensitive.
  35 ****************************************************************************/
  36
  37 static BOOL fname_equal(const char *name1, const char *name2, BOOL case_sensitive)
  38 {
  39         /* Normal filename handling */
  40         if (case_sensitive)
  41                 return(strcmp(name1,name2) == 0);
  42
  43         return(strequal(name1,name2));
  44 }
  45
  46 /****************************************************************************
  47  Mangle the 2nd name and check if it is then equal to the first name.
  48 ****************************************************************************/
  49
  50 static BOOL mangled_equal(const char *name1, const char *name2, int snum)
  51 {
  52         pstring tmpname;
  53
  54         pstrcpy(tmpname, name2);
  55         mangle_map(tmpname, True, False, snum);
  56         return strequal(name1, tmpname);
  57 }
  58
  59 /****************************************************************************
  60 This routine is called to convert names from the dos namespace to unix
  61 namespace. It needs to handle any case conversions, mangling, format
  62 changes etc.
  63
  64 We assume that we have already done a chdir() to the right "root" directory
  65 for this service.
  66
  67 The function will return False if some part of the name except for the last
  68 part cannot be resolved
  69
  70 If the saved_last_component != 0, then the unmodified last component
  71 of the pathname is returned there. This is used in an exceptional
  72 case in reply_mv (so far). If saved_last_component == 0 then nothing
  73 is returned there.
  74
  75 The bad_path arg is set to True if the filename walk failed. This is
  76 used to pick the correct error code to return between ENOENT and ENOTDIR
  77 as Windows applications depend on ERRbadpath being returned if a component
  78 of a pathname does not exist.
  79
  80 On exit from unix_convert, if *pst was not null, then the file stat
  81 struct will be returned if the file exists and was found, if not this
  82 stat struct will be filled with zeros (and this can be detected by checking
  83 for nlinks = 0, which can never be true for any file).
  84 ****************************************************************************/
  85
  86 BOOL unix_convert(pstring name,connection_struct *conn,char *saved_last_component,
  87                   BOOL *bad_path, SMB_STRUCT_STAT *pst)
  88 {
  89         SMB_STRUCT_STAT st;
  90         char *start, *end;
  91         pstring dirpath;
  92         pstring orig_path;
  93         BOOL component_was_mangled = False;
  94         BOOL name_has_wildcard = False;
  95
  96         ZERO_STRUCTP(pst);
  97
  98         *dirpath = 0;
  99         *bad_path = False;
 100         if(saved_last_component)
 101                 *saved_last_component = 0;
 102
 103         if (conn->printer) {
 104                 /* we don't ever use the filenames on a printer share as a
 105                         filename - so don't convert them */
 106                 return True;
 107         }
 108
 109         DEBUG(5, ("unix_convert called on file \"%s\"\n", name));
 110
 111         /*
 112          * Conversion to basic unix format is already done in check_path_syntax().
 113          */
 114
 115         /*
 116          * Names must be relative to the root of the service - any leading /.
 117          * and trailing /'s should have been trimmed by check_path_syntax().
 118          */
 119
 120 #ifdef DEVELOPER
 121         SMB_ASSERT(*name != '/');
 122 #endif
 123
 124         /*
 125          * If we trimmed down to a single '\0' character
 126          * then we should use the "." directory to avoid
 127          * searching the cache, but not if we are in a
 128          * printing share.
 129          * As we know this is valid we can return true here.
 130          */
 131
 132         if (!*name) {
 133                 name[0] = '.';
 134                 name[1] = '\0';
 135                 if (SMB_VFS_STAT(conn,name,&st) == 0) {
 136                         *pst = st;
 137                 }
 138                 DEBUG(5,("conversion finished \"\" -> %s\n",name));
 139                 return(True);
 140         }
 141
 142         /*
 143          * Ensure saved_last_component is valid even if file exists.
 144          */
 145
 146         if(saved_last_component) {
 147                 end = strrchr_m(name, '/');
 148                 if(end)
 149                         pstrcpy(saved_last_component, end + 1);
 150                 else
 151                         pstrcpy(saved_last_component, name);
 152         }
 153
 154 #if 1
 155         if (!conn->case_preserve || (mangle_is_8_3(name, False) && !conn->short_case_preserve))
 156 #else
 157         if (!conn->case_sensitive && (!conn->case_preserve || (mangle_is_8_3(name, False) && !conn->short_case_preserve)))
 158 #endif
 159                 strnorm(name, lp_defaultcase(SNUM(conn)));
 160
 161         start = name;
 162         pstrcpy(orig_path, name);
 163
 164         if(!conn->case_sensitive && stat_cache_lookup(conn, name, dirpath, &start, &st)) {
 165                 *pst = st;
 166                 return True;
 167         }
 168
 169         /*
 170          * stat the name - if it exists then we are all done!
 171          */
 172
 173         if (SMB_VFS_STAT(conn,name,&st) == 0) {
 174                 stat_cache_add(orig_path, name, conn->case_sensitive);
 175                 DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
 176                 *pst = st;
 177                 return(True);
 178         }
 179
 180         DEBUG(5,("unix_convert begin: name = %s, dirpath = %s, start = %s\n", name, dirpath, start));
 181
 182         /*
 183          * A special case - if we don't have any mangling chars and are case
 184          * sensitive then searching won't help.
 185          */
 186
 187         if (conn->case_sensitive && !mangle_is_mangled(name) && !*lp_mangled_map(SNUM(conn)))
 188                 return(False);
 189
 190         name_has_wildcard = ms_has_wild(start);
 191
 192         /*
 193          * is_mangled() was changed to look at an entire pathname, not
 194          * just a component. JRA.
 195          */
 196
 197         if (mangle_is_mangled(start))
 198                 component_was_mangled = True;
 199
 200         /*
 201          * Now we need to recursively match the name against the real
 202          * directory structure.
 203          */
 204
 205         /*
 206          * Match each part of the path name separately, trying the names
 207          * as is first, then trying to scan the directory for matching names.
 208          */
 209
 210         for (; start ; start = (end?end+1:(char *)NULL)) {
 211                 /*
 212                  * Pinpoint the end of this section of the filename.
 213                  */
 214                 end = strchr_m(start, '/');
 215
 216                 /*
 217                  * Chop the name at this point.
 218                  */
 219                 if (end)
 220                         *end = 0;
 221
 222                 if(saved_last_component != 0)
 223                         pstrcpy(saved_last_component, end ? end + 1 : start);
 224
 225                 /*
 226                  * Check if the name exists up to this point.
 227                  */
 228
 229                 if (SMB_VFS_STAT(conn,name, &st) == 0) {
 230                         /*
 231                          * It exists. it must either be a directory or this must be
 232                          * the last part of the path for it to be OK.
 233                          */
 234                         if (end && !(st.st_mode & S_IFDIR)) {
 235                                 /*
 236                                  * An intermediate part of the name isn't a directory.
 237                                  */
 238                                 DEBUG(5,("Not a dir %s\n",start));
 239                                 *end = '/';
 240                                 /*
 241                                  * We need to return the fact that the intermediate
 242                                  * name resolution failed. This is used to return an
 243                                  * error of ERRbadpath rather than ERRbadfile. Some
 244                                  * Windows applications depend on the difference between
 245                                  * these two errors.
 246                                  */
 247                                 errno = ENOTDIR;
 248                                 *bad_path = True;
 249                                 return(False);
 250                         }
 251
 252                         if (!end) {
 253                                 /*
 254                                  * We just scanned for, and found the end of the path.
 255                                  * We must return the valid stat struct.
 256                                  * JRA.
 257                                  */
 258
 259                                 *pst = st;
 260                         }
 261
 262                 } else {
 263                         pstring rest;
 264
 265                         /* Stat failed - ensure we don't use it. */
 266                         ZERO_STRUCT(st);
 267                         *rest = 0;
 268
 269                         /*
 270                          * Remember the rest of the pathname so it can be restored
 271                          * later.
 272                          */
 273
 274                         if (end)
 275                                 pstrcpy(rest,end+1);
 276
 277                         /* Reset errno so we can detect directory open errors. */
 278                         errno = 0;
 279
 280                         /*
 281                          * Try to find this part of the path in the directory.
 282                          */
 283
 284                         if (ms_has_wild(start) ||
 285                             !scan_directory(dirpath, start,
 286                                             sizeof(pstring) - 1 - (start - name),
 287                                             conn,
 288                                             end?True:False)) {
 289                                 if (end) {
 290                                         /*
 291                                          * An intermediate part of the name can't be found.
 292                                          */
 293                                         DEBUG(5,("Intermediate not found %s\n",start));
 294                                         *end = '/';
 295
 296                                         /*
 297                                          * We need to return the fact that the intermediate
 298                                          * name resolution failed. This is used to return an
 299                                          * error of ERRbadpath rather than ERRbadfile. Some
 300                                          * Windows applications depend on the difference between
 301                                          * these two errors.
 302                                          */
 303                                         *bad_path = True;
 304                                         return(False);
 305                                 }
 306
 307                                 if (errno == ENOTDIR) {
 308                                         *bad_path = True;
 309                                         return(False);
 310                                 }
 311
 312                                 /*
 313                                  * Just the last part of the name doesn't exist.
 314                                  * We may need to strupper() or strlower() it in case
 315                                  * this conversion is being used for file creation
 316                                  * purposes. If the filename is of mixed case then
 317                                  * don't normalise it.
 318                                  */
 319
 320                                 if (!conn->case_preserve && (!strhasupper(start) || !strhaslower(start)))
 321                                         strnorm(start, lp_defaultcase(SNUM(conn)));
 322
 323                                 /*
 324                                  * check on the mangled stack to see if we can recover the
 325                                  * base of the filename.
 326                                  */
 327
 328                                 if (mangle_is_mangled(start)) {
 329                                         mangle_check_cache( start, sizeof(pstring) - 1 - (start - name) );
 330                                 }
 331
 332                                 DEBUG(5,("New file %s\n",start));
 333                                 return(True);
 334                         }
 335
 336                         /*
 337                          * Restore the rest of the string. If the string was mangled the size
 338                          * may have changed.
 339                          */
 340                         if (end) {
 341                                 end = start + strlen(start);
 342                                 if (!safe_strcat(start, "/", sizeof(pstring) - 1 - (start - name)) ||
 343                                     !safe_strcat(start, rest, sizeof(pstring) - 1 - (start - name))) {
 344                                         return False;
 345                                 }
 346                                 *end = '\0';
 347                         } else {
 348                                 /*
 349                                  * We just scanned for, and found the end of the path.
 350                                  * We must return a valid stat struct if it exists.
 351                                  * JRA.
 352                                  */
 353
 354                                 if (SMB_VFS_STAT(conn,name, &st) == 0) {
 355                                         *pst = st;
 356                                 } else {
 357                                         ZERO_STRUCT(st);
 358                                 }
 359                         }
 360                 } /* end else */
 361
 362                 /*
 363                  * Add to the dirpath that we have resolved so far.
 364                  */
 365                 if (*dirpath)
 366                         pstrcat(dirpath,"/");
 367
 368                 pstrcat(dirpath,start);
 369
 370                 /*
 371                  * Don't cache a name with mangled or wildcard components
 372                  * as this can change the size.
 373                  */
 374
 375                 if(!component_was_mangled && !name_has_wildcard)
 376                         stat_cache_add(orig_path, dirpath, conn->case_sensitive);
 377
 378                 /*
 379                  * Restore the / that we wiped out earlier.
 380                  */
 381                 if (end)
 382                         *end = '/';
 383         }
 384
 385         /*
 386          * Don't cache a name with mangled or wildcard components
 387          * as this can change the size.
 388          */
 389
 390         if(!component_was_mangled && !name_has_wildcard)
 391                 stat_cache_add(orig_path, name, conn->case_sensitive);
 392
 393         /*
 394          * The name has been resolved.
 395          */
 396
 397         DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
 398         return(True);
 399 }
 400
 401 /****************************************************************************
 402  Check a filename - possibly caling reducename.
 403  This is called by every routine before it allows an operation on a filename.
 404  It does any final confirmation necessary to ensure that the filename is
 405  a valid one for the user to access.
 406 ****************************************************************************/
 407
 408 BOOL check_name(pstring name,connection_struct *conn)
 409 {
 410         BOOL ret = True;
 411
 412         if (IS_VETO_PATH(conn, name))  {
 413                 /* Is it not dot or dot dot. */
 414                 if (!((name[0] == '.') && (!name[1] || (name[1] == '.' && !name[2])))) {
 415                         DEBUG(5,("file path name %s vetoed\n",name));
 416                         errno = ENOENT;
 417                         return False;
 418                 }
 419         }
 420
 421         if (!lp_widelinks(SNUM(conn)) || !lp_symlinks(SNUM(conn))) {
 422                 ret = reduce_name(conn,name);
 423         }
 424
 425         if (!ret) {
 426                 DEBUG(5,("check_name on %s failed\n",name));
 427         }
 428
 429         return(ret);
 430 }
 431
 432 /****************************************************************************
 433  Scan a directory to find a filename, matching without case sensitivity.
 434  If the name looks like a mangled name then try via the mangling functions
 435 ****************************************************************************/
 436
 437 static BOOL scan_directory(const char *path, char *name, size_t maxlength,
 438                            connection_struct *conn,BOOL docache)
 439 {
 440         void *cur_dir;
 441         const char *dname;
 442         BOOL mangled;
 443
 444         mangled = mangle_is_mangled(name);
 445
 446         /* handle null paths */
 447         if (*path == 0)
 448                 path = ".";
 449
 450         if (docache && (dname = DirCacheCheck(path,name,SNUM(conn)))) {
 451                 safe_strcpy(name, dname, maxlength);
 452                 return(True);
 453         }
 454
 455         /*
 456          * The incoming name can be mangled, and if we de-mangle it
 457          * here it will not compare correctly against the filename (name2)
 458          * read from the directory and then mangled by the mangle_map()
 459          * call. We need to mangle both names or neither.
 460          * (JRA).
 461          */
 462         if (mangled)
 463                 mangled = !mangle_check_cache( name, maxlength );
 464
 465         /* open the directory */
 466         if (!(cur_dir = OpenDir(conn, path, True))) {
 467                 DEBUG(3,("scan dir didn't open dir [%s]\n",path));
 468                 return(False);
 469         }
 470
 471         /* now scan for matching names */
 472         while ((dname = ReadDirName(cur_dir))) {
 473
 474                 /* Is it dot or dot dot. */
 475                 if ((dname[0] == '.') && (!dname[1] || (dname[1] == '.' && !dname[2]))) {
 476                         continue;
 477                 }
 478
 479                 /*
 480                  * At this point dname is the unmangled name.
 481                  * name is either mangled or not, depending on the state of the "mangled"
 482                  * variable. JRA.
 483                  */
 484
 485                 /*
 486                  * Check mangled name against mangled name, or unmangled name
 487                  * against unmangled name.
 488                  */
 489
 490                 if ((mangled && mangled_equal(name,dname,SNUM(conn))) || fname_equal(name, dname, conn->case_sensitive)) {
 491                         /* we've found the file, change it's name and return */
 492                         if (docache)
 493                                 DirCacheAdd(path,name,dname,SNUM(conn));
 494                         safe_strcpy(name, dname, maxlength);
 495                         CloseDir(cur_dir);
 496                         return(True);
 497                 }
 498         }
 499
 500         CloseDir(cur_dir);
 501         errno = ENOENT;
 502         return(False);
 503 }