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