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