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 #include "../lib/util/memcache.h"
  28 #include "../librpc/gen_ndr/open_files.h"
  29
  30 /*
  31    This module implements directory related functions for Samba.
  32 */
  33
  34 /* "Special" directory offsets. */
  35 #define END_OF_DIRECTORY_OFFSET ((long)-1)
  36 #define START_OF_DIRECTORY_OFFSET ((long)0)
  37 #define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
  38
  39 /* "Special" directory offsets in 32-bit wire format. */
  40 #define WIRE_END_OF_DIRECTORY_OFFSET ((uint32_t)0xFFFFFFFF)
  41 #define WIRE_START_OF_DIRECTORY_OFFSET ((uint32_t)0)
  42 #define WIRE_DOT_DOT_DIRECTORY_OFFSET ((uint32_t)0x80000000)
  43
  44 /* Make directory handle internals available. */
  45
  46 struct name_cache_entry {
  47         char *name;
  48         long offset;
  49 };
  50
  51 struct smb_Dir {
  52         connection_struct *conn;
  53         DIR *dir;
  54         long offset;
  55         struct smb_filename *dir_smb_fname;
  56         size_t name_cache_size;
  57         struct name_cache_entry *name_cache;
  58         unsigned int name_cache_index;
  59         unsigned int file_number;
  60         files_struct *fsp; /* Back pointer to containing fsp, only
  61                               set from OpenDir_fsp(). */
  62 };
  63
  64 struct dptr_struct {
  65         struct dptr_struct *next, *prev;
  66         int dnum;
  67         uint16_t spid;
  68         struct connection_struct *conn;
  69         struct smb_Dir *dir_hnd;
  70         bool expect_close;
  71         char *wcard;
  72         uint32_t attr;
  73         struct smb_filename *smb_dname;
  74         bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
  75         bool did_stat; /* Optimisation for non-wcard searches. */
  76         bool priv;     /* Directory handle opened with privilege. */
  77         uint32_t counter;
  78         struct memcache *dptr_cache;
  79 };
  80
  81 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
  82                         files_struct *fsp,
  83                         const char *mask,
  84                         uint32_t attr);
  85
  86 static void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset);
  87
  88 #define INVALID_DPTR_KEY (-3)
  89
  90 /****************************************************************************
  91  Initialise the dir bitmap.
  92 ****************************************************************************/
  93
  94 bool init_dptrs(struct smbd_server_connection *sconn)
  95 {
  96         if (sconn->searches.dptr_bmap) {
  97                 return true;
  98         }
  99
 100         sconn->searches.dptr_bmap = bitmap_talloc(
 101                 sconn, MAX_DIRECTORY_HANDLES);
 102
 103         if (sconn->searches.dptr_bmap == NULL) {
 104                 return false;
 105         }
 106
 107         return true;
 108 }
 109
 110 /****************************************************************************
 111  Idle a dptr - the directory is closed but the control info is kept.
 112 ****************************************************************************/
 113
 114 static void dptr_idle(struct dptr_struct *dptr)
 115 {
 116         if (dptr->dir_hnd) {
 117                 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
 118                 TALLOC_FREE(dptr->dir_hnd);
 119                 TALLOC_FREE(dptr->dptr_cache);
 120                 dptr->counter = 0;
 121         }
 122 }
 123
 124 /****************************************************************************
 125  Idle the oldest dptr.
 126 ****************************************************************************/
 127
 128 static void dptr_idleoldest(struct smbd_server_connection *sconn)
 129 {
 130         struct dptr_struct *dptr;
 131
 132         /*
 133          * Go to the end of the list.
 134          */
 135         dptr = DLIST_TAIL(sconn->searches.dirptrs);
 136
 137         if(!dptr) {
 138                 DEBUG(0,("No dptrs available to idle ?\n"));
 139                 return;
 140         }
 141
 142         /*
 143          * Idle the oldest pointer.
 144          */
 145
 146         for(; dptr; dptr = DLIST_PREV(dptr)) {
 147                 if (dptr->dir_hnd) {
 148                         dptr_idle(dptr);
 149                         return;
 150                 }
 151         }
 152 }
 153
 154 /****************************************************************************
 155  Get the struct dptr_struct for a dir index.
 156 ****************************************************************************/
 157
 158 static struct dptr_struct *dptr_get(struct smbd_server_connection *sconn,
 159                                     int key, bool forclose)
 160 {
 161         struct dptr_struct *dptr;
 162         const int dirhandles_open = sconn->searches.dirhandles_open;
 163
 164         for (dptr = sconn->searches.dirptrs; dptr != NULL; dptr = dptr->next) {
 165                 if(dptr->dnum != key) {
 166                         continue;
 167                 }
 168
 169                 if (!forclose && (dptr->dir_hnd == NULL)) {
 170                         if (dirhandles_open >= MAX_OPEN_DIRECTORIES) {
 171                                 dptr_idleoldest(sconn);
 172                         }
 173                         DBG_INFO("Reopening dptr key %d\n",key);
 174
 175                         dptr->dir_hnd = OpenDir(NULL,
 176                                                 dptr->conn,
 177                                                 dptr->smb_dname,
 178                                                 dptr->wcard,
 179                                                 dptr->attr);
 180
 181                         if (dptr->dir_hnd == NULL) {
 182                                 DBG_INFO("Failed to open %s (%s)\n",
 183                                       dptr->smb_dname->base_name,
 184                                       strerror(errno));
 185                                 return NULL;
 186                         }
 187                 }
 188                 DLIST_PROMOTE(sconn->searches.dirptrs, dptr);
 189                 return dptr;
 190         }
 191         return(NULL);
 192 }
 193
 194 /****************************************************************************
 195  Get the dir path for a dir index.
 196 ****************************************************************************/
 197
 198 const char *dptr_path(struct smbd_server_connection *sconn, int key)
 199 {
 200         struct dptr_struct *dptr = dptr_get(sconn, key, false);
 201         if (dptr)
 202                 return(dptr->smb_dname->base_name);
 203         return(NULL);
 204 }
 205
 206 /****************************************************************************
 207  Get the dir wcard for a dir index.
 208 ****************************************************************************/
 209
 210 const char *dptr_wcard(struct smbd_server_connection *sconn, int key)
 211 {
 212         struct dptr_struct *dptr = dptr_get(sconn, key, false);
 213         if (dptr)
 214                 return(dptr->wcard);
 215         return(NULL);
 216 }
 217
 218 /****************************************************************************
 219  Get the dir attrib for a dir index.
 220 ****************************************************************************/
 221
 222 uint16_t dptr_attr(struct smbd_server_connection *sconn, int key)
 223 {
 224         struct dptr_struct *dptr = dptr_get(sconn, key, false);
 225         if (dptr)
 226                 return(dptr->attr);
 227         return(0);
 228 }
 229
 230 /****************************************************************************
 231  Close a dptr (internal func).
 232 ****************************************************************************/
 233
 234 static void dptr_close_internal(struct dptr_struct *dptr)
 235 {
 236         struct smbd_server_connection *sconn = dptr->conn->sconn;
 237
 238         DEBUG(4,("closing dptr key %d\n",dptr->dnum));
 239
 240         if (sconn == NULL) {
 241                 goto done;
 242         }
 243
 244         if (sconn->using_smb2) {
 245                 goto done;
 246         }
 247
 248         DLIST_REMOVE(sconn->searches.dirptrs, dptr);
 249
 250         /*
 251          * Free the dnum in the bitmap. Remember the dnum value is always
 252          * biased by one with respect to the bitmap.
 253          */
 254
 255         if (!bitmap_query(sconn->searches.dptr_bmap, dptr->dnum - 1)) {
 256                 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
 257                         dptr->dnum ));
 258         }
 259
 260         bitmap_clear(sconn->searches.dptr_bmap, dptr->dnum - 1);
 261
 262 done:
 263         TALLOC_FREE(dptr->dir_hnd);
 264         TALLOC_FREE(dptr);
 265 }
 266
 267 /****************************************************************************
 268  Close a dptr given a key.
 269 ****************************************************************************/
 270
 271 void dptr_close(struct smbd_server_connection *sconn, int *key)
 272 {
 273         struct dptr_struct *dptr;
 274
 275         if(*key == INVALID_DPTR_KEY)
 276                 return;
 277
 278         /* OS/2 seems to use -1 to indicate "close all directories" */
 279         if (*key == -1) {
 280                 struct dptr_struct *next;
 281                 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
 282                         next = dptr->next;
 283                         dptr_close_internal(dptr);
 284                 }
 285                 *key = INVALID_DPTR_KEY;
 286                 return;
 287         }
 288
 289         dptr = dptr_get(sconn, *key, true);
 290
 291         if (!dptr) {
 292                 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
 293                 return;
 294         }
 295
 296         dptr_close_internal(dptr);
 297
 298         *key = INVALID_DPTR_KEY;
 299 }
 300
 301 /****************************************************************************
 302  Close all dptrs for a cnum.
 303 ****************************************************************************/
 304
 305 void dptr_closecnum(connection_struct *conn)
 306 {
 307         struct dptr_struct *dptr, *next;
 308         struct smbd_server_connection *sconn = conn->sconn;
 309
 310         if (sconn == NULL) {
 311                 return;
 312         }
 313
 314         for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
 315                 next = dptr->next;
 316                 if (dptr->conn == conn) {
 317                         dptr_close_internal(dptr);
 318                 }
 319         }
 320 }
 321
 322 /****************************************************************************
 323  Idle all dptrs for a cnum.
 324 ****************************************************************************/
 325
 326 void dptr_idlecnum(connection_struct *conn)
 327 {
 328         struct dptr_struct *dptr;
 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 = dptr->next) {
 336                 if (dptr->conn == conn && dptr->dir_hnd) {
 337                         dptr_idle(dptr);
 338                 }
 339         }
 340 }
 341
 342 /****************************************************************************
 343  Close a dptr that matches a given path, only if it matches the spid also.
 344 ****************************************************************************/
 345
 346 void dptr_closepath(struct smbd_server_connection *sconn,
 347                     char *path,uint16_t spid)
 348 {
 349         struct dptr_struct *dptr, *next;
 350         for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
 351                 next = dptr->next;
 352                 if (spid == dptr->spid &&
 353                                 strequal(dptr->smb_dname->base_name,path)) {
 354                         dptr_close_internal(dptr);
 355                 }
 356         }
 357 }
 358
 359 /****************************************************************************
 360  Try and close the oldest handle not marked for
 361  expect close in the hope that the client has
 362  finished with that one.
 363 ****************************************************************************/
 364
 365 static void dptr_close_oldest(struct smbd_server_connection *sconn,
 366                               bool old)
 367 {
 368         struct dptr_struct *dptr;
 369
 370         /*
 371          * Go to the end of the list.
 372          */
 373         for(dptr = sconn->searches.dirptrs; dptr && dptr->next; dptr = dptr->next)
 374                 ;
 375
 376         if(!dptr) {
 377                 DEBUG(0,("No old dptrs available to close oldest ?\n"));
 378                 return;
 379         }
 380
 381         /*
 382          * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
 383          * does not have expect_close set. If 'old' is false, close
 384          * one of the new dnum handles.
 385          */
 386
 387         for(; dptr; dptr = DLIST_PREV(dptr)) {
 388                 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
 389                         (!old && (dptr->dnum > 255))) {
 390                                 dptr_close_internal(dptr);
 391                                 return;
 392                 }
 393         }
 394 }
 395
 396 /****************************************************************************
 397  Safely do an OpenDir as root, ensuring we're in the right place.
 398 ****************************************************************************/
 399
 400 static struct smb_Dir *open_dir_with_privilege(connection_struct *conn,
 401                                         struct smb_request *req,
 402                                         const struct smb_filename *smb_dname,
 403                                         const char *wcard,
 404                                         uint32_t attr)
 405 {
 406         struct smb_Dir *dir_hnd = NULL;
 407         struct smb_filename *smb_fname_cwd = NULL;
 408         struct smb_filename *saved_dir_fname = vfs_GetWd(talloc_tos(), conn);
 409         struct privilege_paths *priv_paths = req->priv_paths;
 410         int ret;
 411
 412         if (saved_dir_fname == NULL) {
 413                 return NULL;
 414         }
 415
 416         if (vfs_ChDir(conn, smb_dname) == -1) {
 417                 return NULL;
 418         }
 419
 420         /* Now check the stat value is the same. */
 421         smb_fname_cwd = synthetic_smb_fname(talloc_tos(),
 422                                         ".",
 423                                         NULL,
 424                                         NULL,
 425                                         smb_dname->flags);
 426         if (smb_fname_cwd == NULL) {
 427                 goto out;
 428         }
 429         ret = SMB_VFS_STAT(conn, smb_fname_cwd);
 430         if (ret != 0) {
 431                 goto out;
 432         }
 433
 434         if (!check_same_stat(&smb_fname_cwd->st, &priv_paths->parent_name.st)) {
 435                 DEBUG(0,("open_dir_with_privilege: stat mismatch between %s "
 436                         "and %s\n",
 437                         smb_dname->base_name,
 438                         smb_fname_str_dbg(&priv_paths->parent_name)));
 439                 goto out;
 440         }
 441
 442         dir_hnd = OpenDir(NULL, conn, smb_fname_cwd, wcard, attr);
 443
 444   out:
 445
 446         vfs_ChDir(conn, saved_dir_fname);
 447         TALLOC_FREE(saved_dir_fname);
 448         return dir_hnd;
 449 }
 450
 451 /****************************************************************************
 452  Create a new dir ptr. If the flag old_handle is true then we must allocate
 453  from the bitmap range 0 - 255 as old SMBsearch directory handles are only
 454  one byte long. If old_handle is false we allocate from the range
 455  256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
 456  a directory handle is never zero.
 457  wcard must not be zero.
 458 ****************************************************************************/
 459
 460 NTSTATUS dptr_create(connection_struct *conn,
 461                 struct smb_request *req,
 462                 files_struct *fsp,
 463                 const struct smb_filename *smb_dname,
 464                 bool old_handle,
 465                 bool expect_close,
 466                 uint16_t spid,
 467                 const char *wcard,
 468                 bool wcard_has_wild,
 469                 uint32_t attr,
 470                 struct dptr_struct **dptr_ret)
 471 {
 472         struct smbd_server_connection *sconn = conn->sconn;
 473         struct dptr_struct *dptr = NULL;
 474         struct smb_Dir *dir_hnd;
 475
 476         if (fsp && fsp->is_directory && fsp->fh->fd != -1) {
 477                 smb_dname = fsp->fsp_name;
 478         }
 479
 480         DEBUG(5,("dptr_create dir=%s\n", smb_dname->base_name));
 481
 482         if (sconn == NULL) {
 483                 DEBUG(0,("dptr_create: called with fake connection_struct\n"));
 484                 return NT_STATUS_INTERNAL_ERROR;
 485         }
 486
 487         if (!wcard) {
 488                 return NT_STATUS_INVALID_PARAMETER;
 489         }
 490
 491         if (fsp) {
 492                 if (!(fsp->access_mask & SEC_DIR_LIST)) {
 493                         DEBUG(5,("dptr_create: directory %s "
 494                                 "not open for LIST access\n",
 495                                 smb_dname->base_name));
 496                         return NT_STATUS_ACCESS_DENIED;
 497                 }
 498                 dir_hnd = OpenDir_fsp(NULL, conn, fsp, wcard, attr);
 499         } else {
 500                 int ret;
 501                 bool backup_intent = (req && req->priv_paths);
 502                 NTSTATUS status;
 503                 struct smb_filename *smb_dname_cp =
 504                         cp_smb_filename(talloc_tos(), smb_dname);
 505
 506                 if (smb_dname_cp == NULL) {
 507                         return NT_STATUS_NO_MEMORY;
 508                 }
 509
 510                 if (req != NULL && req->posix_pathnames) {
 511                         ret = SMB_VFS_LSTAT(conn, smb_dname_cp);
 512                 } else {
 513                         ret = SMB_VFS_STAT(conn, smb_dname_cp);
 514                 }
 515                 if (ret == -1) {
 516                         status = map_nt_error_from_unix(errno);
 517                         TALLOC_FREE(smb_dname_cp);
 518                         return status;
 519                 }
 520                 if (!S_ISDIR(smb_dname_cp->st.st_ex_mode)) {
 521                         TALLOC_FREE(smb_dname_cp);
 522                         return NT_STATUS_NOT_A_DIRECTORY;
 523                 }
 524                 status = smbd_check_access_rights(conn,
 525                                                 smb_dname_cp,
 526                                                 backup_intent,
 527                                                 SEC_DIR_LIST);
 528                 if (!NT_STATUS_IS_OK(status)) {
 529                         TALLOC_FREE(smb_dname_cp);
 530                         return status;
 531                 }
 532                 if (backup_intent) {
 533                         dir_hnd = open_dir_with_privilege(conn,
 534                                                 req,
 535                                                 smb_dname_cp,
 536                                                 wcard,
 537                                                 attr);
 538                 } else {
 539                         dir_hnd = OpenDir(NULL,
 540                                         conn,
 541                                         smb_dname_cp,
 542                                         wcard,
 543                                         attr);
 544                 }
 545                 TALLOC_FREE(smb_dname_cp);
 546         }
 547
 548         if (!dir_hnd) {
 549                 return map_nt_error_from_unix(errno);
 550         }
 551
 552         if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES) {
 553                 dptr_idleoldest(sconn);
 554         }
 555
 556         dptr = talloc_zero(NULL, struct dptr_struct);
 557         if(!dptr) {
 558                 DEBUG(0,("talloc fail in dptr_create.\n"));
 559                 TALLOC_FREE(dir_hnd);
 560                 return NT_STATUS_NO_MEMORY;
 561         }
 562
 563         dptr->smb_dname = cp_smb_filename(dptr, smb_dname);
 564         if (!dptr->smb_dname) {
 565                 TALLOC_FREE(dptr);
 566                 TALLOC_FREE(dir_hnd);
 567                 return NT_STATUS_NO_MEMORY;
 568         }
 569         dptr->conn = conn;
 570         dptr->dir_hnd = dir_hnd;
 571         dptr->spid = spid;
 572         dptr->expect_close = expect_close;
 573         dptr->wcard = talloc_strdup(dptr, wcard);
 574         if (!dptr->wcard) {
 575                 TALLOC_FREE(dptr);
 576                 TALLOC_FREE(dir_hnd);
 577                 return NT_STATUS_NO_MEMORY;
 578         }
 579         if ((req != NULL && req->posix_pathnames) ||
 580                         (wcard[0] == '.' && wcard[1] == 0)) {
 581                 dptr->has_wild = True;
 582         } else {
 583                 dptr->has_wild = wcard_has_wild;
 584         }
 585
 586         dptr->attr = attr;
 587
 588         if (sconn->using_smb2) {
 589                 goto done;
 590         }
 591
 592         if(old_handle) {
 593
 594                 /*
 595                  * This is an old-style SMBsearch request. Ensure the
 596                  * value we return will fit in the range 1-255.
 597                  */
 598
 599                 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
 600
 601                 if(dptr->dnum == -1 || dptr->dnum > 254) {
 602
 603                         /*
 604                          * Try and close the oldest handle not marked for
 605                          * expect close in the hope that the client has
 606                          * finished with that one.
 607                          */
 608
 609                         dptr_close_oldest(sconn, true);
 610
 611                         /* Now try again... */
 612                         dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
 613                         if(dptr->dnum == -1 || dptr->dnum > 254) {
 614                                 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
 615                                 TALLOC_FREE(dptr);
 616                                 TALLOC_FREE(dir_hnd);
 617                                 return NT_STATUS_TOO_MANY_OPENED_FILES;
 618                         }
 619                 }
 620         } else {
 621
 622                 /*
 623                  * This is a new-style trans2 request. Allocate from
 624                  * a range that will return 256 - MAX_DIRECTORY_HANDLES.
 625                  */
 626
 627                 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
 628
 629                 if(dptr->dnum == -1 || dptr->dnum < 255) {
 630
 631                         /*
 632                          * Try and close the oldest handle close in the hope that
 633                          * the client has finished with that one. This will only
 634                          * happen in the case of the Win98 client bug where it leaks
 635                          * directory handles.
 636                          */
 637
 638                         dptr_close_oldest(sconn, false);
 639
 640                         /* Now try again... */
 641                         dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
 642
 643                         if(dptr->dnum == -1 || dptr->dnum < 255) {
 644                                 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
 645                                 TALLOC_FREE(dptr);
 646                                 TALLOC_FREE(dir_hnd);
 647                                 return NT_STATUS_TOO_MANY_OPENED_FILES;
 648                         }
 649                 }
 650         }
 651
 652         bitmap_set(sconn->searches.dptr_bmap, dptr->dnum);
 653
 654         dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
 655
 656         DLIST_ADD(sconn->searches.dirptrs, dptr);
 657
 658 done:
 659         DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
 660                 dptr->dnum,
 661                 dptr->smb_dname->base_name,
 662                 expect_close));
 663
 664         *dptr_ret = dptr;
 665
 666         return NT_STATUS_OK;
 667 }
 668
 669
 670 /****************************************************************************
 671  Wrapper functions to access the lower level directory handles.
 672 ****************************************************************************/
 673
 674 void dptr_CloseDir(files_struct *fsp)
 675 {
 676         if (fsp->dptr) {
 677                 /*
 678                  * The destructor for the struct smb_Dir
 679                  * (fsp->dptr->dir_hnd) now handles
 680                  * all resource deallocation.
 681                  */
 682                 dptr_close_internal(fsp->dptr);
 683                 fsp->dptr = NULL;
 684         }
 685 }
 686
 687 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
 688 {
 689         SeekDir(dptr->dir_hnd, offset);
 690 }
 691
 692 long dptr_TellDir(struct dptr_struct *dptr)
 693 {
 694         return TellDir(dptr->dir_hnd);
 695 }
 696
 697 bool dptr_has_wild(struct dptr_struct *dptr)
 698 {
 699         return dptr->has_wild;
 700 }
 701
 702 int dptr_dnum(struct dptr_struct *dptr)
 703 {
 704         return dptr->dnum;
 705 }
 706
 707 bool dptr_get_priv(struct dptr_struct *dptr)
 708 {
 709         return dptr->priv;
 710 }
 711
 712 void dptr_set_priv(struct dptr_struct *dptr)
 713 {
 714         dptr->priv = true;
 715 }
 716
 717 /****************************************************************************
 718  Return the next visible file name, skipping veto'd and invisible files.
 719 ****************************************************************************/
 720
 721 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
 722                                            long *poffset, SMB_STRUCT_STAT *pst,
 723                                            char **ptalloced)
 724 {
 725         /* Normal search for the next file. */
 726         const char *name;
 727         char *talloced = NULL;
 728
 729         while ((name = ReadDirName(dptr->dir_hnd, poffset, pst, &talloced))
 730                != NULL) {
 731                 if (is_visible_file(dptr->conn,
 732                                 dptr->smb_dname->base_name,
 733                                 name,
 734                                 pst,
 735                                 true)) {
 736                         *ptalloced = talloced;
 737                         return name;
 738                 }
 739                 TALLOC_FREE(talloced);
 740         }
 741         return NULL;
 742 }
 743
 744 /****************************************************************************
 745  Return the next visible file name, skipping veto'd and invisible files.
 746 ****************************************************************************/
 747
 748 static char *dptr_ReadDirName(TALLOC_CTX *ctx,
 749                               struct dptr_struct *dptr,
 750                               long *poffset,
 751                               SMB_STRUCT_STAT *pst)
 752 {
 753         struct smb_filename smb_fname_base;
 754         char *name = NULL;
 755         const char *name_temp = NULL;
 756         char *talloced = NULL;
 757         char *pathreal = NULL;
 758         char *found_name = NULL;
 759         int ret;
 760
 761         SET_STAT_INVALID(*pst);
 762
 763         if (dptr->has_wild || dptr->did_stat) {
 764                 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst,
 765                                                     &talloced);
 766                 if (name_temp == NULL) {
 767                         return NULL;
 768                 }
 769                 if (talloced != NULL) {
 770                         return talloc_move(ctx, &talloced);
 771                 }
 772                 return talloc_strdup(ctx, name_temp);
 773         }
 774
 775         /* If poffset is -1 then we know we returned this name before and we
 776          * have no wildcards. We're at the end of the directory. */
 777         if (*poffset == END_OF_DIRECTORY_OFFSET) {
 778                 return NULL;
 779         }
 780
 781         /* We know the stored wcard contains no wildcard characters.
 782          * See if we can match with a stat call. If we can't, then set
 783          * did_stat to true to ensure we only do this once and keep
 784          * searching. */
 785
 786         dptr->did_stat = true;
 787
 788         /* First check if it should be visible. */
 789         if (!is_visible_file(dptr->conn,
 790                         dptr->smb_dname->base_name,
 791                         dptr->wcard,
 792                         pst,
 793                         true)) {
 794                 /* This only returns false if the file was found, but
 795                    is explicitly not visible. Set us to end of
 796                    directory, but return NULL as we know we can't ever
 797                    find it. */
 798                 goto ret;
 799         }
 800
 801         if (VALID_STAT(*pst)) {
 802                 name = talloc_strdup(ctx, dptr->wcard);
 803                 goto ret;
 804         }
 805
 806         pathreal = talloc_asprintf(ctx,
 807                                 "%s/%s",
 808                                 dptr->smb_dname->base_name,
 809                                 dptr->wcard);
 810         if (!pathreal)
 811                 return NULL;
 812
 813         /* Create an smb_filename with stream_name == NULL. */
 814         smb_fname_base = (struct smb_filename) { .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,
 844                                         dptr->smb_dname->base_name,
 845                                         dptr->wcard,
 846                                         ctx,
 847                                         &found_name);
 848         if (ret == 0) {
 849                 name = found_name;
 850                 goto clean;
 851         } else if (errno == ENOENT) {
 852                 /* The case-insensitive lookup was authoritative. */
 853                 goto clean;
 854         }
 855
 856         TALLOC_FREE(pathreal);
 857
 858         name_temp = dptr_normal_ReadDirName(dptr, poffset, pst, &talloced);
 859         if (name_temp == NULL) {
 860                 return NULL;
 861         }
 862         if (talloced != NULL) {
 863                 return talloc_move(ctx, &talloced);
 864         }
 865         return talloc_strdup(ctx, name_temp);
 866
 867 clean:
 868         TALLOC_FREE(pathreal);
 869 ret:
 870         /* We need to set the underlying dir_hnd offset to -1
 871          * also as this function is usually called with the
 872          * output from TellDir. */
 873         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 874         return name;
 875 }
 876
 877 /****************************************************************************
 878  Search for a file by name, skipping veto'ed and not visible files.
 879 ****************************************************************************/
 880
 881 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
 882 {
 883         SET_STAT_INVALID(*pst);
 884
 885         if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
 886                 /* This is a singleton directory and we're already at the end. */
 887                 *poffset = END_OF_DIRECTORY_OFFSET;
 888                 return False;
 889         }
 890
 891         return SearchDir(dptr->dir_hnd, name, poffset);
 892 }
 893
 894 /****************************************************************************
 895  Map a native directory offset to a 32-bit cookie.
 896 ****************************************************************************/
 897
 898 static uint32_t map_dir_offset_to_wire(struct dptr_struct *dptr, long offset)
 899 {
 900         DATA_BLOB key;
 901         DATA_BLOB val;
 902
 903         if (offset == END_OF_DIRECTORY_OFFSET) {
 904                 return WIRE_END_OF_DIRECTORY_OFFSET;
 905         } else if(offset == START_OF_DIRECTORY_OFFSET) {
 906                 return WIRE_START_OF_DIRECTORY_OFFSET;
 907         } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
 908                 return WIRE_DOT_DOT_DIRECTORY_OFFSET;
 909         }
 910         if (sizeof(long) == 4) {
 911                 /* 32-bit machine. We can cheat... */
 912                 return (uint32_t)offset;
 913         }
 914         if (dptr->dptr_cache == NULL) {
 915                 /* Lazy initialize cache. */
 916                 dptr->dptr_cache = memcache_init(dptr, 0);
 917                 if (dptr->dptr_cache == NULL) {
 918                         return WIRE_END_OF_DIRECTORY_OFFSET;
 919                 }
 920         } else {
 921                 /* Have we seen this offset before ? */
 922                 key.data = (void *)&offset;
 923                 key.length = sizeof(offset);
 924                 if (memcache_lookup(dptr->dptr_cache,
 925                                         SMB1_SEARCH_OFFSET_MAP,
 926                                         key,
 927                                         &val)) {
 928                         uint32_t wire_offset;
 929                         SMB_ASSERT(val.length == sizeof(wire_offset));
 930                         memcpy(&wire_offset, val.data, sizeof(wire_offset));
 931                         DEBUG(10,("found wire %u <-> offset %ld\n",
 932                                 (unsigned int)wire_offset,
 933                                 (long)offset));
 934                         return wire_offset;
 935                 }
 936         }
 937         /* Allocate a new wire cookie. */
 938         do {
 939                 dptr->counter++;
 940         } while (dptr->counter == WIRE_START_OF_DIRECTORY_OFFSET ||
 941                  dptr->counter == WIRE_END_OF_DIRECTORY_OFFSET ||
 942                  dptr->counter == WIRE_DOT_DOT_DIRECTORY_OFFSET);
 943         /* Store it in the cache. */
 944         key.data = (void *)&offset;
 945         key.length = sizeof(offset);
 946         val.data = (void *)&dptr->counter;
 947         val.length = sizeof(dptr->counter); /* MUST BE uint32_t ! */
 948         memcache_add(dptr->dptr_cache,
 949                         SMB1_SEARCH_OFFSET_MAP,
 950                         key,
 951                         val);
 952         /* And the reverse mapping for lookup from
 953            map_wire_to_dir_offset(). */
 954         memcache_add(dptr->dptr_cache,
 955                         SMB1_SEARCH_OFFSET_MAP,
 956                         val,
 957                         key);
 958         DEBUG(10,("stored wire %u <-> offset %ld\n",
 959                 (unsigned int)dptr->counter,
 960                 (long)offset));
 961         return dptr->counter;
 962 }
 963
 964 /****************************************************************************
 965  Fill the 5 byte server reserved dptr field.
 966 ****************************************************************************/
 967
 968 bool dptr_fill(struct smbd_server_connection *sconn,
 969                char *buf1,unsigned int key)
 970 {
 971         unsigned char *buf = (unsigned char *)buf1;
 972         struct dptr_struct *dptr = dptr_get(sconn, key, false);
 973         uint32_t wire_offset;
 974         if (!dptr) {
 975                 DEBUG(1,("filling null dirptr %d\n",key));
 976                 return(False);
 977         }
 978         wire_offset = map_dir_offset_to_wire(dptr,TellDir(dptr->dir_hnd));
 979         DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
 980                 (long)dptr->dir_hnd,(int)wire_offset));
 981         buf[0] = key;
 982         SIVAL(buf,1,wire_offset);
 983         return(True);
 984 }
 985
 986 /****************************************************************************
 987  Map a 32-bit wire cookie to a native directory offset.
 988 ****************************************************************************/
 989
 990 static long map_wire_to_dir_offset(struct dptr_struct *dptr, uint32_t wire_offset)
 991 {
 992         DATA_BLOB key;
 993         DATA_BLOB val;
 994
 995         if (wire_offset == WIRE_END_OF_DIRECTORY_OFFSET) {
 996                 return END_OF_DIRECTORY_OFFSET;
 997         } else if(wire_offset == WIRE_START_OF_DIRECTORY_OFFSET) {
 998                 return START_OF_DIRECTORY_OFFSET;
 999         } else if (wire_offset == WIRE_DOT_DOT_DIRECTORY_OFFSET) {
1000                 return DOT_DOT_DIRECTORY_OFFSET;
1001         }
1002         if (sizeof(long) == 4) {
1003                 /* 32-bit machine. We can cheat... */
1004                 return (long)wire_offset;
1005         }
1006         if (dptr->dptr_cache == NULL) {
1007                 /* Logic error, cache should be initialized. */
1008                 return END_OF_DIRECTORY_OFFSET;
1009         }
1010         key.data = (void *)&wire_offset;
1011         key.length = sizeof(wire_offset);
1012         if (memcache_lookup(dptr->dptr_cache,
1013                                 SMB1_SEARCH_OFFSET_MAP,
1014                                 key,
1015                                 &val)) {
1016                 /* Found mapping. */
1017                 long offset;
1018                 SMB_ASSERT(val.length == sizeof(offset));
1019                 memcpy(&offset, val.data, sizeof(offset));
1020                 DEBUG(10,("lookup wire %u <-> offset %ld\n",
1021                         (unsigned int)wire_offset,
1022                         (long)offset));
1023                 return offset;
1024         }
1025         return END_OF_DIRECTORY_OFFSET;
1026 }
1027
1028 /****************************************************************************
1029  Fetch the dir ptr and seek it given the 5 byte server field.
1030 ****************************************************************************/
1031
1032 struct dptr_struct *dptr_fetch(struct smbd_server_connection *sconn,
1033                                char *buf, int *num)
1034 {
1035         unsigned int key = *(unsigned char *)buf;
1036         struct dptr_struct *dptr = dptr_get(sconn, key, false);
1037         uint32_t wire_offset;
1038         long seekoff;
1039
1040         if (!dptr) {
1041                 DEBUG(3,("fetched null dirptr %d\n",key));
1042                 return(NULL);
1043         }
1044         *num = key;
1045         wire_offset = IVAL(buf,1);
1046         seekoff = map_wire_to_dir_offset(dptr, wire_offset);
1047         SeekDir(dptr->dir_hnd,seekoff);
1048         DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
1049                 key, dptr->smb_dname->base_name, (int)seekoff));
1050         return(dptr);
1051 }
1052
1053 /****************************************************************************
1054  Fetch the dir ptr.
1055 ****************************************************************************/
1056
1057 struct dptr_struct *dptr_fetch_lanman2(struct smbd_server_connection *sconn,
1058                                        int dptr_num)
1059 {
1060         struct dptr_struct *dptr  = dptr_get(sconn, dptr_num, false);
1061
1062         if (!dptr) {
1063                 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
1064                 return(NULL);
1065         }
1066         DEBUG(3,("fetching dirptr %d for path %s\n",
1067                 dptr_num,
1068                 dptr->smb_dname->base_name));
1069         return(dptr);
1070 }
1071
1072 static bool mangle_mask_match(connection_struct *conn,
1073                 const char *filename,
1074                 const char *mask)
1075 {
1076         char mname[13];
1077
1078         if (!name_to_8_3(filename,mname,False,conn->params)) {
1079                 return False;
1080         }
1081         return mask_match_search(mname,mask,False);
1082 }
1083
1084 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
1085                            struct dptr_struct *dirptr,
1086                            const char *mask,
1087                            uint32_t dirtype,
1088                            bool dont_descend,
1089                            bool ask_sharemode,
1090                            bool get_dosmode,
1091                            bool (*match_fn)(TALLOC_CTX *ctx,
1092                                             void *private_data,
1093                                             const char *dname,
1094                                             const char *mask,
1095                                             char **_fname),
1096                            bool (*mode_fn)(TALLOC_CTX *ctx,
1097                                            void *private_data,
1098                                            struct smb_filename *smb_fname,
1099                                            bool get_dosmode,
1100                                            uint32_t *_mode),
1101                            void *private_data,
1102                            char **_fname,
1103                            struct smb_filename **_smb_fname,
1104                            uint32_t *_mode,
1105                            long *_prev_offset)
1106 {
1107         connection_struct *conn = dirptr->conn;
1108         size_t slashlen;
1109         size_t pathlen;
1110         const char *dpath = dirptr->smb_dname->base_name;
1111         bool dirptr_path_is_dot = ISDOT(dpath);
1112
1113         *_smb_fname = NULL;
1114         *_mode = 0;
1115
1116         pathlen = strlen(dpath);
1117         slashlen = ( dpath[pathlen-1] != '/') ? 1 : 0;
1118
1119         while (true) {
1120                 long cur_offset;
1121                 long prev_offset;
1122                 SMB_STRUCT_STAT sbuf = { 0 };
1123                 char *dname = NULL;
1124                 bool isdots;
1125                 char *fname = NULL;
1126                 char *pathreal = NULL;
1127                 struct smb_filename smb_fname;
1128                 uint32_t mode = 0;
1129                 bool ok;
1130
1131                 cur_offset = dptr_TellDir(dirptr);
1132                 prev_offset = cur_offset;
1133                 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
1134
1135                 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
1136                         (long)dirptr, cur_offset));
1137
1138                 if (dname == NULL) {
1139                         return false;
1140                 }
1141
1142                 isdots = (ISDOT(dname) || ISDOTDOT(dname));
1143                 if (dont_descend && !isdots) {
1144                         TALLOC_FREE(dname);
1145                         continue;
1146                 }
1147
1148                 /*
1149                  * fname may get mangled, dname is never mangled.
1150                  * Whenever we're accessing the filesystem we use
1151                  * pathreal which is composed from dname.
1152                  */
1153
1154                 ok = match_fn(ctx, private_data, dname, mask, &fname);
1155                 if (!ok) {
1156                         TALLOC_FREE(dname);
1157                         continue;
1158                 }
1159
1160                 /*
1161                  * This used to be
1162                  * pathreal = talloc_asprintf(ctx, "%s%s%s", dirptr->path,
1163                  *                            needslash?"/":"", dname);
1164                  * but this was measurably slower than doing the memcpy.
1165                  */
1166
1167                 pathreal = talloc_array(
1168                         ctx, char,
1169                         pathlen + slashlen + talloc_get_size(dname));
1170                 if (!pathreal) {
1171                         TALLOC_FREE(dname);
1172                         TALLOC_FREE(fname);
1173                         return false;
1174                 }
1175
1176                 /*
1177                  * We don't want to pass ./xxx to modules below us so don't
1178                  * add the path if it is just . by itself.
1179                  */
1180                 if (dirptr_path_is_dot) {
1181                         memcpy(pathreal, dname, talloc_get_size(dname));
1182                 } else {
1183                         memcpy(pathreal, dpath, pathlen);
1184                         pathreal[pathlen] = '/';
1185                         memcpy(pathreal + slashlen + pathlen, dname,
1186                                talloc_get_size(dname));
1187                 }
1188
1189                 /* Create smb_fname with NULL stream_name. */
1190                 smb_fname = (struct smb_filename) {
1191                         .base_name = pathreal, .st = sbuf
1192                 };
1193
1194                 ok = mode_fn(ctx, private_data, &smb_fname, get_dosmode, &mode);
1195                 if (!ok) {
1196                         TALLOC_FREE(dname);
1197                         TALLOC_FREE(fname);
1198                         TALLOC_FREE(pathreal);
1199                         continue;
1200                 }
1201
1202                 if (!dir_check_ftype(mode, dirtype)) {
1203                         DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1204                                 fname, (unsigned int)mode, (unsigned int)dirtype));
1205                         TALLOC_FREE(dname);
1206                         TALLOC_FREE(fname);
1207                         TALLOC_FREE(pathreal);
1208                         continue;
1209                 }
1210
1211                 if (ask_sharemode) {
1212                         struct timespec write_time_ts;
1213                         struct file_id fileid;
1214
1215                         fileid = vfs_file_id_from_sbuf(conn,
1216                                                        &smb_fname.st);
1217                         get_file_infos(fileid, 0, NULL, &write_time_ts);
1218                         if (!null_timespec(write_time_ts)) {
1219                                 update_stat_ex_mtime(&smb_fname.st,
1220                                                      write_time_ts);
1221                         }
1222                 }
1223
1224                 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1225                         "fname=%s (%s)\n",
1226                         mask, smb_fname_str_dbg(&smb_fname),
1227                         dname, fname));
1228
1229                 if (!conn->sconn->using_smb2) {
1230                         /*
1231                          * The dircache is only needed for SMB1 because SMB1
1232                          * uses a name for the resume wheras SMB2 always
1233                          * continues from the next position (unless it's told to
1234                          * restart or close-and-reopen the listing).
1235                          */
1236                         DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
1237                 }
1238
1239                 TALLOC_FREE(dname);
1240
1241                 *_smb_fname = cp_smb_filename(ctx, &smb_fname);
1242                 TALLOC_FREE(pathreal);
1243                 if (*_smb_fname == NULL) {
1244                         return false;
1245                 }
1246                 *_fname = fname;
1247                 *_mode = mode;
1248                 *_prev_offset = prev_offset;
1249
1250                 return true;
1251         }
1252
1253         return false;
1254 }
1255
1256 /****************************************************************************
1257  Get an 8.3 directory entry.
1258 ****************************************************************************/
1259
1260 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1261                                      void *private_data,
1262                                      const char *dname,
1263                                      const char *mask,
1264                                      char **_fname)
1265 {
1266         connection_struct *conn = (connection_struct *)private_data;
1267
1268         if ((strcmp(mask,"*.*") == 0) ||
1269             mask_match_search(dname, mask, false) ||
1270             mangle_mask_match(conn, dname, mask)) {
1271                 char mname[13];
1272                 const char *fname;
1273                 /*
1274                  * Ensure we can push the original name as UCS2. If
1275                  * not, then just don't return this name.
1276                  */
1277                 NTSTATUS status;
1278                 size_t ret_len = 0;
1279                 size_t len = (strlen(dname) + 2) * 4; /* Allow enough space. */
1280                 uint8_t *tmp = talloc_array(talloc_tos(),
1281                                         uint8_t,
1282                                         len);
1283
1284                 status = srvstr_push(NULL,
1285                         FLAGS2_UNICODE_STRINGS,
1286                         tmp,
1287                         dname,
1288                         len,
1289                         STR_TERMINATE,
1290                         &ret_len);
1291
1292                 TALLOC_FREE(tmp);
1293
1294                 if (!NT_STATUS_IS_OK(status)) {
1295                         return false;
1296                 }
1297
1298                 if (!mangle_is_8_3(dname, false, conn->params)) {
1299                         bool ok = name_to_8_3(dname, mname, false,
1300                                               conn->params);
1301                         if (!ok) {
1302                                 return false;
1303                         }
1304                         fname = mname;
1305                 } else {
1306                         fname = dname;
1307                 }
1308
1309                 *_fname = talloc_strdup(ctx, fname);
1310                 if (*_fname == NULL) {
1311                         return false;
1312                 }
1313
1314                 return true;
1315         }
1316
1317         return false;
1318 }
1319
1320 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1321                                     void *private_data,
1322                                     struct smb_filename *smb_fname,
1323                                     bool get_dosmode,
1324                                     uint32_t *_mode)
1325 {
1326         connection_struct *conn = (connection_struct *)private_data;
1327
1328         if (!VALID_STAT(smb_fname->st)) {
1329                 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1330                         DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1331                                  "Couldn't stat [%s]. Error "
1332                                  "= %s\n",
1333                                  smb_fname_str_dbg(smb_fname),
1334                                  strerror(errno)));
1335                         return false;
1336                 }
1337         }
1338
1339         *_mode = dos_mode(conn, smb_fname);
1340         return true;
1341 }
1342
1343 bool get_dir_entry(TALLOC_CTX *ctx,
1344                 struct dptr_struct *dirptr,
1345                 const char *mask,
1346                 uint32_t dirtype,
1347                 char **_fname,
1348                 off_t *_size,
1349                 uint32_t *_mode,
1350                 struct timespec *_date,
1351                 bool check_descend,
1352                 bool ask_sharemode)
1353 {
1354         connection_struct *conn = dirptr->conn;
1355         char *fname = NULL;
1356         struct smb_filename *smb_fname = NULL;
1357         uint32_t mode = 0;
1358         long prev_offset;
1359         bool ok;
1360
1361         ok = smbd_dirptr_get_entry(ctx,
1362                                    dirptr,
1363                                    mask,
1364                                    dirtype,
1365                                    check_descend,
1366                                    ask_sharemode,
1367                                    true,
1368                                    smbd_dirptr_8_3_match_fn,
1369                                    smbd_dirptr_8_3_mode_fn,
1370                                    conn,
1371                                    &fname,
1372                                    &smb_fname,
1373                                    &mode,
1374                                    &prev_offset);
1375         if (!ok) {
1376                 return false;
1377         }
1378
1379         *_fname = talloc_move(ctx, &fname);
1380         *_size = smb_fname->st.st_ex_size;
1381         *_mode = mode;
1382         *_date = smb_fname->st.st_ex_mtime;
1383         TALLOC_FREE(smb_fname);
1384         return true;
1385 }
1386
1387 /*******************************************************************
1388  Check to see if a user can read a file. This is only approximate,
1389  it is used as part of the "hide unreadable" option. Don't
1390  use it for anything security sensitive.
1391 ********************************************************************/
1392
1393 static bool user_can_read_file(connection_struct *conn,
1394                                struct smb_filename *smb_fname)
1395 {
1396         NTSTATUS status;
1397         uint32_t rejected_share_access = 0;
1398         uint32_t rejected_mask = 0;
1399         struct security_descriptor *sd = NULL;
1400         uint32_t access_mask = FILE_READ_DATA|
1401                                 FILE_READ_EA|
1402                                 FILE_READ_ATTRIBUTES|
1403                                 SEC_STD_READ_CONTROL;
1404
1405         /*
1406          * Never hide files from the root user.
1407          * We use (uid_t)0 here not sec_initial_uid()
1408          * as make test uses a single user context.
1409          */
1410
1411         if (get_current_uid(conn) == (uid_t)0) {
1412                 return True;
1413         }
1414
1415         /*
1416          * We can't directly use smbd_check_access_rights()
1417          * here, as this implicitly grants FILE_READ_ATTRIBUTES
1418          * which the Windows access-based-enumeration code
1419          * explicitly checks for on the file security descriptor.
1420          * See bug:
1421          *
1422          * https://bugzilla.samba.org/show_bug.cgi?id=10252
1423          *
1424          * and the smb2.acl2.ACCESSBASED test for details.
1425          */
1426
1427         rejected_share_access = access_mask & ~(conn->share_access);
1428         if (rejected_share_access) {
1429                 DEBUG(10, ("rejected share access 0x%x "
1430                         "on %s (0x%x)\n",
1431                         (unsigned int)access_mask,
1432                         smb_fname_str_dbg(smb_fname),
1433                         (unsigned int)rejected_share_access ));
1434                 return false;
1435         }
1436
1437         status = SMB_VFS_GET_NT_ACL(conn,
1438                         smb_fname,
1439                         (SECINFO_OWNER |
1440                          SECINFO_GROUP |
1441                          SECINFO_DACL),
1442                         talloc_tos(),
1443                         &sd);
1444
1445         if (!NT_STATUS_IS_OK(status)) {
1446                 DEBUG(10, ("Could not get acl "
1447                         "on %s: %s\n",
1448                         smb_fname_str_dbg(smb_fname),
1449                         nt_errstr(status)));
1450                 return false;
1451         }
1452
1453         status = se_file_access_check(sd,
1454                                 get_current_nttok(conn),
1455                                 false,
1456                                 access_mask,
1457                                 &rejected_mask);
1458
1459         TALLOC_FREE(sd);
1460
1461         if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
1462                 DEBUG(10,("rejected bits 0x%x read access for %s\n",
1463                         (unsigned int)rejected_mask,
1464                         smb_fname_str_dbg(smb_fname) ));
1465                 return false;
1466         }
1467         return true;
1468 }
1469
1470 /*******************************************************************
1471  Check to see if a user can write a file (and only files, we do not
1472  check dirs on this one). This is only approximate,
1473  it is used as part of the "hide unwriteable" option. Don't
1474  use it for anything security sensitive.
1475 ********************************************************************/
1476
1477 static bool user_can_write_file(connection_struct *conn,
1478                                 const struct smb_filename *smb_fname)
1479 {
1480         /*
1481          * Never hide files from the root user.
1482          * We use (uid_t)0 here not sec_initial_uid()
1483          * as make test uses a single user context.
1484          */
1485
1486         if (get_current_uid(conn) == (uid_t)0) {
1487                 return True;
1488         }
1489
1490         SMB_ASSERT(VALID_STAT(smb_fname->st));
1491
1492         /* Pseudo-open the file */
1493
1494         if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1495                 return True;
1496         }
1497
1498         return can_write_to_file(conn, smb_fname);
1499 }
1500
1501 /*******************************************************************
1502   Is a file a "special" type ?
1503 ********************************************************************/
1504
1505 static bool file_is_special(connection_struct *conn,
1506                             const struct smb_filename *smb_fname)
1507 {
1508         /*
1509          * Never hide files from the root user.
1510          * We use (uid_t)0 here not sec_initial_uid()
1511          * as make test uses a single user context.
1512          */
1513
1514         if (get_current_uid(conn) == (uid_t)0) {
1515                 return False;
1516         }
1517
1518         SMB_ASSERT(VALID_STAT(smb_fname->st));
1519
1520         if (S_ISREG(smb_fname->st.st_ex_mode) ||
1521             S_ISDIR(smb_fname->st.st_ex_mode) ||
1522             S_ISLNK(smb_fname->st.st_ex_mode))
1523                 return False;
1524
1525         return True;
1526 }
1527
1528 /*******************************************************************
1529  Should the file be seen by the client?
1530  NOTE: A successful return is no guarantee of the file's existence.
1531 ********************************************************************/
1532
1533 bool is_visible_file(connection_struct *conn, const char *dir_path,
1534                      const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1535 {
1536         bool hide_unreadable = lp_hide_unreadable(SNUM(conn));
1537         bool hide_unwriteable = lp_hide_unwriteable_files(SNUM(conn));
1538         bool hide_special = lp_hide_special_files(SNUM(conn));
1539         char *entry = NULL;
1540         struct smb_filename *smb_fname_base = NULL;
1541         bool ret = false;
1542
1543         if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1544                 return True; /* . and .. are always visible. */
1545         }
1546
1547         /* If it's a vetoed file, pretend it doesn't even exist */
1548         if (use_veto && IS_VETO_PATH(conn, name)) {
1549                 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1550                 return False;
1551         }
1552
1553         if (hide_unreadable || hide_unwriteable || hide_special) {
1554                 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1555                 if (!entry) {
1556                         ret = false;
1557                         goto out;
1558                 }
1559
1560                 /* Create an smb_filename with stream_name == NULL. */
1561                 smb_fname_base = synthetic_smb_fname(talloc_tos(),
1562                                                 entry,
1563                                                 NULL,
1564                                                 pst,
1565                                                 0);
1566                 if (smb_fname_base == NULL) {
1567                         ret = false;
1568                         goto out;
1569                 }
1570
1571                 /* If the file name does not exist, there's no point checking
1572                  * the configuration options. We succeed, on the basis that the
1573                  * checks *might* have passed if the file was present.
1574                  */
1575                 if (!VALID_STAT(*pst)) {
1576                         if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1577                                 ret = true;
1578                                 goto out;
1579                         }
1580                         *pst = smb_fname_base->st;
1581                 }
1582
1583                 /* Honour _hide unreadable_ option */
1584                 if (hide_unreadable &&
1585                     !user_can_read_file(conn, smb_fname_base)) {
1586                         DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1587                                  entry ));
1588                         ret = false;
1589                         goto out;
1590                 }
1591                 /* Honour _hide unwriteable_ option */
1592                 if (hide_unwriteable && !user_can_write_file(conn,
1593                                                              smb_fname_base)) {
1594                         DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1595                                  entry ));
1596                         ret = false;
1597                         goto out;
1598                 }
1599                 /* Honour _hide_special_ option */
1600                 if (hide_special && file_is_special(conn, smb_fname_base)) {
1601                         DEBUG(10,("is_visible_file: file %s is special.\n",
1602                                  entry ));
1603                         ret = false;
1604                         goto out;
1605                 }
1606         }
1607
1608         ret = true;
1609  out:
1610         TALLOC_FREE(smb_fname_base);
1611         TALLOC_FREE(entry);
1612         return ret;
1613 }
1614
1615 static int smb_Dir_destructor(struct smb_Dir *dirp)
1616 {
1617         if (dirp->dir != NULL) {
1618                 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1619                 if (dirp->fsp != NULL) {
1620                         /*
1621                          * The SMB_VFS_CLOSEDIR above
1622                          * closes the underlying fd inside
1623                          * dirp->fsp.
1624                          */
1625                         dirp->fsp->fh->fd = -1;
1626                         if (dirp->fsp->dptr != NULL) {
1627                                 SMB_ASSERT(dirp->fsp->dptr->dir_hnd == dirp);
1628                                 dirp->fsp->dptr->dir_hnd = NULL;
1629                         }
1630                         dirp->fsp = NULL;
1631                 }
1632         }
1633         if (dirp->conn->sconn && !dirp->conn->sconn->using_smb2) {
1634                 dirp->conn->sconn->searches.dirhandles_open--;
1635         }
1636         return 0;
1637 }
1638
1639 /*******************************************************************
1640  Open a directory.
1641 ********************************************************************/
1642
1643 static struct smb_Dir *OpenDir_internal(TALLOC_CTX *mem_ctx,
1644                         connection_struct *conn,
1645                         const struct smb_filename *smb_dname,
1646                         const char *mask,
1647                         uint32_t attr)
1648 {
1649         struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1650         struct smbd_server_connection *sconn = conn->sconn;
1651
1652         if (!dirp) {
1653                 return NULL;
1654         }
1655
1656         dirp->dir = SMB_VFS_OPENDIR(conn, smb_dname, mask, attr);
1657
1658         if (!dirp->dir) {
1659                 DEBUG(5,("OpenDir: Can't open %s. %s\n",
1660                         smb_dname->base_name,
1661                         strerror(errno) ));
1662                 goto fail;
1663         }
1664
1665         dirp->conn = conn;
1666
1667         if (!conn->sconn->using_smb2) {
1668                 /*
1669                  * The dircache is only needed for SMB1 because SMB1 uses a name
1670                  * for the resume wheras SMB2 always continues from the next
1671                  * position (unless it's told to restart or close-and-reopen the
1672                  * listing).
1673                  */
1674                 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1675         }
1676
1677         if (sconn && !sconn->using_smb2) {
1678                 sconn->searches.dirhandles_open++;
1679         }
1680         talloc_set_destructor(dirp, smb_Dir_destructor);
1681
1682         return dirp;
1683
1684   fail:
1685         TALLOC_FREE(dirp);
1686         return NULL;
1687 }
1688
1689 /****************************************************************************
1690  Open a directory handle by pathname, ensuring it's under the share path.
1691 ****************************************************************************/
1692
1693 static struct smb_Dir *open_dir_safely(TALLOC_CTX *ctx,
1694                                         connection_struct *conn,
1695                                         const struct smb_filename *smb_dname,
1696                                         const char *wcard,
1697                                         uint32_t attr)
1698 {
1699         struct smb_Dir *dir_hnd = NULL;
1700         struct smb_filename *smb_fname_cwd = NULL;
1701         struct smb_filename *saved_dir_fname = vfs_GetWd(ctx, conn);
1702         NTSTATUS status;
1703
1704         if (saved_dir_fname == NULL) {
1705                 return NULL;
1706         }
1707
1708         if (vfs_ChDir(conn, smb_dname) == -1) {
1709                 goto out;
1710         }
1711
1712         smb_fname_cwd = synthetic_smb_fname(talloc_tos(),
1713                                         ".",
1714                                         NULL,
1715                                         NULL,
1716                                         smb_dname->flags);
1717         if (smb_fname_cwd == NULL) {
1718                 goto out;
1719         }
1720
1721         /*
1722          * Now the directory is pinned, use
1723          * REALPATH to ensure we can access it.
1724          */
1725         status = check_name(conn, smb_fname_cwd);
1726         if (!NT_STATUS_IS_OK(status)) {
1727                 goto out;
1728         }
1729
1730         dir_hnd = OpenDir_internal(ctx,
1731                                 conn,
1732                                 smb_fname_cwd,
1733                                 wcard,
1734                                 attr);
1735
1736         if (dir_hnd == NULL) {
1737                 goto out;
1738         }
1739
1740         /*
1741          * OpenDir_internal only gets "." as the dir name.
1742          * Store the real dir name here.
1743          */
1744
1745         dir_hnd->dir_smb_fname = cp_smb_filename(dir_hnd, smb_dname);
1746         if (!dir_hnd->dir_smb_fname) {
1747                 TALLOC_FREE(dir_hnd);
1748                 errno = ENOMEM;
1749         }
1750
1751   out:
1752
1753         vfs_ChDir(conn, saved_dir_fname);
1754         TALLOC_FREE(saved_dir_fname);
1755         return dir_hnd;
1756 }
1757
1758 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1759                         const struct smb_filename *smb_dname,
1760                         const char *mask,
1761                         uint32_t attr)
1762 {
1763         return open_dir_safely(mem_ctx,
1764                                 conn,
1765                                 smb_dname,
1766                                 mask,
1767                                 attr);
1768 }
1769
1770 /*******************************************************************
1771  Open a directory from an fsp.
1772 ********************************************************************/
1773
1774 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
1775                         files_struct *fsp,
1776                         const char *mask,
1777                         uint32_t attr)
1778 {
1779         struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1780         struct smbd_server_connection *sconn = conn->sconn;
1781
1782         if (!dirp) {
1783                 goto fail;
1784         }
1785
1786         if (!fsp->is_directory) {
1787                 errno = EBADF;
1788                 goto fail;
1789         }
1790
1791         if (fsp->fh->fd == -1) {
1792                 errno = EBADF;
1793                 goto fail;
1794         }
1795
1796         dirp->conn = conn;
1797
1798         if (!conn->sconn->using_smb2) {
1799                 /*
1800                  * The dircache is only needed for SMB1 because SMB1 uses a name
1801                  * for the resume wheras SMB2 always continues from the next
1802                  * position (unless it's told to restart or close-and-reopen the
1803                  * listing).
1804                  */
1805                 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1806         }
1807
1808         dirp->dir_smb_fname = cp_smb_filename(dirp, fsp->fsp_name);
1809         if (!dirp->dir_smb_fname) {
1810                 errno = ENOMEM;
1811                 goto fail;
1812         }
1813
1814         dirp->dir = SMB_VFS_FDOPENDIR(fsp, mask, attr);
1815         if (dirp->dir != NULL) {
1816                 dirp->fsp = fsp;
1817         } else {
1818                 DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1819                         "NULL (%s)\n",
1820                         dirp->dir_smb_fname->base_name,
1821                         strerror(errno)));
1822                 if (errno != ENOSYS) {
1823                         goto fail;
1824                 }
1825         }
1826
1827         if (dirp->dir == NULL) {
1828                 /* FDOPENDIR is not supported. Use OPENDIR instead. */
1829                 TALLOC_FREE(dirp);
1830                 return open_dir_safely(mem_ctx,
1831                                         conn,
1832                                         fsp->fsp_name,
1833                                         mask,
1834                                         attr);
1835         }
1836
1837         if (sconn && !sconn->using_smb2) {
1838                 sconn->searches.dirhandles_open++;
1839         }
1840         talloc_set_destructor(dirp, smb_Dir_destructor);
1841
1842         return dirp;
1843
1844   fail:
1845         TALLOC_FREE(dirp);
1846         return NULL;
1847 }
1848
1849
1850 /*******************************************************************
1851  Read from a directory.
1852  Return directory entry, current offset, and optional stat information.
1853  Don't check for veto or invisible files.
1854 ********************************************************************/
1855
1856 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1857                         SMB_STRUCT_STAT *sbuf, char **ptalloced)
1858 {
1859         const char *n;
1860         char *talloced = NULL;
1861         connection_struct *conn = dirp->conn;
1862
1863         /* Cheat to allow . and .. to be the first entries returned. */
1864         if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1865              (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1866         {
1867                 if (dirp->file_number == 0) {
1868                         n = ".";
1869                         *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1870                 } else {
1871                         n = "..";
1872                         *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1873                 }
1874                 dirp->file_number++;
1875                 *ptalloced = NULL;
1876                 return n;
1877         }
1878
1879         if (*poffset == END_OF_DIRECTORY_OFFSET) {
1880                 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1881                 return NULL;
1882         }
1883
1884         /* A real offset, seek to it. */
1885         SeekDir(dirp, *poffset);
1886
1887         while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1888                 /* Ignore . and .. - we've already returned them. */
1889                 if (*n == '.') {
1890                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1891                                 TALLOC_FREE(talloced);
1892                                 continue;
1893                         }
1894                 }
1895                 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1896                 *ptalloced = talloced;
1897                 dirp->file_number++;
1898                 return n;
1899         }
1900         *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1901         *ptalloced = NULL;
1902         return NULL;
1903 }
1904
1905 /*******************************************************************
1906  Rewind to the start.
1907 ********************************************************************/
1908
1909 void RewindDir(struct smb_Dir *dirp, long *poffset)
1910 {
1911         SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1912         dirp->file_number = 0;
1913         dirp->offset = START_OF_DIRECTORY_OFFSET;
1914         *poffset = START_OF_DIRECTORY_OFFSET;
1915 }
1916
1917 /*******************************************************************
1918  Seek a dir.
1919 ********************************************************************/
1920
1921 void SeekDir(struct smb_Dir *dirp, long offset)
1922 {
1923         if (offset != dirp->offset) {
1924                 if (offset == START_OF_DIRECTORY_OFFSET) {
1925                         RewindDir(dirp, &offset);
1926                         /*
1927                          * Ok we should really set the file number here
1928                          * to 1 to enable ".." to be returned next. Trouble
1929                          * is I'm worried about callers using SeekDir(dirp,0)
1930                          * as equivalent to RewindDir(). So leave this alone
1931                          * for now.
1932                          */
1933                 } else if  (offset == DOT_DOT_DIRECTORY_OFFSET) {
1934                         RewindDir(dirp, &offset);
1935                         /*
1936                          * Set the file number to 2 - we want to get the first
1937                          * real file entry (the one we return after "..")
1938                          * on the next ReadDir.
1939                          */
1940                         dirp->file_number = 2;
1941                 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1942                         ; /* Don't seek in this case. */
1943                 } else {
1944                         SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1945                 }
1946                 dirp->offset = offset;
1947         }
1948 }
1949
1950 /*******************************************************************
1951  Tell a dir position.
1952 ********************************************************************/
1953
1954 long TellDir(struct smb_Dir *dirp)
1955 {
1956         return(dirp->offset);
1957 }
1958
1959 /*******************************************************************
1960  Add an entry into the dcache.
1961 ********************************************************************/
1962
1963 static void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1964 {
1965         struct name_cache_entry *e;
1966
1967         if (dirp->name_cache_size == 0) {
1968                 return;
1969         }
1970
1971         if (dirp->name_cache == NULL) {
1972                 dirp->name_cache = talloc_zero_array(
1973                         dirp, struct name_cache_entry, dirp->name_cache_size);
1974
1975                 if (dirp->name_cache == NULL) {
1976                         return;
1977                 }
1978         }
1979
1980         dirp->name_cache_index = (dirp->name_cache_index+1) %
1981                                         dirp->name_cache_size;
1982         e = &dirp->name_cache[dirp->name_cache_index];
1983         TALLOC_FREE(e->name);
1984         e->name = talloc_strdup(dirp, name);
1985         e->offset = offset;
1986 }
1987
1988 /*******************************************************************
1989  Find an entry by name. Leave us at the offset after it.
1990  Don't check for veto or invisible files.
1991 ********************************************************************/
1992
1993 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1994 {
1995         int i;
1996         const char *entry = NULL;
1997         char *talloced = NULL;
1998         connection_struct *conn = dirp->conn;
1999
2000         /* Search back in the name cache. */
2001         if (dirp->name_cache_size && dirp->name_cache) {
2002                 for (i = dirp->name_cache_index; i >= 0; i--) {
2003                         struct name_cache_entry *e = &dirp->name_cache[i];
2004                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
2005                                 *poffset = e->offset;
2006                                 SeekDir(dirp, e->offset);
2007                                 return True;
2008                         }
2009                 }
2010                 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
2011                         struct name_cache_entry *e = &dirp->name_cache[i];
2012                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
2013                                 *poffset = e->offset;
2014                                 SeekDir(dirp, e->offset);
2015                                 return True;
2016                         }
2017                 }
2018         }
2019
2020         /* Not found in the name cache. Rewind directory and start from scratch. */
2021         SMB_VFS_REWINDDIR(conn, dirp->dir);
2022         dirp->file_number = 0;
2023         *poffset = START_OF_DIRECTORY_OFFSET;
2024         while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
2025                 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
2026                         TALLOC_FREE(talloced);
2027                         return True;
2028                 }
2029                 TALLOC_FREE(talloced);
2030         }
2031         return False;
2032 }
2033
2034 struct files_below_forall_state {
2035         char *dirpath;
2036         size_t dirpath_len;
2037         int (*fn)(struct file_id fid, const struct share_mode_data *data,
2038                   void *private_data);
2039         void *private_data;
2040 };
2041
2042 static int files_below_forall_fn(struct file_id fid,
2043                                  const struct share_mode_data *data,
2044                                  void *private_data)
2045 {
2046         struct files_below_forall_state *state = private_data;
2047         char tmpbuf[PATH_MAX];
2048         char *fullpath, *to_free;
2049         size_t len;
2050
2051         len = full_path_tos(data->servicepath, data->base_name,
2052                             tmpbuf, sizeof(tmpbuf),
2053                             &fullpath, &to_free);
2054         if (len == -1) {
2055                 return 0;
2056         }
2057         if (state->dirpath_len >= len) {
2058                 /*
2059                  * Filter files above dirpath
2060                  */
2061                 goto out;
2062         }
2063         if (fullpath[state->dirpath_len] != '/') {
2064                 /*
2065                  * Filter file that don't have a path separator at the end of
2066                  * dirpath's length
2067                  */
2068                 goto out;
2069         }
2070
2071         if (memcmp(state->dirpath, fullpath, state->dirpath_len) != 0) {
2072                 /*
2073                  * Not a parent
2074                  */
2075                 goto out;
2076         }
2077
2078         TALLOC_FREE(to_free);
2079         return state->fn(fid, data, state->private_data);
2080
2081 out:
2082         TALLOC_FREE(to_free);
2083         return 0;
2084 }
2085
2086 static int files_below_forall(connection_struct *conn,
2087                               const struct smb_filename *dir_name,
2088                               int (*fn)(struct file_id fid,
2089                                         const struct share_mode_data *data,
2090                                         void *private_data),
2091                               void *private_data)
2092 {
2093         struct files_below_forall_state state = {
2094                         .fn = fn,
2095                         .private_data = private_data,
2096         };
2097         int ret;
2098         char tmpbuf[PATH_MAX];
2099         char *to_free;
2100
2101         state.dirpath_len = full_path_tos(conn->connectpath,
2102                                           dir_name->base_name,
2103                                           tmpbuf, sizeof(tmpbuf),
2104                                           &state.dirpath, &to_free);
2105         if (state.dirpath_len == -1) {
2106                 return -1;
2107         }
2108
2109         ret = share_mode_forall(files_below_forall_fn, &state);
2110         TALLOC_FREE(to_free);
2111         return ret;
2112 }
2113
2114 struct have_file_open_below_state {
2115         bool found_one;
2116 };
2117
2118 static int have_file_open_below_fn(struct file_id fid,
2119                                    const struct share_mode_data *data,
2120                                    void *private_data)
2121 {
2122         struct have_file_open_below_state *state = private_data;
2123         state->found_one = true;
2124         return 1;
2125 }
2126
2127 bool have_file_open_below(connection_struct *conn,
2128                                  const struct smb_filename *name)
2129 {
2130         struct have_file_open_below_state state = {
2131                 .found_one = false,
2132         };
2133         int ret;
2134
2135         if (!VALID_STAT(name->st)) {
2136                 return false;
2137         }
2138         if (!S_ISDIR(name->st.st_ex_mode)) {
2139                 return false;
2140         }
2141
2142         ret = files_below_forall(conn, name, have_file_open_below_fn, &state);
2143         if (ret == -1) {
2144                 return false;
2145         }
2146
2147         return state.found_one;
2148 }
2149
2150 /*****************************************************************
2151  Is this directory empty ?
2152 *****************************************************************/
2153
2154 NTSTATUS can_delete_directory_fsp(files_struct *fsp)
2155 {
2156         NTSTATUS status = NT_STATUS_OK;
2157         long dirpos = 0;
2158         const char *dname = NULL;
2159         const char *dirname = fsp->fsp_name->base_name;
2160         char *talloced = NULL;
2161         SMB_STRUCT_STAT st;
2162         struct connection_struct *conn = fsp->conn;
2163         struct smb_Dir *dir_hnd = OpenDir(talloc_tos(),
2164                                         conn,
2165                                         fsp->fsp_name,
2166                                         NULL,
2167                                         0);
2168
2169         if (!dir_hnd) {
2170                 return map_nt_error_from_unix(errno);
2171         }
2172
2173         while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
2174                 /* Quick check for "." and ".." */
2175                 if (dname[0] == '.') {
2176                         if (!dname[1] || (dname[1] == '.' && !dname[2])) {
2177                                 TALLOC_FREE(talloced);
2178                                 continue;
2179                         }
2180                 }
2181
2182                 if (!is_visible_file(conn, dirname, dname, &st, True)) {
2183                         TALLOC_FREE(talloced);
2184                         continue;
2185                 }
2186
2187                 DEBUG(10,("got name %s - can't delete\n",
2188                          dname ));
2189                 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
2190                 break;
2191         }
2192         TALLOC_FREE(talloced);
2193         TALLOC_FREE(dir_hnd);
2194
2195         if (!NT_STATUS_IS_OK(status)) {
2196                 return status;
2197         }
2198
2199         if (!(fsp->posix_flags & FSP_POSIX_FLAGS_RENAME) &&
2200             lp_strict_rename(SNUM(conn)) &&
2201             have_file_open_below(fsp->conn, fsp->fsp_name))
2202         {
2203                 return NT_STATUS_ACCESS_DENIED;
2204         }
2205
2206         return NT_STATUS_OK;
2207 }