source3/smbd/dir.c

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