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