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