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