source/smbd/dir.c

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