source3/smbd/dir.c

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