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