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