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 const char *dptr_ReadDirName(TALLOC_CTX *ctx,
 573                         struct dptr_struct *dptr,
 574                         long *poffset,
 575                         SMB_STRUCT_STAT *pst)
 576 {
 577         char *name = NULL;
 578         char *pathreal = NULL;
 579         char *found_name = NULL;
 580         int ret;
 581
 582         SET_STAT_INVALID(*pst);
 583
 584         if (dptr->has_wild || dptr->did_stat) {
 585                 return dptr_normal_ReadDirName(dptr, poffset, pst);
 586         }
 587
 588         /* If poffset is -1 then we know we returned this name before and we
 589          * have no wildcards. We're at the end of the directory. */
 590         if (*poffset == END_OF_DIRECTORY_OFFSET) {
 591                 return NULL;
 592         }
 593
 594         /* We know the stored wcard contains no wildcard characters.
 595          * See if we can match with a stat call. If we can't, then set
 596          * did_stat to true to ensure we only do this once and keep
 597          * searching. */
 598
 599         dptr->did_stat = true;
 600
 601         /* First check if it should be visible. */
 602         if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
 603             pst, true))
 604         {
 605                 /* This only returns false if the file was found, but
 606                    is explicitly not visible. Set us to end of
 607                    directory, but return NULL as we know we can't ever
 608                    find it. */
 609                 goto ret;
 610         }
 611
 612         if (VALID_STAT(*pst)) {
 613                 name = dptr->wcard;
 614                 goto ret;
 615         }
 616
 617         pathreal = talloc_asprintf(ctx,
 618                                 "%s/%s",
 619                                 dptr->path,
 620                                 dptr->wcard);
 621         if (!pathreal)
 622                 return NULL;
 623
 624         if (SMB_VFS_STAT(dptr->conn, pathreal, pst) == 0) {
 625                 name = dptr->wcard;
 626                 goto clean;
 627         } else {
 628                 /* If we get any other error than ENOENT or ENOTDIR
 629                    then the file exists we just can't stat it. */
 630                 if (errno != ENOENT && errno != ENOTDIR) {
 631                         name = dptr->wcard;
 632                         goto clean;
 633                 }
 634         }
 635
 636         /* Stat failed. We know this is authoratiative if we are
 637          * providing case sensitive semantics or the underlying
 638          * filesystem is case sensitive.
 639          */
 640         if (dptr->conn->case_sensitive ||
 641             !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
 642         {
 643                 goto clean;
 644         }
 645
 646         /*
 647          * Try case-insensitive stat if the fs has the ability. This avoids
 648          * scanning the whole directory.
 649          */
 650         ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
 651                                         ctx, &found_name);
 652         if (ret == 0) {
 653                 name = found_name;
 654                 goto clean;
 655         } else if (errno == ENOENT) {
 656                 /* The case-insensitive lookup was authoritative. */
 657                 goto clean;
 658         }
 659
 660         TALLOC_FREE(pathreal);
 661
 662         return dptr_normal_ReadDirName(dptr, poffset, pst);
 663
 664 clean:
 665         TALLOC_FREE(pathreal);
 666 ret:
 667         /* We need to set the underlying dir_hnd offset to -1
 668          * also as this function is usually called with the
 669          * output from TellDir. */
 670         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 671         return name;
 672 }
 673
 674 /****************************************************************************
 675  Search for a file by name, skipping veto'ed and not visible files.
 676 ****************************************************************************/
 677
 678 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
 679 {
 680         SET_STAT_INVALID(*pst);
 681
 682         if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
 683                 /* This is a singleton directory and we're already at the end. */
 684                 *poffset = END_OF_DIRECTORY_OFFSET;
 685                 return False;
 686         }
 687
 688         return SearchDir(dptr->dir_hnd, name, poffset);
 689 }
 690
 691 /****************************************************************************
 692  Add the name we're returning into the underlying cache.
 693 ****************************************************************************/
 694
 695 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
 696 {
 697         DirCacheAdd(dptr->dir_hnd, name, offset);
 698 }
 699
 700 /****************************************************************************
 701  Initialize variables & state data at the beginning of all search SMB requests.
 702 ****************************************************************************/
 703 void dptr_init_search_op(struct dptr_struct *dptr)
 704 {
 705         SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
 706 }
 707
 708 /****************************************************************************
 709  Fill the 5 byte server reserved dptr field.
 710 ****************************************************************************/
 711
 712 bool dptr_fill(char *buf1,unsigned int key)
 713 {
 714         unsigned char *buf = (unsigned char *)buf1;
 715         struct dptr_struct *dptr = dptr_get(key, False);
 716         uint32 offset;
 717         if (!dptr) {
 718                 DEBUG(1,("filling null dirptr %d\n",key));
 719                 return(False);
 720         }
 721         offset = (uint32)TellDir(dptr->dir_hnd);
 722         DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
 723                 (long)dptr->dir_hnd,(int)offset));
 724         buf[0] = key;
 725         SIVAL(buf,1,offset);
 726         return(True);
 727 }
 728
 729 /****************************************************************************
 730  Fetch the dir ptr and seek it given the 5 byte server field.
 731 ****************************************************************************/
 732
 733 struct dptr_struct *dptr_fetch(char *buf,int *num)
 734 {
 735         unsigned int key = *(unsigned char *)buf;
 736         struct dptr_struct *dptr = dptr_get(key, False);
 737         uint32 offset;
 738         long seekoff;
 739
 740         if (!dptr) {
 741                 DEBUG(3,("fetched null dirptr %d\n",key));
 742                 return(NULL);
 743         }
 744         *num = key;
 745         offset = IVAL(buf,1);
 746         if (offset == (uint32)-1) {
 747                 seekoff = END_OF_DIRECTORY_OFFSET;
 748         } else {
 749                 seekoff = (long)offset;
 750         }
 751         SeekDir(dptr->dir_hnd,seekoff);
 752         DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
 753                 key,dptr_path(key),(int)seekoff));
 754         return(dptr);
 755 }
 756
 757 /****************************************************************************
 758  Fetch the dir ptr.
 759 ****************************************************************************/
 760
 761 struct dptr_struct *dptr_fetch_lanman2(int dptr_num)
 762 {
 763         struct dptr_struct *dptr  = dptr_get(dptr_num, False);
 764
 765         if (!dptr) {
 766                 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
 767                 return(NULL);
 768         }
 769         DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
 770         return(dptr);
 771 }
 772
 773 /****************************************************************************
 774  Check that a file matches a particular file type.
 775 ****************************************************************************/
 776
 777 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
 778 {
 779         uint32 mask;
 780
 781         /* Check the "may have" search bits. */
 782         if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
 783                 return False;
 784
 785         /* Check the "must have" bits, which are the may have bits shifted eight */
 786         /* If must have bit is set, the file/dir can not be returned in search unless the matching
 787                 file attribute is set */
 788         mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
 789         if(mask) {
 790                 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask)   /* check if matching attribute present */
 791                         return True;
 792                 else
 793                         return False;
 794         }
 795
 796         return True;
 797 }
 798
 799 static bool mangle_mask_match(connection_struct *conn,
 800                 const char *filename,
 801                 const char *mask)
 802 {
 803         char mname[13];
 804
 805         if (!name_to_8_3(filename,mname,False,conn->params)) {
 806                 return False;
 807         }
 808         return mask_match_search(mname,mask,False);
 809 }
 810
 811 /****************************************************************************
 812  Get an 8.3 directory entry.
 813 ****************************************************************************/
 814
 815 bool get_dir_entry(TALLOC_CTX *ctx,
 816                 connection_struct *conn,
 817                 const char *mask,
 818                 uint32 dirtype,
 819                 char **pp_fname_out,
 820                 SMB_OFF_T *size,
 821                 uint32 *mode,
 822                 time_t *date,
 823                 bool check_descend,
 824                 bool ask_sharemode)
 825 {
 826         const char *dname = NULL;
 827         bool found = False;
 828         SMB_STRUCT_STAT sbuf;
 829         char *pathreal = NULL;
 830         const char *filename = NULL;
 831         bool needslash;
 832
 833         *pp_fname_out = NULL;
 834
 835         needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
 836
 837         if (!conn->dirptr) {
 838                 return(False);
 839         }
 840
 841         while (!found) {
 842                 long curoff = dptr_TellDir(conn->dirptr);
 843                 dname = dptr_ReadDirName(ctx, conn->dirptr, &curoff, &sbuf);
 844
 845                 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
 846                         (long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
 847
 848                 if (dname == NULL) {
 849                         return(False);
 850                 }
 851
 852                 filename = dname;
 853
 854                 /* notice the special *.* handling. This appears to be the only difference
 855                         between the wildcard handling in this routine and in the trans2 routines.
 856                         see masktest for a demo
 857                 */
 858                 if ((strcmp(mask,"*.*") == 0) ||
 859                     mask_match_search(filename,mask,False) ||
 860                     mangle_mask_match(conn,filename,mask)) {
 861                         char mname[13];
 862
 863                         if (!mangle_is_8_3(filename, False, conn->params)) {
 864                                 if (!name_to_8_3(filename,mname,False,
 865                                            conn->params)) {
 866                                         continue;
 867                                 }
 868                                 filename = mname;
 869                         }
 870
 871                         if (needslash) {
 872                                 pathreal = talloc_asprintf(ctx,
 873                                                 "%s/%s",
 874                                                 conn->dirpath,
 875                                                 dname);
 876                         } else {
 877                                 pathreal = talloc_asprintf(ctx,
 878                                                 "%s%s",
 879                                                 conn->dirpath,
 880                                                 dname);
 881                         }
 882                         if (!pathreal) {
 883                                 return False;
 884                         }
 885
 886                         if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn, pathreal, &sbuf)) != 0) {
 887                                 DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",
 888                                         pathreal, strerror(errno) ));
 889                                 TALLOC_FREE(pathreal);
 890                                 continue;
 891                         }
 892
 893                         *mode = dos_mode(conn,pathreal,&sbuf);
 894
 895                         if (!dir_check_ftype(conn,*mode,dirtype)) {
 896                                 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
 897                                 TALLOC_FREE(pathreal);
 898                                 continue;
 899                         }
 900
 901                         *size = sbuf.st_size;
 902                         *date = sbuf.st_mtime;
 903
 904                         if (ask_sharemode) {
 905                                 struct timespec write_time_ts;
 906                                 struct file_id fileid;
 907
 908                                 fileid = vfs_file_id_from_sbuf(conn, &sbuf);
 909                                 get_file_infos(fileid, NULL, &write_time_ts);
 910                                 if (!null_timespec(write_time_ts)) {
 911                                         *date = convert_timespec_to_time_t(write_time_ts);
 912                                 }
 913                         }
 914
 915                         DEBUG(3,("get_dir_entry mask=[%s] found %s "
 916                                 "fname=%s (%s)\n",
 917                                 mask,
 918                                 pathreal,
 919                                 dname,
 920                                 filename));
 921
 922                         found = True;
 923
 924                         *pp_fname_out = talloc_strdup(ctx, filename);
 925                         if (!*pp_fname_out) {
 926                                 return False;
 927                         }
 928
 929                         DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
 930                         TALLOC_FREE(pathreal);
 931                 }
 932         }
 933
 934         return(found);
 935 }
 936
 937 /*******************************************************************
 938  Check to see if a user can read a file. This is only approximate,
 939  it is used as part of the "hide unreadable" option. Don't
 940  use it for anything security sensitive.
 941 ********************************************************************/
 942
 943 static bool user_can_read_file(connection_struct *conn, char *name)
 944 {
 945         /*
 946          * If user is a member of the Admin group
 947          * we never hide files from them.
 948          */
 949
 950         if (conn->admin_user) {
 951                 return True;
 952         }
 953
 954         return can_access_file_acl(conn, name, FILE_READ_DATA);
 955 }
 956
 957 /*******************************************************************
 958  Check to see if a user can write a file (and only files, we do not
 959  check dirs on this one). This is only approximate,
 960  it is used as part of the "hide unwriteable" option. Don't
 961  use it for anything security sensitive.
 962 ********************************************************************/
 963
 964 static bool user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
 965 {
 966         /*
 967          * If user is a member of the Admin group
 968          * we never hide files from them.
 969          */
 970
 971         if (conn->admin_user) {
 972                 return True;
 973         }
 974
 975         SMB_ASSERT(VALID_STAT(*pst));
 976
 977         /* Pseudo-open the file */
 978
 979         if(S_ISDIR(pst->st_mode)) {
 980                 return True;
 981         }
 982
 983         return can_write_to_file(conn, name, pst);
 984 }
 985
 986 /*******************************************************************
 987   Is a file a "special" type ?
 988 ********************************************************************/
 989
 990 static bool file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
 991 {
 992         /*
 993          * If user is a member of the Admin group
 994          * we never hide files from them.
 995          */
 996
 997         if (conn->admin_user)
 998                 return False;
 999
1000         SMB_ASSERT(VALID_STAT(*pst));
1001
1002         if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
1003                 return False;
1004
1005         return True;
1006 }
1007
1008 /*******************************************************************
1009  Should the file be seen by the client?
1010  NOTE: A successful return is no guarantee of the file's existence.
1011 ********************************************************************/
1012
1013 bool is_visible_file(connection_struct *conn, const char *dir_path,
1014                      const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1015 {
1016         bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1017         bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1018         bool hide_special = lp_hide_special_files(SNUM(conn));
1019
1020         if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1021                 return True; /* . and .. are always visible. */
1022         }
1023
1024         /* If it's a vetoed file, pretend it doesn't even exist */
1025         if (use_veto && IS_VETO_PATH(conn, name)) {
1026                 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1027                 return False;
1028         }
1029
1030         if (hide_unreadable || hide_unwriteable || hide_special) {
1031                 char *entry = NULL;
1032
1033                 if (asprintf(&entry, "%s/%s", dir_path, name) == -1) {
1034                         return False;
1035                 }
1036
1037                 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1038                 if (lp_host_msdfs() &&
1039                                 lp_msdfs_root(SNUM(conn)) &&
1040                                 is_msdfs_link(conn, entry, NULL)) {
1041                         SAFE_FREE(entry);
1042                         return True;
1043                 }
1044
1045                 /* If the file name does not exist, there's no point checking
1046                  * the configuration options. We succeed, on the basis that the
1047                  * checks *might* have passed if the file was present.
1048                  */
1049                 if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, entry, pst) != 0))
1050                 {
1051                         SAFE_FREE(entry);
1052                         return True;
1053                 }
1054
1055                 /* Honour _hide unreadable_ option */
1056                 if (hide_unreadable && !user_can_read_file(conn, entry)) {
1057                         DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1058                                  entry ));
1059                         SAFE_FREE(entry);
1060                         return False;
1061                 }
1062                 /* Honour _hide unwriteable_ option */
1063                 if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
1064                         DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1065                                  entry ));
1066                         SAFE_FREE(entry);
1067                         return False;
1068                 }
1069                 /* Honour _hide_special_ option */
1070                 if (hide_special && file_is_special(conn, entry, pst)) {
1071                         DEBUG(10,("is_visible_file: file %s is special.\n",
1072                                  entry ));
1073                         SAFE_FREE(entry);
1074                         return False;
1075                 }
1076                 SAFE_FREE(entry);
1077         }
1078         return True;
1079 }
1080
1081 static int smb_Dir_destructor(struct smb_Dir *dirp)
1082 {
1083         if (dirp->dir) {
1084                 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1085         }
1086         dirhandles_open--;
1087         return 0;
1088 }
1089
1090 /*******************************************************************
1091  Open a directory.
1092 ********************************************************************/
1093
1094 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1095                         const char *name, const char *mask, uint32 attr)
1096 {
1097         struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1098
1099         if (!dirp) {
1100                 return NULL;
1101         }
1102
1103         dirp->conn = conn;
1104         dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1105
1106         dirp->dir_path = talloc_strdup(dirp, name);
1107         if (!dirp->dir_path) {
1108                 errno = ENOMEM;
1109                 goto fail;
1110         }
1111
1112         dirhandles_open++;
1113         talloc_set_destructor(dirp, smb_Dir_destructor);
1114
1115         dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1116         if (!dirp->dir) {
1117                 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1118                          strerror(errno) ));
1119                 goto fail;
1120         }
1121
1122         return dirp;
1123
1124   fail:
1125         TALLOC_FREE(dirp);
1126         return NULL;
1127 }
1128
1129 /*******************************************************************
1130  Read from a directory.
1131  Return directory entry, current offset, and optional stat information.
1132  Don't check for veto or invisible files.
1133 ********************************************************************/
1134
1135 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1136                         SMB_STRUCT_STAT *sbuf)
1137 {
1138         const char *n;
1139         connection_struct *conn = dirp->conn;
1140
1141         /* Cheat to allow . and .. to be the first entries returned. */
1142         if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1143              (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1144         {
1145                 if (dirp->file_number == 0) {
1146                         n = ".";
1147                         *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1148                 } else {
1149                         *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1150                         n = "..";
1151                 }
1152                 dirp->file_number++;
1153                 return n;
1154         } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1155                 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1156                 return NULL;
1157         } else {
1158                 /* A real offset, seek to it. */
1159                 SeekDir(dirp, *poffset);
1160         }
1161
1162         while ((n = vfs_readdirname(conn, dirp->dir, sbuf))) {
1163                 /* Ignore . and .. - we've already returned them. */
1164                 if (*n == '.') {
1165                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1166                                 continue;
1167                         }
1168                 }
1169                 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1170                 dirp->file_number++;
1171                 return n;
1172         }
1173         *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1174         return NULL;
1175 }
1176
1177 /*******************************************************************
1178  Rewind to the start.
1179 ********************************************************************/
1180
1181 void RewindDir(struct smb_Dir *dirp, long *poffset)
1182 {
1183         SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1184         dirp->file_number = 0;
1185         dirp->offset = START_OF_DIRECTORY_OFFSET;
1186         *poffset = START_OF_DIRECTORY_OFFSET;
1187 }
1188
1189 /*******************************************************************
1190  Seek a dir.
1191 ********************************************************************/
1192
1193 void SeekDir(struct smb_Dir *dirp, long offset)
1194 {
1195         if (offset != dirp->offset) {
1196                 if (offset == START_OF_DIRECTORY_OFFSET) {
1197                         RewindDir(dirp, &offset);
1198                         /*
1199                          * Ok we should really set the file number here
1200                          * to 1 to enable ".." to be returned next. Trouble
1201                          * is I'm worried about callers using SeekDir(dirp,0)
1202                          * as equivalent to RewindDir(). So leave this alone
1203                          * for now.
1204                          */
1205                 } else if  (offset == DOT_DOT_DIRECTORY_OFFSET) {
1206                         RewindDir(dirp, &offset);
1207                         /*
1208                          * Set the file number to 2 - we want to get the first
1209                          * real file entry (the one we return after "..")
1210                          * on the next ReadDir.
1211                          */
1212                         dirp->file_number = 2;
1213                 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1214                         ; /* Don't seek in this case. */
1215                 } else {
1216                         SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1217                 }
1218                 dirp->offset = offset;
1219         }
1220 }
1221
1222 /*******************************************************************
1223  Tell a dir position.
1224 ********************************************************************/
1225
1226 long TellDir(struct smb_Dir *dirp)
1227 {
1228         return(dirp->offset);
1229 }
1230
1231 /*******************************************************************
1232  Add an entry into the dcache.
1233 ********************************************************************/
1234
1235 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1236 {
1237         struct name_cache_entry *e;
1238
1239         if (dirp->name_cache_size == 0) {
1240                 return;
1241         }
1242
1243         if (dirp->name_cache == NULL) {
1244                 dirp->name_cache = TALLOC_ZERO_ARRAY(
1245                         dirp, struct name_cache_entry, dirp->name_cache_size);
1246
1247                 if (dirp->name_cache == NULL) {
1248                         return;
1249                 }
1250         }
1251
1252         dirp->name_cache_index = (dirp->name_cache_index+1) %
1253                                         dirp->name_cache_size;
1254         e = &dirp->name_cache[dirp->name_cache_index];
1255         TALLOC_FREE(e->name);
1256         e->name = talloc_strdup(dirp, name);
1257         e->offset = offset;
1258 }
1259
1260 /*******************************************************************
1261  Find an entry by name. Leave us at the offset after it.
1262  Don't check for veto or invisible files.
1263 ********************************************************************/
1264
1265 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1266 {
1267         int i;
1268         const char *entry;
1269         connection_struct *conn = dirp->conn;
1270
1271         /* Search back in the name cache. */
1272         if (dirp->name_cache_size && dirp->name_cache) {
1273                 for (i = dirp->name_cache_index; i >= 0; i--) {
1274                         struct name_cache_entry *e = &dirp->name_cache[i];
1275                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1276                                 *poffset = e->offset;
1277                                 SeekDir(dirp, e->offset);
1278                                 return True;
1279                         }
1280                 }
1281                 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1282                         struct name_cache_entry *e = &dirp->name_cache[i];
1283                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1284                                 *poffset = e->offset;
1285                                 SeekDir(dirp, e->offset);
1286                                 return True;
1287                         }
1288                 }
1289         }
1290
1291         /* Not found in the name cache. Rewind directory and start from scratch. */
1292         SMB_VFS_REWINDDIR(conn, dirp->dir);
1293         dirp->file_number = 0;
1294         *poffset = START_OF_DIRECTORY_OFFSET;
1295         while ((entry = ReadDirName(dirp, poffset, NULL))) {
1296                 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1297                         return True;
1298                 }
1299         }
1300         return False;
1301 }
1302
1303 /*****************************************************************
1304  Is this directory empty ?
1305 *****************************************************************/
1306
1307 NTSTATUS can_delete_directory(struct connection_struct *conn,
1308                                 const char *dirname)
1309 {
1310         NTSTATUS status = NT_STATUS_OK;
1311         long dirpos = 0;
1312         const char *dname;
1313         SMB_STRUCT_STAT st;
1314         struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
1315                                           NULL, 0);
1316
1317         if (!dir_hnd) {
1318                 return map_nt_error_from_unix(errno);
1319         }
1320
1321         while ((dname = ReadDirName(dir_hnd, &dirpos, &st))) {
1322                 /* Quick check for "." and ".." */
1323                 if (dname[0] == '.') {
1324                         if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1325                                 continue;
1326                         }
1327                 }
1328
1329                 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1330                         continue;
1331                 }
1332
1333                 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1334                          dname ));
1335                 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1336                 break;
1337         }
1338         TALLOC_FREE(dir_hnd);
1339
1340         return status;
1341 }