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                  * The destructor for the struct smb_Dir
 597                  * (fsp->dptr->dir_hnd) now handles
 598                  * all resource deallocation.
 599                  */
 600                 dptr_close_internal(fsp->dptr);
 601         }
 602 }
 603
 604 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
 605 {
 606         SeekDir(dptr->dir_hnd, offset);
 607 }
 608
 609 long dptr_TellDir(struct dptr_struct *dptr)
 610 {
 611         return TellDir(dptr->dir_hnd);
 612 }
 613
 614 bool dptr_has_wild(struct dptr_struct *dptr)
 615 {
 616         return dptr->has_wild;
 617 }
 618
 619 int dptr_dnum(struct dptr_struct *dptr)
 620 {
 621         return dptr->dnum;
 622 }
 623
 624 /****************************************************************************
 625  Return the next visible file name, skipping veto'd and invisible files.
 626 ****************************************************************************/
 627
 628 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
 629                                            long *poffset, SMB_STRUCT_STAT *pst,
 630                                            char **ptalloced)
 631 {
 632         /* Normal search for the next file. */
 633         const char *name;
 634         char *talloced = NULL;
 635
 636         while ((name = ReadDirName(dptr->dir_hnd, poffset, pst, &talloced))
 637                != NULL) {
 638                 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
 639                         *ptalloced = talloced;
 640                         return name;
 641                 }
 642                 TALLOC_FREE(talloced);
 643         }
 644         return NULL;
 645 }
 646
 647 /****************************************************************************
 648  Return the next visible file name, skipping veto'd and invisible files.
 649 ****************************************************************************/
 650
 651 char *dptr_ReadDirName(TALLOC_CTX *ctx,
 652                         struct dptr_struct *dptr,
 653                         long *poffset,
 654                         SMB_STRUCT_STAT *pst)
 655 {
 656         struct smb_filename smb_fname_base;
 657         char *name = NULL;
 658         const char *name_temp = NULL;
 659         char *talloced = NULL;
 660         char *pathreal = NULL;
 661         char *found_name = NULL;
 662         int ret;
 663
 664         SET_STAT_INVALID(*pst);
 665
 666         if (dptr->has_wild || dptr->did_stat) {
 667                 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst,
 668                                                     &talloced);
 669                 if (name_temp == NULL) {
 670                         return NULL;
 671                 }
 672                 if (talloced != NULL) {
 673                         return talloc_move(ctx, &talloced);
 674                 }
 675                 return talloc_strdup(ctx, name_temp);
 676         }
 677
 678         /* If poffset is -1 then we know we returned this name before and we
 679          * have no wildcards. We're at the end of the directory. */
 680         if (*poffset == END_OF_DIRECTORY_OFFSET) {
 681                 return NULL;
 682         }
 683
 684         /* We know the stored wcard contains no wildcard characters.
 685          * See if we can match with a stat call. If we can't, then set
 686          * did_stat to true to ensure we only do this once and keep
 687          * searching. */
 688
 689         dptr->did_stat = true;
 690
 691         /* First check if it should be visible. */
 692         if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
 693             pst, true))
 694         {
 695                 /* This only returns false if the file was found, but
 696                    is explicitly not visible. Set us to end of
 697                    directory, but return NULL as we know we can't ever
 698                    find it. */
 699                 goto ret;
 700         }
 701
 702         if (VALID_STAT(*pst)) {
 703                 name = talloc_strdup(ctx, dptr->wcard);
 704                 goto ret;
 705         }
 706
 707         pathreal = talloc_asprintf(ctx,
 708                                 "%s/%s",
 709                                 dptr->path,
 710                                 dptr->wcard);
 711         if (!pathreal)
 712                 return NULL;
 713
 714         /* Create an smb_filename with stream_name == NULL. */
 715         ZERO_STRUCT(smb_fname_base);
 716         smb_fname_base.base_name = pathreal;
 717
 718         if (SMB_VFS_STAT(dptr->conn, &smb_fname_base) == 0) {
 719                 *pst = smb_fname_base.st;
 720                 name = talloc_strdup(ctx, dptr->wcard);
 721                 goto clean;
 722         } else {
 723                 /* If we get any other error than ENOENT or ENOTDIR
 724                    then the file exists we just can't stat it. */
 725                 if (errno != ENOENT && errno != ENOTDIR) {
 726                         name = talloc_strdup(ctx, dptr->wcard);
 727                         goto clean;
 728                 }
 729         }
 730
 731         /* Stat failed. We know this is authoratiative if we are
 732          * providing case sensitive semantics or the underlying
 733          * filesystem is case sensitive.
 734          */
 735         if (dptr->conn->case_sensitive ||
 736             !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
 737         {
 738                 goto clean;
 739         }
 740
 741         /*
 742          * Try case-insensitive stat if the fs has the ability. This avoids
 743          * scanning the whole directory.
 744          */
 745         ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
 746                                         ctx, &found_name);
 747         if (ret == 0) {
 748                 name = found_name;
 749                 goto clean;
 750         } else if (errno == ENOENT) {
 751                 /* The case-insensitive lookup was authoritative. */
 752                 goto clean;
 753         }
 754
 755         TALLOC_FREE(pathreal);
 756
 757         name_temp = dptr_normal_ReadDirName(dptr, poffset, pst, &talloced);
 758         if (name_temp == NULL) {
 759                 return NULL;
 760         }
 761         if (talloced != NULL) {
 762                 return talloc_move(ctx, &talloced);
 763         }
 764         return talloc_strdup(ctx, name_temp);
 765
 766 clean:
 767         TALLOC_FREE(pathreal);
 768 ret:
 769         /* We need to set the underlying dir_hnd offset to -1
 770          * also as this function is usually called with the
 771          * output from TellDir. */
 772         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 773         return name;
 774 }
 775
 776 /****************************************************************************
 777  Search for a file by name, skipping veto'ed and not visible files.
 778 ****************************************************************************/
 779
 780 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
 781 {
 782         SET_STAT_INVALID(*pst);
 783
 784         if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
 785                 /* This is a singleton directory and we're already at the end. */
 786                 *poffset = END_OF_DIRECTORY_OFFSET;
 787                 return False;
 788         }
 789
 790         return SearchDir(dptr->dir_hnd, name, poffset);
 791 }
 792
 793 /****************************************************************************
 794  Add the name we're returning into the underlying cache.
 795 ****************************************************************************/
 796
 797 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
 798 {
 799         DirCacheAdd(dptr->dir_hnd, name, offset);
 800 }
 801
 802 /****************************************************************************
 803  Initialize variables & state data at the beginning of all search SMB requests.
 804 ****************************************************************************/
 805 void dptr_init_search_op(struct dptr_struct *dptr)
 806 {
 807         SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
 808 }
 809
 810 /****************************************************************************
 811  Fill the 5 byte server reserved dptr field.
 812 ****************************************************************************/
 813
 814 bool dptr_fill(struct smbd_server_connection *sconn,
 815                char *buf1,unsigned int key)
 816 {
 817         unsigned char *buf = (unsigned char *)buf1;
 818         struct dptr_struct *dptr = dptr_get(sconn, key, false);
 819         uint32 offset;
 820         if (!dptr) {
 821                 DEBUG(1,("filling null dirptr %d\n",key));
 822                 return(False);
 823         }
 824         offset = (uint32)TellDir(dptr->dir_hnd);
 825         DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
 826                 (long)dptr->dir_hnd,(int)offset));
 827         buf[0] = key;
 828         SIVAL(buf,1,offset);
 829         return(True);
 830 }
 831
 832 /****************************************************************************
 833  Fetch the dir ptr and seek it given the 5 byte server field.
 834 ****************************************************************************/
 835
 836 struct dptr_struct *dptr_fetch(struct smbd_server_connection *sconn,
 837                                char *buf, int *num)
 838 {
 839         unsigned int key = *(unsigned char *)buf;
 840         struct dptr_struct *dptr = dptr_get(sconn, key, false);
 841         uint32 offset;
 842         long seekoff;
 843
 844         if (!dptr) {
 845                 DEBUG(3,("fetched null dirptr %d\n",key));
 846                 return(NULL);
 847         }
 848         *num = key;
 849         offset = IVAL(buf,1);
 850         if (offset == (uint32)-1) {
 851                 seekoff = END_OF_DIRECTORY_OFFSET;
 852         } else {
 853                 seekoff = (long)offset;
 854         }
 855         SeekDir(dptr->dir_hnd,seekoff);
 856         DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
 857                 key, dptr->path, (int)seekoff));
 858         return(dptr);
 859 }
 860
 861 /****************************************************************************
 862  Fetch the dir ptr.
 863 ****************************************************************************/
 864
 865 struct dptr_struct *dptr_fetch_lanman2(struct smbd_server_connection *sconn,
 866                                        int dptr_num)
 867 {
 868         struct dptr_struct *dptr  = dptr_get(sconn, dptr_num, false);
 869
 870         if (!dptr) {
 871                 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
 872                 return(NULL);
 873         }
 874         DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr->path));
 875         return(dptr);
 876 }
 877
 878 /****************************************************************************
 879  Check that a file matches a particular file type.
 880 ****************************************************************************/
 881
 882 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
 883 {
 884         uint32 mask;
 885
 886         /* Check the "may have" search bits. */
 887         if (((mode & ~dirtype) & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY)) != 0)
 888                 return False;
 889
 890         /* Check the "must have" bits, which are the may have bits shifted eight */
 891         /* If must have bit is set, the file/dir can not be returned in search unless the matching
 892                 file attribute is set */
 893         mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
 894         if(mask) {
 895                 if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM))) == mask)   /* check if matching attribute present */
 896                         return True;
 897                 else
 898                         return False;
 899         }
 900
 901         return True;
 902 }
 903
 904 static bool mangle_mask_match(connection_struct *conn,
 905                 const char *filename,
 906                 const char *mask)
 907 {
 908         char mname[13];
 909
 910         if (!name_to_8_3(filename,mname,False,conn->params)) {
 911                 return False;
 912         }
 913         return mask_match_search(mname,mask,False);
 914 }
 915
 916 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
 917                            struct dptr_struct *dirptr,
 918                            const char *mask,
 919                            uint32_t dirtype,
 920                            bool dont_descend,
 921                            bool ask_sharemode,
 922                            bool (*match_fn)(TALLOC_CTX *ctx,
 923                                             void *private_data,
 924                                             const char *dname,
 925                                             const char *mask,
 926                                             char **_fname),
 927                            bool (*mode_fn)(TALLOC_CTX *ctx,
 928                                            void *private_data,
 929                                            struct smb_filename *smb_fname,
 930                                            uint32_t *_mode),
 931                            void *private_data,
 932                            char **_fname,
 933                            struct smb_filename **_smb_fname,
 934                            uint32_t *_mode,
 935                            long *_prev_offset)
 936 {
 937         connection_struct *conn = dirptr->conn;
 938         size_t slashlen;
 939         size_t pathlen;
 940
 941         *_smb_fname = NULL;
 942         *_mode = 0;
 943
 944         pathlen = strlen(dirptr->path);
 945         slashlen = ( dirptr->path[pathlen-1] != '/') ? 1 : 0;
 946
 947         while (true) {
 948                 long cur_offset;
 949                 long prev_offset;
 950                 SMB_STRUCT_STAT sbuf;
 951                 char *dname = NULL;
 952                 bool isdots;
 953                 char *fname = NULL;
 954                 char *pathreal = NULL;
 955                 struct smb_filename smb_fname;
 956                 uint32_t mode = 0;
 957                 bool ok;
 958                 NTSTATUS status;
 959
 960                 cur_offset = dptr_TellDir(dirptr);
 961                 prev_offset = cur_offset;
 962                 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
 963
 964                 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
 965                         (long)dirptr, cur_offset));
 966
 967                 if (dname == NULL) {
 968                         return false;
 969                 }
 970
 971                 isdots = (ISDOT(dname) || ISDOTDOT(dname));
 972                 if (dont_descend && !isdots) {
 973                         TALLOC_FREE(dname);
 974                         continue;
 975                 }
 976
 977                 /*
 978                  * fname may get mangled, dname is never mangled.
 979                  * Whenever we're accessing the filesystem we use
 980                  * pathreal which is composed from dname.
 981                  */
 982
 983                 ok = match_fn(ctx, private_data, dname, mask, &fname);
 984                 if (!ok) {
 985                         TALLOC_FREE(dname);
 986                         continue;
 987                 }
 988
 989                 /*
 990                  * This used to be
 991                  * pathreal = talloc_asprintf(ctx, "%s%s%s", dirptr->path,
 992                  *                            needslash?"/":"", dname);
 993                  * but this was measurably slower than doing the memcpy.
 994                  */
 995
 996                 pathreal = talloc_array(
 997                         ctx, char,
 998                         pathlen + slashlen + talloc_get_size(dname));
 999                 if (!pathreal) {
1000                         TALLOC_FREE(dname);
1001                         TALLOC_FREE(fname);
1002                         return false;
1003                 }
1004
1005                 memcpy(pathreal, dirptr->path, pathlen);
1006                 pathreal[pathlen] = '/';
1007                 memcpy(pathreal + slashlen + pathlen, dname,
1008                        talloc_get_size(dname));
1009
1010                 /* Create smb_fname with NULL stream_name. */
1011                 ZERO_STRUCT(smb_fname);
1012                 smb_fname.base_name = pathreal;
1013                 smb_fname.st = sbuf;
1014
1015                 ok = mode_fn(ctx, private_data, &smb_fname, &mode);
1016                 if (!ok) {
1017                         TALLOC_FREE(dname);
1018                         TALLOC_FREE(fname);
1019                         TALLOC_FREE(pathreal);
1020                         continue;
1021                 }
1022
1023                 if (!dir_check_ftype(conn, mode, dirtype)) {
1024                         DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1025                                 fname, (unsigned int)mode, (unsigned int)dirtype));
1026                         TALLOC_FREE(dname);
1027                         TALLOC_FREE(fname);
1028                         TALLOC_FREE(pathreal);
1029                         continue;
1030                 }
1031
1032                 if (ask_sharemode) {
1033                         struct timespec write_time_ts;
1034                         struct file_id fileid;
1035
1036                         fileid = vfs_file_id_from_sbuf(conn,
1037                                                        &smb_fname.st);
1038                         get_file_infos(fileid, 0, NULL, &write_time_ts);
1039                         if (!null_timespec(write_time_ts)) {
1040                                 update_stat_ex_mtime(&smb_fname.st,
1041                                                      write_time_ts);
1042                         }
1043                 }
1044
1045                 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1046                         "fname=%s (%s)\n",
1047                         mask, smb_fname_str_dbg(&smb_fname),
1048                         dname, fname));
1049
1050                 DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
1051
1052                 TALLOC_FREE(dname);
1053
1054                 status = copy_smb_filename(ctx, &smb_fname, _smb_fname);
1055                 TALLOC_FREE(pathreal);
1056                 if (!NT_STATUS_IS_OK(status)) {
1057                         return false;
1058                 }
1059                 *_fname = fname;
1060                 *_mode = mode;
1061                 *_prev_offset = prev_offset;
1062
1063                 return true;
1064         }
1065
1066         return false;
1067 }
1068
1069 /****************************************************************************
1070  Get an 8.3 directory entry.
1071 ****************************************************************************/
1072
1073 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1074                                      void *private_data,
1075                                      const char *dname,
1076                                      const char *mask,
1077                                      char **_fname)
1078 {
1079         connection_struct *conn = (connection_struct *)private_data;
1080
1081         if ((strcmp(mask,"*.*") == 0) ||
1082             mask_match_search(dname, mask, false) ||
1083             mangle_mask_match(conn, dname, mask)) {
1084                 char mname[13];
1085                 const char *fname;
1086
1087                 if (!mangle_is_8_3(dname, false, conn->params)) {
1088                         bool ok = name_to_8_3(dname, mname, false,
1089                                               conn->params);
1090                         if (!ok) {
1091                                 return false;
1092                         }
1093                         fname = mname;
1094                 } else {
1095                         fname = dname;
1096                 }
1097
1098                 *_fname = talloc_strdup(ctx, fname);
1099                 if (*_fname == NULL) {
1100                         return false;
1101                 }
1102
1103                 return true;
1104         }
1105
1106         return false;
1107 }
1108
1109 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1110                                     void *private_data,
1111                                     struct smb_filename *smb_fname,
1112                                     uint32_t *_mode)
1113 {
1114         connection_struct *conn = (connection_struct *)private_data;
1115
1116         if (!VALID_STAT(smb_fname->st)) {
1117                 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1118                         DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1119                                  "Couldn't stat [%s]. Error "
1120                                  "= %s\n",
1121                                  smb_fname_str_dbg(smb_fname),
1122                                  strerror(errno)));
1123                         return false;
1124                 }
1125         }
1126
1127         *_mode = dos_mode(conn, smb_fname);
1128         return true;
1129 }
1130
1131 bool get_dir_entry(TALLOC_CTX *ctx,
1132                 struct dptr_struct *dirptr,
1133                 const char *mask,
1134                 uint32_t dirtype,
1135                 char **_fname,
1136                 SMB_OFF_T *_size,
1137                 uint32_t *_mode,
1138                 struct timespec *_date,
1139                 bool check_descend,
1140                 bool ask_sharemode)
1141 {
1142         connection_struct *conn = dirptr->conn;
1143         char *fname = NULL;
1144         struct smb_filename *smb_fname = NULL;
1145         uint32_t mode = 0;
1146         long prev_offset;
1147         bool ok;
1148
1149         ok = smbd_dirptr_get_entry(ctx,
1150                                    dirptr,
1151                                    mask,
1152                                    dirtype,
1153                                    check_descend,
1154                                    ask_sharemode,
1155                                    smbd_dirptr_8_3_match_fn,
1156                                    smbd_dirptr_8_3_mode_fn,
1157                                    conn,
1158                                    &fname,
1159                                    &smb_fname,
1160                                    &mode,
1161                                    &prev_offset);
1162         if (!ok) {
1163                 return false;
1164         }
1165
1166         *_fname = talloc_move(ctx, &fname);
1167         *_size = smb_fname->st.st_ex_size;
1168         *_mode = mode;
1169         *_date = smb_fname->st.st_ex_mtime;
1170         TALLOC_FREE(smb_fname);
1171         return true;
1172 }
1173
1174 /*******************************************************************
1175  Check to see if a user can read a file. This is only approximate,
1176  it is used as part of the "hide unreadable" option. Don't
1177  use it for anything security sensitive.
1178 ********************************************************************/
1179
1180 static bool user_can_read_file(connection_struct *conn,
1181                                struct smb_filename *smb_fname)
1182 {
1183         /*
1184          * Never hide files from the root user.
1185          * We use (uid_t)0 here not sec_initial_uid()
1186          * as make test uses a single user context.
1187          */
1188
1189         if (get_current_uid(conn) == (uid_t)0) {
1190                 return True;
1191         }
1192
1193         return can_access_file_acl(conn, smb_fname, FILE_READ_DATA);
1194 }
1195
1196 /*******************************************************************
1197  Check to see if a user can write a file (and only files, we do not
1198  check dirs on this one). This is only approximate,
1199  it is used as part of the "hide unwriteable" option. Don't
1200  use it for anything security sensitive.
1201 ********************************************************************/
1202
1203 static bool user_can_write_file(connection_struct *conn,
1204                                 const struct smb_filename *smb_fname)
1205 {
1206         /*
1207          * Never hide files from the root user.
1208          * We use (uid_t)0 here not sec_initial_uid()
1209          * as make test uses a single user context.
1210          */
1211
1212         if (get_current_uid(conn) == (uid_t)0) {
1213                 return True;
1214         }
1215
1216         SMB_ASSERT(VALID_STAT(smb_fname->st));
1217
1218         /* Pseudo-open the file */
1219
1220         if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1221                 return True;
1222         }
1223
1224         return can_write_to_file(conn, smb_fname);
1225 }
1226
1227 /*******************************************************************
1228   Is a file a "special" type ?
1229 ********************************************************************/
1230
1231 static bool file_is_special(connection_struct *conn,
1232                             const struct smb_filename *smb_fname)
1233 {
1234         /*
1235          * Never hide files from the root user.
1236          * We use (uid_t)0 here not sec_initial_uid()
1237          * as make test uses a single user context.
1238          */
1239
1240         if (get_current_uid(conn) == (uid_t)0) {
1241                 return False;
1242         }
1243
1244         SMB_ASSERT(VALID_STAT(smb_fname->st));
1245
1246         if (S_ISREG(smb_fname->st.st_ex_mode) ||
1247             S_ISDIR(smb_fname->st.st_ex_mode) ||
1248             S_ISLNK(smb_fname->st.st_ex_mode))
1249                 return False;
1250
1251         return True;
1252 }
1253
1254 /*******************************************************************
1255  Should the file be seen by the client?
1256  NOTE: A successful return is no guarantee of the file's existence.
1257 ********************************************************************/
1258
1259 bool is_visible_file(connection_struct *conn, const char *dir_path,
1260                      const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1261 {
1262         bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1263         bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1264         bool hide_special = lp_hide_special_files(SNUM(conn));
1265         char *entry = NULL;
1266         struct smb_filename *smb_fname_base = NULL;
1267         NTSTATUS status;
1268         bool ret = false;
1269
1270         if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1271                 return True; /* . and .. are always visible. */
1272         }
1273
1274         /* If it's a vetoed file, pretend it doesn't even exist */
1275         if (use_veto && IS_VETO_PATH(conn, name)) {
1276                 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1277                 return False;
1278         }
1279
1280         if (hide_unreadable || hide_unwriteable || hide_special) {
1281                 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1282                 if (!entry) {
1283                         ret = false;
1284                         goto out;
1285                 }
1286
1287                 /* Create an smb_filename with stream_name == NULL. */
1288                 status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1289                                                     pst, &smb_fname_base);
1290                 if (!NT_STATUS_IS_OK(status)) {
1291                         ret = false;
1292                         goto out;
1293                 }
1294
1295                 /* If the file name does not exist, there's no point checking
1296                  * the configuration options. We succeed, on the basis that the
1297                  * checks *might* have passed if the file was present.
1298                  */
1299                 if (!VALID_STAT(*pst)) {
1300                         if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1301                                 ret = true;
1302                                 goto out;
1303                         } else {
1304                                 *pst = smb_fname_base->st;
1305                         }
1306                 }
1307
1308                 /* Honour _hide unreadable_ option */
1309                 if (hide_unreadable &&
1310                     !user_can_read_file(conn, smb_fname_base)) {
1311                         DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1312                                  entry ));
1313                         ret = false;
1314                         goto out;
1315                 }
1316                 /* Honour _hide unwriteable_ option */
1317                 if (hide_unwriteable && !user_can_write_file(conn,
1318                                                              smb_fname_base)) {
1319                         DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1320                                  entry ));
1321                         ret = false;
1322                         goto out;
1323                 }
1324                 /* Honour _hide_special_ option */
1325                 if (hide_special && file_is_special(conn, smb_fname_base)) {
1326                         DEBUG(10,("is_visible_file: file %s is special.\n",
1327                                  entry ));
1328                         ret = false;
1329                         goto out;
1330                 }
1331         }
1332
1333         ret = true;
1334  out:
1335         TALLOC_FREE(smb_fname_base);
1336         TALLOC_FREE(entry);
1337         return ret;
1338 }
1339
1340 static int smb_Dir_destructor(struct smb_Dir *dirp)
1341 {
1342         if (dirp->dir != NULL) {
1343                 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1344                 if (dirp->fsp != NULL) {
1345                         /*
1346                          * The SMB_VFS_CLOSEDIR above
1347                          * closes the underlying fd inside
1348                          * dirp->fsp.
1349                          */
1350                         dirp->fsp->fh->fd = -1;
1351                         if (dirp->fsp->dptr != NULL) {
1352                                 SMB_ASSERT(dirp->fsp->dptr->dir_hnd == dirp);
1353                                 dirp->fsp->dptr->dir_hnd = NULL;
1354                         }
1355                         dirp->fsp = NULL;
1356                 }
1357         }
1358         if (dirp->conn->sconn && !dirp->conn->sconn->using_smb2) {
1359                 dirp->conn->sconn->searches.dirhandles_open--;
1360         }
1361         return 0;
1362 }
1363
1364 /*******************************************************************
1365  Open a directory.
1366 ********************************************************************/
1367
1368 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1369                         const char *name,
1370                         const char *mask,
1371                         uint32 attr)
1372 {
1373         struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1374         struct smbd_server_connection *sconn = conn->sconn;
1375
1376         if (!dirp) {
1377                 return NULL;
1378         }
1379
1380         dirp->conn = conn;
1381         dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1382
1383         dirp->dir_path = talloc_strdup(dirp, name);
1384         if (!dirp->dir_path) {
1385                 errno = ENOMEM;
1386                 goto fail;
1387         }
1388
1389         if (sconn && !sconn->using_smb2) {
1390                 sconn->searches.dirhandles_open++;
1391         }
1392         talloc_set_destructor(dirp, smb_Dir_destructor);
1393
1394         dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1395         if (!dirp->dir) {
1396                 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1397                          strerror(errno) ));
1398                 goto fail;
1399         }
1400
1401         return dirp;
1402
1403   fail:
1404         TALLOC_FREE(dirp);
1405         return NULL;
1406 }
1407
1408 /*******************************************************************
1409  Open a directory from an fsp.
1410 ********************************************************************/
1411
1412 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
1413                         files_struct *fsp,
1414                         const char *mask,
1415                         uint32 attr)
1416 {
1417         struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1418         struct smbd_server_connection *sconn = conn->sconn;
1419
1420         if (!dirp) {
1421                 return NULL;
1422         }
1423
1424         dirp->conn = conn;
1425         dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1426
1427         dirp->dir_path = talloc_strdup(dirp, fsp->fsp_name->base_name);
1428         if (!dirp->dir_path) {
1429                 errno = ENOMEM;
1430                 goto fail;
1431         }
1432
1433         if (sconn && !sconn->using_smb2) {
1434                 sconn->searches.dirhandles_open++;
1435         }
1436         talloc_set_destructor(dirp, smb_Dir_destructor);
1437
1438         if (fsp->is_directory && fsp->fh->fd != -1) {
1439                 dirp->dir = SMB_VFS_FDOPENDIR(fsp, mask, attr);
1440                 if (dirp->dir != NULL) {
1441                         dirp->fsp = fsp;
1442                 } else {
1443                         DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1444                                 "NULL (%s)\n",
1445                                 dirp->dir_path,
1446                                 strerror(errno)));
1447                         if (errno != ENOSYS) {
1448                                 return NULL;
1449                         }
1450                 }
1451         }
1452
1453         if (dirp->dir == NULL) {
1454                 /* FDOPENDIR didn't work. Use OPENDIR instead. */
1455                 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1456         }
1457
1458         if (!dirp->dir) {
1459                 DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp->dir_path,
1460                          strerror(errno) ));
1461                 goto fail;
1462         }
1463
1464         return dirp;
1465
1466   fail:
1467         TALLOC_FREE(dirp);
1468         return NULL;
1469 }
1470
1471
1472 /*******************************************************************
1473  Read from a directory.
1474  Return directory entry, current offset, and optional stat information.
1475  Don't check for veto or invisible files.
1476 ********************************************************************/
1477
1478 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1479                         SMB_STRUCT_STAT *sbuf, char **ptalloced)
1480 {
1481         const char *n;
1482         char *talloced = NULL;
1483         connection_struct *conn = dirp->conn;
1484
1485         /* Cheat to allow . and .. to be the first entries returned. */
1486         if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1487              (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1488         {
1489                 if (dirp->file_number == 0) {
1490                         n = ".";
1491                         *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1492                 } else {
1493                         n = "..";
1494                         *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1495                 }
1496                 dirp->file_number++;
1497                 *ptalloced = NULL;
1498                 return n;
1499         } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1500                 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1501                 return NULL;
1502         } else {
1503                 /* A real offset, seek to it. */
1504                 SeekDir(dirp, *poffset);
1505         }
1506
1507         while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1508                 /* Ignore . and .. - we've already returned them. */
1509                 if (*n == '.') {
1510                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1511                                 TALLOC_FREE(talloced);
1512                                 continue;
1513                         }
1514                 }
1515                 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1516                 *ptalloced = talloced;
1517                 dirp->file_number++;
1518                 return n;
1519         }
1520         *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1521         *ptalloced = NULL;
1522         return NULL;
1523 }
1524
1525 /*******************************************************************
1526  Rewind to the start.
1527 ********************************************************************/
1528
1529 void RewindDir(struct smb_Dir *dirp, long *poffset)
1530 {
1531         SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1532         dirp->file_number = 0;
1533         dirp->offset = START_OF_DIRECTORY_OFFSET;
1534         *poffset = START_OF_DIRECTORY_OFFSET;
1535 }
1536
1537 /*******************************************************************
1538  Seek a dir.
1539 ********************************************************************/
1540
1541 void SeekDir(struct smb_Dir *dirp, long offset)
1542 {
1543         if (offset != dirp->offset) {
1544                 if (offset == START_OF_DIRECTORY_OFFSET) {
1545                         RewindDir(dirp, &offset);
1546                         /*
1547                          * Ok we should really set the file number here
1548                          * to 1 to enable ".." to be returned next. Trouble
1549                          * is I'm worried about callers using SeekDir(dirp,0)
1550                          * as equivalent to RewindDir(). So leave this alone
1551                          * for now.
1552                          */
1553                 } else if  (offset == DOT_DOT_DIRECTORY_OFFSET) {
1554                         RewindDir(dirp, &offset);
1555                         /*
1556                          * Set the file number to 2 - we want to get the first
1557                          * real file entry (the one we return after "..")
1558                          * on the next ReadDir.
1559                          */
1560                         dirp->file_number = 2;
1561                 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1562                         ; /* Don't seek in this case. */
1563                 } else {
1564                         SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1565                 }
1566                 dirp->offset = offset;
1567         }
1568 }
1569
1570 /*******************************************************************
1571  Tell a dir position.
1572 ********************************************************************/
1573
1574 long TellDir(struct smb_Dir *dirp)
1575 {
1576         return(dirp->offset);
1577 }
1578
1579 /*******************************************************************
1580  Add an entry into the dcache.
1581 ********************************************************************/
1582
1583 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1584 {
1585         struct name_cache_entry *e;
1586
1587         if (dirp->name_cache_size == 0) {
1588                 return;
1589         }
1590
1591         if (dirp->name_cache == NULL) {
1592                 dirp->name_cache = TALLOC_ZERO_ARRAY(
1593                         dirp, struct name_cache_entry, dirp->name_cache_size);
1594
1595                 if (dirp->name_cache == NULL) {
1596                         return;
1597                 }
1598         }
1599
1600         dirp->name_cache_index = (dirp->name_cache_index+1) %
1601                                         dirp->name_cache_size;
1602         e = &dirp->name_cache[dirp->name_cache_index];
1603         TALLOC_FREE(e->name);
1604         e->name = talloc_strdup(dirp, name);
1605         e->offset = offset;
1606 }
1607
1608 /*******************************************************************
1609  Find an entry by name. Leave us at the offset after it.
1610  Don't check for veto or invisible files.
1611 ********************************************************************/
1612
1613 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1614 {
1615         int i;
1616         const char *entry = NULL;
1617         char *talloced = NULL;
1618         connection_struct *conn = dirp->conn;
1619
1620         /* Search back in the name cache. */
1621         if (dirp->name_cache_size && dirp->name_cache) {
1622                 for (i = dirp->name_cache_index; i >= 0; i--) {
1623                         struct name_cache_entry *e = &dirp->name_cache[i];
1624                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1625                                 *poffset = e->offset;
1626                                 SeekDir(dirp, e->offset);
1627                                 return True;
1628                         }
1629                 }
1630                 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1631                         struct name_cache_entry *e = &dirp->name_cache[i];
1632                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1633                                 *poffset = e->offset;
1634                                 SeekDir(dirp, e->offset);
1635                                 return True;
1636                         }
1637                 }
1638         }
1639
1640         /* Not found in the name cache. Rewind directory and start from scratch. */
1641         SMB_VFS_REWINDDIR(conn, dirp->dir);
1642         dirp->file_number = 0;
1643         *poffset = START_OF_DIRECTORY_OFFSET;
1644         while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
1645                 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1646                         TALLOC_FREE(talloced);
1647                         return True;
1648                 }
1649                 TALLOC_FREE(talloced);
1650         }
1651         return False;
1652 }
1653
1654 /*****************************************************************
1655  Is this directory empty ?
1656 *****************************************************************/
1657
1658 NTSTATUS can_delete_directory_fsp(files_struct *fsp)
1659 {
1660         NTSTATUS status = NT_STATUS_OK;
1661         long dirpos = 0;
1662         const char *dname = NULL;
1663         char *talloced = NULL;
1664         SMB_STRUCT_STAT st;
1665         struct connection_struct *conn = fsp->conn;
1666         struct smb_Dir *dir_hnd = OpenDir_fsp(talloc_tos(),
1667                                         conn,
1668                                         fsp,
1669                                         NULL,
1670                                         0);
1671
1672         if (!dir_hnd) {
1673                 return map_nt_error_from_unix(errno);
1674         }
1675
1676         while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
1677                 /* Quick check for "." and ".." */
1678                 if (dname[0] == '.') {
1679                         if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1680                                 TALLOC_FREE(talloced);
1681                                 continue;
1682                         }
1683                 }
1684
1685                 if (!is_visible_file(conn, fsp->fsp_name->base_name, dname, &st, True)) {
1686                         TALLOC_FREE(talloced);
1687                         continue;
1688                 }
1689
1690                 DEBUG(10,("can_delete_directory_fsp: got name %s - can't delete\n",
1691                          dname ));
1692                 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1693                 break;
1694         }
1695         TALLOC_FREE(talloced);
1696         TALLOC_FREE(dir_hnd);
1697
1698         return status;
1699 }