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