source3/smbd/dir.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Directory handling routines
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 2007
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22
  23 /*
  24    This module implements directory related functions for Samba.
  25 */
  26
  27 extern struct current_user current_user;
  28
  29 /* "Special" directory offsets. */
  30 #define END_OF_DIRECTORY_OFFSET ((long)-1)
  31 #define START_OF_DIRECTORY_OFFSET ((long)0)
  32 #define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
  33
  34 /* Make directory handle internals available. */
  35
  36 struct name_cache_entry {
  37         char *name;
  38         long offset;
  39 };
  40
  41 struct smb_Dir {
  42         connection_struct *conn;
  43         SMB_STRUCT_DIR *dir;
  44         long offset;
  45         char *dir_path;
  46         size_t name_cache_size;
  47         struct name_cache_entry *name_cache;
  48         unsigned int name_cache_index;
  49         unsigned int file_number;
  50 };
  51
  52 struct dptr_struct {
  53         struct dptr_struct *next, *prev;
  54         int dnum;
  55         uint16 spid;
  56         struct connection_struct *conn;
  57         struct smb_Dir *dir_hnd;
  58         bool expect_close;
  59         char *wcard;
  60         uint32 attr;
  61         char *path;
  62         bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
  63         bool did_stat; /* Optimisation for non-wcard searches. */
  64 };
  65
  66 static struct bitmap *dptr_bmap;
  67 static struct dptr_struct *dirptrs;
  68 static int dirhandles_open = 0;
  69
  70 #define INVALID_DPTR_KEY (-3)
  71
  72 /****************************************************************************
  73  Make a dir struct.
  74 ****************************************************************************/
  75
  76 bool make_dir_struct(TALLOC_CTX *ctx,
  77                         char *buf,
  78                         const char *mask,
  79                         const char *fname,
  80                         SMB_OFF_T size,
  81                         uint32 mode,
  82                         time_t date,
  83                         bool uc)
  84 {
  85         char *p;
  86         char *mask2 = talloc_strdup(ctx, mask);
  87
  88         if (!mask2) {
  89                 return False;
  90         }
  91
  92         if ((mode & aDIR) != 0) {
  93                 size = 0;
  94         }
  95
  96         memset(buf+1,' ',11);
  97         if ((p = strchr_m(mask2,'.')) != NULL) {
  98                 *p = 0;
  99                 push_ascii(buf+1,mask2,8, 0);
 100                 push_ascii(buf+9,p+1,3, 0);
 101                 *p = '.';
 102         } else {
 103                 push_ascii(buf+1,mask2,11, 0);
 104         }
 105
 106         memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
 107         SCVAL(buf,21,mode);
 108         srv_put_dos_date(buf,22,date);
 109         SSVAL(buf,26,size & 0xFFFF);
 110         SSVAL(buf,28,(size >> 16)&0xFFFF);
 111         /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
 112            Strange, but verified on W2K3. Needed for OS/2. JRA. */
 113         push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
 114         DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
 115         return True;
 116 }
 117
 118 /****************************************************************************
 119  Initialise the dir bitmap.
 120 ****************************************************************************/
 121
 122 void init_dptrs(void)
 123 {
 124         static bool dptrs_init=False;
 125
 126         if (dptrs_init)
 127                 return;
 128
 129         dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
 130
 131         if (!dptr_bmap)
 132                 exit_server("out of memory in init_dptrs");
 133
 134         dptrs_init = True;
 135 }
 136
 137 /****************************************************************************
 138  Idle a dptr - the directory is closed but the control info is kept.
 139 ****************************************************************************/
 140
 141 static void dptr_idle(struct dptr_struct *dptr)
 142 {
 143         if (dptr->dir_hnd) {
 144                 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
 145                 TALLOC_FREE(dptr->dir_hnd);
 146         }
 147 }
 148
 149 /****************************************************************************
 150  Idle the oldest dptr.
 151 ****************************************************************************/
 152
 153 static void dptr_idleoldest(void)
 154 {
 155         struct dptr_struct *dptr;
 156
 157         /*
 158          * Go to the end of the list.
 159          */
 160         for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
 161                 ;
 162
 163         if(!dptr) {
 164                 DEBUG(0,("No dptrs available to idle ?\n"));
 165                 return;
 166         }
 167
 168         /*
 169          * Idle the oldest pointer.
 170          */
 171
 172         for(; dptr; dptr = dptr->prev) {
 173                 if (dptr->dir_hnd) {
 174                         dptr_idle(dptr);
 175                         return;
 176                 }
 177         }
 178 }
 179
 180 /****************************************************************************
 181  Get the struct dptr_struct for a dir index.
 182 ****************************************************************************/
 183
 184 static struct dptr_struct *dptr_get(int key, bool forclose)
 185 {
 186         struct dptr_struct *dptr;
 187
 188         for(dptr = dirptrs; dptr; dptr = dptr->next) {
 189                 if(dptr->dnum == key) {
 190                         if (!forclose && !dptr->dir_hnd) {
 191                                 if (dirhandles_open >= MAX_OPEN_DIRECTORIES)
 192                                         dptr_idleoldest();
 193                                 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
 194                                 if (!(dptr->dir_hnd = OpenDir(
 195                                               NULL, dptr->conn, dptr->path,
 196                                               dptr->wcard, dptr->attr))) {
 197                                         DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
 198                                                 strerror(errno)));
 199                                         return False;
 200                                 }
 201                         }
 202                         DLIST_PROMOTE(dirptrs,dptr);
 203                         return dptr;
 204                 }
 205         }
 206         return(NULL);
 207 }
 208
 209 /****************************************************************************
 210  Get the dir path for a dir index.
 211 ****************************************************************************/
 212
 213 char *dptr_path(int key)
 214 {
 215         struct dptr_struct *dptr = dptr_get(key, False);
 216         if (dptr)
 217                 return(dptr->path);
 218         return(NULL);
 219 }
 220
 221 /****************************************************************************
 222  Get the dir wcard for a dir index.
 223 ****************************************************************************/
 224
 225 char *dptr_wcard(int key)
 226 {
 227         struct dptr_struct *dptr = dptr_get(key, False);
 228         if (dptr)
 229                 return(dptr->wcard);
 230         return(NULL);
 231 }
 232
 233 /****************************************************************************
 234  Get the dir attrib for a dir index.
 235 ****************************************************************************/
 236
 237 uint16 dptr_attr(int key)
 238 {
 239         struct dptr_struct *dptr = dptr_get(key, False);
 240         if (dptr)
 241                 return(dptr->attr);
 242         return(0);
 243 }
 244
 245 /****************************************************************************
 246  Close a dptr (internal func).
 247 ****************************************************************************/
 248
 249 static void dptr_close_internal(struct dptr_struct *dptr)
 250 {
 251         DEBUG(4,("closing dptr key %d\n",dptr->dnum));
 252
 253         DLIST_REMOVE(dirptrs, dptr);
 254
 255         /*
 256          * Free the dnum in the bitmap. Remember the dnum value is always
 257          * biased by one with respect to the bitmap.
 258          */
 259
 260         if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
 261                 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
 262                         dptr->dnum ));
 263         }
 264
 265         bitmap_clear(dptr_bmap, dptr->dnum - 1);
 266
 267         TALLOC_FREE(dptr->dir_hnd);
 268
 269         /* Lanman 2 specific code */
 270         SAFE_FREE(dptr->wcard);
 271         string_set(&dptr->path,"");
 272         SAFE_FREE(dptr);
 273 }
 274
 275 /****************************************************************************
 276  Close a dptr given a key.
 277 ****************************************************************************/
 278
 279 void dptr_close(int *key)
 280 {
 281         struct dptr_struct *dptr;
 282
 283         if(*key == INVALID_DPTR_KEY)
 284                 return;
 285
 286         /* OS/2 seems to use -1 to indicate "close all directories" */
 287         if (*key == -1) {
 288                 struct dptr_struct *next;
 289                 for(dptr = dirptrs; dptr; dptr = next) {
 290                         next = dptr->next;
 291                         dptr_close_internal(dptr);
 292                 }
 293                 *key = INVALID_DPTR_KEY;
 294                 return;
 295         }
 296
 297         dptr = dptr_get(*key, True);
 298
 299         if (!dptr) {
 300                 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
 301                 return;
 302         }
 303
 304         dptr_close_internal(dptr);
 305
 306         *key = INVALID_DPTR_KEY;
 307 }
 308
 309 /****************************************************************************
 310  Close all dptrs for a cnum.
 311 ****************************************************************************/
 312
 313 void dptr_closecnum(connection_struct *conn)
 314 {
 315         struct dptr_struct *dptr, *next;
 316         for(dptr = dirptrs; dptr; dptr = next) {
 317                 next = dptr->next;
 318                 if (dptr->conn == conn)
 319                         dptr_close_internal(dptr);
 320         }
 321 }
 322
 323 /****************************************************************************
 324  Idle all dptrs for a cnum.
 325 ****************************************************************************/
 326
 327 void dptr_idlecnum(connection_struct *conn)
 328 {
 329         struct dptr_struct *dptr;
 330         for(dptr = dirptrs; dptr; dptr = dptr->next) {
 331                 if (dptr->conn == conn && dptr->dir_hnd)
 332                         dptr_idle(dptr);
 333         }
 334 }
 335
 336 /****************************************************************************
 337  Close a dptr that matches a given path, only if it matches the spid also.
 338 ****************************************************************************/
 339
 340 void dptr_closepath(char *path,uint16 spid)
 341 {
 342         struct dptr_struct *dptr, *next;
 343         for(dptr = dirptrs; dptr; dptr = next) {
 344                 next = dptr->next;
 345                 if (spid == dptr->spid && strequal(dptr->path,path))
 346                         dptr_close_internal(dptr);
 347         }
 348 }
 349
 350 /****************************************************************************
 351  Try and close the oldest handle not marked for
 352  expect close in the hope that the client has
 353  finished with that one.
 354 ****************************************************************************/
 355
 356 static void dptr_close_oldest(bool old)
 357 {
 358         struct dptr_struct *dptr;
 359
 360         /*
 361          * Go to the end of the list.
 362          */
 363         for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
 364                 ;
 365
 366         if(!dptr) {
 367                 DEBUG(0,("No old dptrs available to close oldest ?\n"));
 368                 return;
 369         }
 370
 371         /*
 372          * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
 373          * does not have expect_close set. If 'old' is false, close
 374          * one of the new dnum handles.
 375          */
 376
 377         for(; dptr; dptr = dptr->prev) {
 378                 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
 379                         (!old && (dptr->dnum > 255))) {
 380                                 dptr_close_internal(dptr);
 381                                 return;
 382                 }
 383         }
 384 }
 385
 386 /****************************************************************************
 387  Create a new dir ptr. If the flag old_handle is true then we must allocate
 388  from the bitmap range 0 - 255 as old SMBsearch directory handles are only
 389  one byte long. If old_handle is false we allocate from the range
 390  256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
 391  a directory handle is never zero.
 392  wcard must not be zero.
 393 ****************************************************************************/
 394
 395 NTSTATUS dptr_create(connection_struct *conn, const char *path, bool old_handle, bool expect_close,uint16 spid,
 396                 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
 397 {
 398         struct dptr_struct *dptr = NULL;
 399         struct smb_Dir *dir_hnd;
 400         NTSTATUS status;
 401
 402         DEBUG(5,("dptr_create dir=%s\n", path));
 403
 404         if (!wcard) {
 405                 return NT_STATUS_INVALID_PARAMETER;
 406         }
 407
 408         status = check_name(conn,path);
 409         if (!NT_STATUS_IS_OK(status)) {
 410                 return status;
 411         }
 412
 413         dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
 414         if (!dir_hnd) {
 415                 return map_nt_error_from_unix(errno);
 416         }
 417
 418         string_set(&conn->dirpath,path);
 419
 420         if (dirhandles_open >= MAX_OPEN_DIRECTORIES) {
 421                 dptr_idleoldest();
 422         }
 423
 424         dptr = SMB_MALLOC_P(struct dptr_struct);
 425         if(!dptr) {
 426                 DEBUG(0,("malloc fail in dptr_create.\n"));
 427                 TALLOC_FREE(dir_hnd);
 428                 return NT_STATUS_NO_MEMORY;
 429         }
 430
 431         ZERO_STRUCTP(dptr);
 432
 433         if(old_handle) {
 434
 435                 /*
 436                  * This is an old-style SMBsearch request. Ensure the
 437                  * value we return will fit in the range 1-255.
 438                  */
 439
 440                 dptr->dnum = bitmap_find(dptr_bmap, 0);
 441
 442                 if(dptr->dnum == -1 || dptr->dnum > 254) {
 443
 444                         /*
 445                          * Try and close the oldest handle not marked for
 446                          * expect close in the hope that the client has
 447                          * finished with that one.
 448                          */
 449
 450                         dptr_close_oldest(True);
 451
 452                         /* Now try again... */
 453                         dptr->dnum = bitmap_find(dptr_bmap, 0);
 454                         if(dptr->dnum == -1 || dptr->dnum > 254) {
 455                                 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
 456                                 SAFE_FREE(dptr);
 457                                 TALLOC_FREE(dir_hnd);
 458                                 return NT_STATUS_TOO_MANY_OPENED_FILES;
 459                         }
 460                 }
 461         } else {
 462
 463                 /*
 464                  * This is a new-style trans2 request. Allocate from
 465                  * a range that will return 256 - MAX_DIRECTORY_HANDLES.
 466                  */
 467
 468                 dptr->dnum = bitmap_find(dptr_bmap, 255);
 469
 470                 if(dptr->dnum == -1 || dptr->dnum < 255) {
 471
 472                         /*
 473                          * Try and close the oldest handle close in the hope that
 474                          * the client has finished with that one. This will only
 475                          * happen in the case of the Win98 client bug where it leaks
 476                          * directory handles.
 477                          */
 478
 479                         dptr_close_oldest(False);
 480
 481                         /* Now try again... */
 482                         dptr->dnum = bitmap_find(dptr_bmap, 255);
 483
 484                         if(dptr->dnum == -1 || dptr->dnum < 255) {
 485                                 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
 486                                 SAFE_FREE(dptr);
 487                                 TALLOC_FREE(dir_hnd);
 488                                 return NT_STATUS_TOO_MANY_OPENED_FILES;
 489                         }
 490                 }
 491         }
 492
 493         bitmap_set(dptr_bmap, dptr->dnum);
 494
 495         dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
 496
 497         string_set(&dptr->path,path);
 498         dptr->conn = conn;
 499         dptr->dir_hnd = dir_hnd;
 500         dptr->spid = spid;
 501         dptr->expect_close = expect_close;
 502         dptr->wcard = SMB_STRDUP(wcard);
 503         if (!dptr->wcard) {
 504                 bitmap_clear(dptr_bmap, dptr->dnum - 1);
 505                 SAFE_FREE(dptr);
 506                 TALLOC_FREE(dir_hnd);
 507                 return NT_STATUS_NO_MEMORY;
 508         }
 509         if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
 510                 dptr->has_wild = True;
 511         } else {
 512                 dptr->has_wild = wcard_has_wild;
 513         }
 514
 515         dptr->attr = attr;
 516
 517         DLIST_ADD(dirptrs, dptr);
 518
 519         DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
 520                 dptr->dnum,path,expect_close));
 521
 522         *dptr_ret = dptr;
 523
 524         return NT_STATUS_OK;
 525 }
 526
 527
 528 /****************************************************************************
 529  Wrapper functions to access the lower level directory handles.
 530 ****************************************************************************/
 531
 532 int dptr_CloseDir(struct dptr_struct *dptr)
 533 {
 534         DLIST_REMOVE(dirptrs, dptr);
 535         TALLOC_FREE(dptr->dir_hnd);
 536         return 0;
 537 }
 538
 539 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
 540 {
 541         SeekDir(dptr->dir_hnd, offset);
 542 }
 543
 544 long dptr_TellDir(struct dptr_struct *dptr)
 545 {
 546         return TellDir(dptr->dir_hnd);
 547 }
 548
 549 bool dptr_has_wild(struct dptr_struct *dptr)
 550 {
 551         return dptr->has_wild;
 552 }
 553
 554 int dptr_dnum(struct dptr_struct *dptr)
 555 {
 556         return dptr->dnum;
 557 }
 558
 559 /****************************************************************************
 560  Return the next visible file name, skipping veto'd and invisible files.
 561 ****************************************************************************/
 562
 563 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr, long *poffset, SMB_STRUCT_STAT *pst)
 564 {
 565         /* Normal search for the next file. */
 566         const char *name;
 567         while ((name = ReadDirName(dptr->dir_hnd, poffset)) != NULL) {
 568                 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
 569                         return name;
 570                 }
 571         }
 572         return NULL;
 573 }
 574
 575 /****************************************************************************
 576  Return the next visible file name, skipping veto'd and invisible files.
 577 ****************************************************************************/
 578
 579 const char *dptr_ReadDirName(TALLOC_CTX *ctx,
 580                         struct dptr_struct *dptr,
 581                         long *poffset,
 582                         SMB_STRUCT_STAT *pst)
 583 {
 584         SET_STAT_INVALID(*pst);
 585
 586         if (dptr->has_wild) {
 587                 return dptr_normal_ReadDirName(dptr, poffset, pst);
 588         }
 589
 590         /* If poffset is -1 then we know we returned this name before and we have
 591            no wildcards. We're at the end of the directory. */
 592         if (*poffset == END_OF_DIRECTORY_OFFSET) {
 593                 return NULL;
 594         }
 595
 596         if (!dptr->did_stat) {
 597                 char *pathreal = NULL;
 598
 599                 /* We know the stored wcard contains no wildcard characters. See if we can match
 600                    with a stat call. If we can't, then set did_stat to true to
 601                    ensure we only do this once and keep searching. */
 602
 603                 dptr->did_stat = True;
 604
 605                 /* First check if it should be visible. */
 606                 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard, pst, True)) {
 607                         /* This only returns False if the file was found, but
 608                            is explicitly not visible. Set us to end of directory,
 609                            but return NULL as we know we can't ever find it. */
 610                         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 611                         return NULL;
 612                 }
 613
 614                 if (VALID_STAT(*pst)) {
 615                         /* We need to set the underlying dir_hnd offset to -1 also as
 616                            this function is usually called with the output from TellDir. */
 617                         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 618                         return dptr->wcard;
 619                 }
 620
 621                 pathreal = talloc_asprintf(ctx,
 622                                         "%s/%s",
 623                                         dptr->path,
 624                                         dptr->wcard);
 625                 if (!pathreal) {
 626                         return NULL;
 627                 }
 628
 629                 if (SMB_VFS_STAT(dptr->conn,pathreal,pst) == 0) {
 630                         /* We need to set the underlying dir_hnd offset to -1 also as
 631                            this function is usually called with the output from TellDir. */
 632                         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 633                         TALLOC_FREE(pathreal);
 634                         return dptr->wcard;
 635                 } else {
 636                         /* If we get any other error than ENOENT or ENOTDIR
 637                            then the file exists we just can't stat it. */
 638                         if (errno != ENOENT && errno != ENOTDIR) {
 639                                 /* We need to set the underlying dir_hdn offset to -1 also as
 640                                    this function is usually called with the output from TellDir. */
 641                                 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 642                                 TALLOC_FREE(pathreal);
 643                                 return dptr->wcard;
 644                         }
 645                 }
 646
 647                 TALLOC_FREE(pathreal);
 648
 649                 /* Stat failed. We know this is authoratiative if we are
 650                  * providing case sensitive semantics or the underlying
 651                  * filesystem is case sensitive.
 652                  */
 653
 654                 if (dptr->conn->case_sensitive ||
 655                     !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
 656                         /* We need to set the underlying dir_hnd offset to -1 also as
 657                            this function is usually called with the output from TellDir. */
 658                         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 659                         return NULL;
 660                 }
 661         }
 662         return dptr_normal_ReadDirName(dptr, poffset, pst);
 663 }
 664
 665 /****************************************************************************
 666  Search for a file by name, skipping veto'ed and not visible files.
 667 ****************************************************************************/
 668
 669 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
 670 {
 671         SET_STAT_INVALID(*pst);
 672
 673         if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
 674                 /* This is a singleton directory and we're already at the end. */
 675                 *poffset = END_OF_DIRECTORY_OFFSET;
 676                 return False;
 677         }
 678
 679         return SearchDir(dptr->dir_hnd, name, poffset);
 680 }
 681
 682 /****************************************************************************
 683  Add the name we're returning into the underlying cache.
 684 ****************************************************************************/
 685
 686 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
 687 {
 688         DirCacheAdd(dptr->dir_hnd, name, offset);
 689 }
 690
 691 /****************************************************************************
 692  Fill the 5 byte server reserved dptr field.
 693 ****************************************************************************/
 694
 695 bool dptr_fill(char *buf1,unsigned int key)
 696 {
 697         unsigned char *buf = (unsigned char *)buf1;
 698         struct dptr_struct *dptr = dptr_get(key, False);
 699         uint32 offset;
 700         if (!dptr) {
 701                 DEBUG(1,("filling null dirptr %d\n",key));
 702                 return(False);
 703         }
 704         offset = (uint32)TellDir(dptr->dir_hnd);
 705         DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
 706                 (long)dptr->dir_hnd,(int)offset));
 707         buf[0] = key;
 708         SIVAL(buf,1,offset);
 709         return(True);
 710 }
 711
 712 /****************************************************************************
 713  Fetch the dir ptr and seek it given the 5 byte server field.
 714 ****************************************************************************/
 715
 716 struct dptr_struct *dptr_fetch(char *buf,int *num)
 717 {
 718         unsigned int key = *(unsigned char *)buf;
 719         struct dptr_struct *dptr = dptr_get(key, False);
 720         uint32 offset;
 721         long seekoff;
 722
 723         if (!dptr) {
 724                 DEBUG(3,("fetched null dirptr %d\n",key));
 725                 return(NULL);
 726         }
 727         *num = key;
 728         offset = IVAL(buf,1);
 729         if (offset == (uint32)-1) {
 730                 seekoff = END_OF_DIRECTORY_OFFSET;
 731         } else {
 732                 seekoff = (long)offset;
 733         }
 734         SeekDir(dptr->dir_hnd,seekoff);
 735         DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
 736                 key,dptr_path(key),(int)seekoff));
 737         return(dptr);
 738 }
 739
 740 /****************************************************************************
 741  Fetch the dir ptr.
 742 ****************************************************************************/
 743
 744 struct dptr_struct *dptr_fetch_lanman2(int dptr_num)
 745 {
 746         struct dptr_struct *dptr  = dptr_get(dptr_num, False);
 747
 748         if (!dptr) {
 749                 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
 750                 return(NULL);
 751         }
 752         DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
 753         return(dptr);
 754 }
 755
 756 /****************************************************************************
 757  Check that a file matches a particular file type.
 758 ****************************************************************************/
 759
 760 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
 761 {
 762         uint32 mask;
 763
 764         /* Check the "may have" search bits. */
 765         if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
 766                 return False;
 767
 768         /* Check the "must have" bits, which are the may have bits shifted eight */
 769         /* If must have bit is set, the file/dir can not be returned in search unless the matching
 770                 file attribute is set */
 771         mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
 772         if(mask) {
 773                 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask)   /* check if matching attribute present */
 774                         return True;
 775                 else
 776                         return False;
 777         }
 778
 779         return True;
 780 }
 781
 782 static bool mangle_mask_match(connection_struct *conn,
 783                 const char *filename,
 784                 const char *mask)
 785 {
 786         char mname[13];
 787
 788         if (!name_to_8_3(filename,mname,False,conn->params)) {
 789                 return False;
 790         }
 791         return mask_match_search(mname,mask,False);
 792 }
 793
 794 /****************************************************************************
 795  Get an 8.3 directory entry.
 796 ****************************************************************************/
 797
 798 bool get_dir_entry(TALLOC_CTX *ctx,
 799                 connection_struct *conn,
 800                 const char *mask,
 801                 uint32 dirtype,
 802                 char **pp_fname_out,
 803                 SMB_OFF_T *size,
 804                 uint32 *mode,
 805                 time_t *date,
 806                 bool check_descend,
 807                 bool ask_sharemode)
 808 {
 809         const char *dname = NULL;
 810         bool found = False;
 811         SMB_STRUCT_STAT sbuf;
 812         char *pathreal = NULL;
 813         const char *filename = NULL;
 814         bool needslash;
 815
 816         *pp_fname_out = NULL;
 817
 818         needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
 819
 820         if (!conn->dirptr) {
 821                 return(False);
 822         }
 823
 824         while (!found) {
 825                 long curoff = dptr_TellDir(conn->dirptr);
 826                 dname = dptr_ReadDirName(ctx, conn->dirptr, &curoff, &sbuf);
 827
 828                 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
 829                         (long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
 830
 831                 if (dname == NULL) {
 832                         return(False);
 833                 }
 834
 835                 filename = dname;
 836
 837                 /* notice the special *.* handling. This appears to be the only difference
 838                         between the wildcard handling in this routine and in the trans2 routines.
 839                         see masktest for a demo
 840                 */
 841                 if ((strcmp(mask,"*.*") == 0) ||
 842                     mask_match_search(filename,mask,False) ||
 843                     mangle_mask_match(conn,filename,mask)) {
 844                         char mname[13];
 845
 846                         if (!mangle_is_8_3(filename, False, conn->params)) {
 847                                 if (!name_to_8_3(filename,mname,False,
 848                                            conn->params)) {
 849                                         continue;
 850                                 }
 851                                 filename = mname;
 852                         }
 853
 854                         if (needslash) {
 855                                 pathreal = talloc_asprintf(ctx,
 856                                                 "%s/%s",
 857                                                 conn->dirpath,
 858                                                 dname);
 859                         } else {
 860                                 pathreal = talloc_asprintf(ctx,
 861                                                 "%s%s",
 862                                                 conn->dirpath,
 863                                                 dname);
 864                         }
 865                         if (!pathreal) {
 866                                 return False;
 867                         }
 868
 869                         if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn, pathreal, &sbuf)) != 0) {
 870                                 DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",
 871                                         pathreal, strerror(errno) ));
 872                                 TALLOC_FREE(pathreal);
 873                                 continue;
 874                         }
 875
 876                         *mode = dos_mode(conn,pathreal,&sbuf);
 877
 878                         if (!dir_check_ftype(conn,*mode,dirtype)) {
 879                                 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
 880                                 TALLOC_FREE(pathreal);
 881                                 continue;
 882                         }
 883
 884                         *size = sbuf.st_size;
 885                         *date = sbuf.st_mtime;
 886
 887                         if (ask_sharemode) {
 888                                 struct timespec write_time_ts;
 889                                 struct file_id fileid;
 890
 891                                 fileid = vfs_file_id_from_sbuf(conn, &sbuf);
 892                                 get_file_infos(fileid, NULL, &write_time_ts);
 893                                 if (!null_timespec(write_time_ts)) {
 894                                         *date = convert_timespec_to_time_t(write_time_ts);
 895                                 }
 896                         }
 897
 898                         DEBUG(3,("get_dir_entry mask=[%s] found %s "
 899                                 "fname=%s (%s)\n",
 900                                 mask,
 901                                 pathreal,
 902                                 dname,
 903                                 filename));
 904
 905                         found = True;
 906
 907                         *pp_fname_out = talloc_strdup(ctx, filename);
 908                         if (!*pp_fname_out) {
 909                                 return False;
 910                         }
 911
 912                         DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
 913                         TALLOC_FREE(pathreal);
 914                 }
 915         }
 916
 917         return(found);
 918 }
 919
 920 /*******************************************************************
 921  Check to see if a user can read a file. This is only approximate,
 922  it is used as part of the "hide unreadable" option. Don't
 923  use it for anything security sensitive.
 924 ********************************************************************/
 925
 926 static bool user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
 927 {
 928         /*
 929          * If user is a member of the Admin group
 930          * we never hide files from them.
 931          */
 932
 933         if (conn->admin_user) {
 934                 return True;
 935         }
 936
 937         SMB_ASSERT(VALID_STAT(*pst));
 938
 939         return can_access_file_acl(conn, name, pst, FILE_READ_DATA);
 940 }
 941
 942 /*******************************************************************
 943  Check to see if a user can write a file (and only files, we do not
 944  check dirs on this one). This is only approximate,
 945  it is used as part of the "hide unwriteable" option. Don't
 946  use it for anything security sensitive.
 947 ********************************************************************/
 948
 949 static bool user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
 950 {
 951         /*
 952          * If user is a member of the Admin group
 953          * we never hide files from them.
 954          */
 955
 956         if (conn->admin_user) {
 957                 return True;
 958         }
 959
 960         SMB_ASSERT(VALID_STAT(*pst));
 961
 962         /* Pseudo-open the file */
 963
 964         if(S_ISDIR(pst->st_mode)) {
 965                 return True;
 966         }
 967
 968         return can_write_to_file(conn, name, pst);
 969 }
 970
 971 /*******************************************************************
 972   Is a file a "special" type ?
 973 ********************************************************************/
 974
 975 static bool file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
 976 {
 977         /*
 978          * If user is a member of the Admin group
 979          * we never hide files from them.
 980          */
 981
 982         if (conn->admin_user)
 983                 return False;
 984
 985         SMB_ASSERT(VALID_STAT(*pst));
 986
 987         if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
 988                 return False;
 989
 990         return True;
 991 }
 992
 993 /*******************************************************************
 994  Should the file be seen by the client ? NOTE: A successful return
 995  is no guarantee of the file's existence ... you also have to check
 996  whether pst is valid.
 997 ********************************************************************/
 998
 999 bool is_visible_file(connection_struct *conn, const char *dir_path, const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1000 {
1001         bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1002         bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1003         bool hide_special = lp_hide_special_files(SNUM(conn));
1004
1005         SET_STAT_INVALID(*pst);
1006
1007         if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1008                 return True; /* . and .. are always visible. */
1009         }
1010
1011         /* If it's a vetoed file, pretend it doesn't even exist */
1012         if (use_veto && IS_VETO_PATH(conn, name)) {
1013                 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1014                 return False;
1015         }
1016
1017         if (hide_unreadable || hide_unwriteable || hide_special) {
1018                 char *entry = NULL;
1019
1020                 if (asprintf(&entry, "%s/%s", dir_path, name) == -1) {
1021                         return False;
1022                 }
1023
1024                 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1025                 if (lp_host_msdfs() &&
1026                                 lp_msdfs_root(SNUM(conn)) &&
1027                                 is_msdfs_link(conn, entry, NULL)) {
1028                         SAFE_FREE(entry);
1029                         return True;
1030                 }
1031
1032                 /* If the file name does not exist, there's no point checking
1033                  * the configuration options. We succeed, on the basis that the
1034                  * checks *might* have passed if the file was present.
1035                  */
1036                 if (SMB_VFS_STAT(conn, entry, pst) != 0) {
1037                         SAFE_FREE(entry);
1038                         return True;
1039                 }
1040
1041                 /* Honour _hide unreadable_ option */
1042                 if (hide_unreadable && !user_can_read_file(conn, entry, pst)) {
1043                         DEBUG(10,("is_visible_file: file %s is unreadable.\n", entry ));
1044                         SAFE_FREE(entry);
1045                         return False;
1046                 }
1047                 /* Honour _hide unwriteable_ option */
1048                 if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
1049                         DEBUG(10,("is_visible_file: file %s is unwritable.\n", entry ));
1050                         SAFE_FREE(entry);
1051                         return False;
1052                 }
1053                 /* Honour _hide_special_ option */
1054                 if (hide_special && file_is_special(conn, entry, pst)) {
1055                         DEBUG(10,("is_visible_file: file %s is special.\n", entry ));
1056                         SAFE_FREE(entry);
1057                         return False;
1058                 }
1059                 SAFE_FREE(entry);
1060         }
1061         return True;
1062 }
1063
1064 static int smb_Dir_destructor(struct smb_Dir *dirp)
1065 {
1066         if (dirp->dir) {
1067                 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1068         }
1069         dirhandles_open--;
1070         return 0;
1071 }
1072
1073 /*******************************************************************
1074  Open a directory.
1075 ********************************************************************/
1076
1077 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1078                         const char *name, const char *mask, uint32 attr)
1079 {
1080         struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1081
1082         if (!dirp) {
1083                 return NULL;
1084         }
1085
1086         dirp->conn = conn;
1087         dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1088
1089         dirp->dir_path = talloc_strdup(dirp, name);
1090         if (!dirp->dir_path) {
1091                 goto fail;
1092         }
1093
1094         dirhandles_open++;
1095         talloc_set_destructor(dirp, smb_Dir_destructor);
1096
1097         dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1098         if (!dirp->dir) {
1099                 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1100                          strerror(errno) ));
1101                 goto fail;
1102         }
1103
1104         return dirp;
1105
1106   fail:
1107         TALLOC_FREE(dirp);
1108         return NULL;
1109 }
1110
1111 /*******************************************************************
1112  Read from a directory. Also return current offset.
1113  Don't check for veto or invisible files.
1114 ********************************************************************/
1115
1116 const char *ReadDirName(struct smb_Dir *dirp, long *poffset)
1117 {
1118         const char *n;
1119         connection_struct *conn = dirp->conn;
1120
1121         /* Cheat to allow . and .. to be the first entries returned. */
1122         if (((*poffset == START_OF_DIRECTORY_OFFSET) || (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2)) {
1123                 if (dirp->file_number == 0) {
1124                         n = ".";
1125                         *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1126                 } else {
1127                         *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1128                         n = "..";
1129                 }
1130                 dirp->file_number++;
1131                 return n;
1132         } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1133                 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1134                 return NULL;
1135         } else {
1136                 /* A real offset, seek to it. */
1137                 SeekDir(dirp, *poffset);
1138         }
1139
1140         while ((n = vfs_readdirname(conn, dirp->dir))) {
1141                 /* Ignore . and .. - we've already returned them. */
1142                 if (*n == '.') {
1143                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1144                                 continue;
1145                         }
1146                 }
1147                 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1148                 dirp->file_number++;
1149                 return n;
1150         }
1151         *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1152         return NULL;
1153 }
1154
1155 /*******************************************************************
1156  Rewind to the start.
1157 ********************************************************************/
1158
1159 void RewindDir(struct smb_Dir *dirp, long *poffset)
1160 {
1161         SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1162         dirp->file_number = 0;
1163         dirp->offset = START_OF_DIRECTORY_OFFSET;
1164         *poffset = START_OF_DIRECTORY_OFFSET;
1165 }
1166
1167 /*******************************************************************
1168  Seek a dir.
1169 ********************************************************************/
1170
1171 void SeekDir(struct smb_Dir *dirp, long offset)
1172 {
1173         if (offset != dirp->offset) {
1174                 if (offset == START_OF_DIRECTORY_OFFSET) {
1175                         RewindDir(dirp, &offset);
1176                         /*
1177                          * Ok we should really set the file number here
1178                          * to 1 to enable ".." to be returned next. Trouble
1179                          * is I'm worried about callers using SeekDir(dirp,0)
1180                          * as equivalent to RewindDir(). So leave this alone
1181                          * for now.
1182                          */
1183                 } else if  (offset == DOT_DOT_DIRECTORY_OFFSET) {
1184                         RewindDir(dirp, &offset);
1185                         /*
1186                          * Set the file number to 2 - we want to get the first
1187                          * real file entry (the one we return after "..")
1188                          * on the next ReadDir.
1189                          */
1190                         dirp->file_number = 2;
1191                 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1192                         ; /* Don't seek in this case. */
1193                 } else {
1194                         SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1195                 }
1196                 dirp->offset = offset;
1197         }
1198 }
1199
1200 /*******************************************************************
1201  Tell a dir position.
1202 ********************************************************************/
1203
1204 long TellDir(struct smb_Dir *dirp)
1205 {
1206         return(dirp->offset);
1207 }
1208
1209 /*******************************************************************
1210  Add an entry into the dcache.
1211 ********************************************************************/
1212
1213 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1214 {
1215         struct name_cache_entry *e;
1216
1217         if (dirp->name_cache_size == 0) {
1218                 return;
1219         }
1220
1221         if (dirp->name_cache == NULL) {
1222                 dirp->name_cache = TALLOC_ZERO_ARRAY(
1223                         dirp, struct name_cache_entry, dirp->name_cache_size);
1224
1225                 if (dirp->name_cache == NULL) {
1226                         return;
1227                 }
1228         }
1229
1230         dirp->name_cache_index = (dirp->name_cache_index+1) %
1231                                         dirp->name_cache_size;
1232         e = &dirp->name_cache[dirp->name_cache_index];
1233         TALLOC_FREE(e->name);
1234         e->name = talloc_strdup(dirp, name);
1235         e->offset = offset;
1236 }
1237
1238 /*******************************************************************
1239  Find an entry by name. Leave us at the offset after it.
1240  Don't check for veto or invisible files.
1241 ********************************************************************/
1242
1243 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1244 {
1245         int i;
1246         const char *entry;
1247         connection_struct *conn = dirp->conn;
1248
1249         /* Search back in the name cache. */
1250         if (dirp->name_cache_size && dirp->name_cache) {
1251                 for (i = dirp->name_cache_index; i >= 0; i--) {
1252                         struct name_cache_entry *e = &dirp->name_cache[i];
1253                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1254                                 *poffset = e->offset;
1255                                 SeekDir(dirp, e->offset);
1256                                 return True;
1257                         }
1258                 }
1259                 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1260                         struct name_cache_entry *e = &dirp->name_cache[i];
1261                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1262                                 *poffset = e->offset;
1263                                 SeekDir(dirp, e->offset);
1264                                 return True;
1265                         }
1266                 }
1267         }
1268
1269         /* Not found in the name cache. Rewind directory and start from scratch. */
1270         SMB_VFS_REWINDDIR(conn, dirp->dir);
1271         dirp->file_number = 0;
1272         *poffset = START_OF_DIRECTORY_OFFSET;
1273         while ((entry = ReadDirName(dirp, poffset))) {
1274                 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1275                         return True;
1276                 }
1277         }
1278         return False;
1279 }
1280
1281 /*****************************************************************
1282  Is this directory empty ?
1283 *****************************************************************/
1284
1285 NTSTATUS can_delete_directory(struct connection_struct *conn,
1286                                 const char *dirname)
1287 {
1288         NTSTATUS status = NT_STATUS_OK;
1289         long dirpos = 0;
1290         const char *dname;
1291         struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
1292                                           NULL, 0);
1293
1294         if (!dir_hnd) {
1295                 return map_nt_error_from_unix(errno);
1296         }
1297
1298         while ((dname = ReadDirName(dir_hnd,&dirpos))) {
1299                 SMB_STRUCT_STAT st;
1300
1301                 /* Quick check for "." and ".." */
1302                 if (dname[0] == '.') {
1303                         if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1304                                 continue;
1305                         }
1306                 }
1307
1308                 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1309                         continue;
1310                 }
1311
1312                 DEBUG(10,("can_delete_directory: got name %s - can't delete\n", dname ));
1313                 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1314                 break;
1315         }
1316         TALLOC_FREE(dir_hnd);
1317
1318         return status;
1319 }