source/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
  23 /*
  24    This module implements directory related functions for Samba.
  25 */
  26
  27 extern struct current_user current_user;
  28
  29 /* "Special" directory offsets. */
  30 #define END_OF_DIRECTORY_OFFSET ((long)-1)
  31 #define START_OF_DIRECTORY_OFFSET ((long)0)
  32 #define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
  33
  34 /* Make directory handle internals available. */
  35
  36 struct name_cache_entry {
  37         char *name;
  38         long offset;
  39 };
  40
  41 struct smb_Dir {
  42         connection_struct *conn;
  43         SMB_STRUCT_DIR *dir;
  44         long offset;
  45         char *dir_path;
  46         size_t name_cache_size;
  47         struct name_cache_entry *name_cache;
  48         unsigned int name_cache_index;
  49         unsigned int file_number;
  50 };
  51
  52 struct dptr_struct {
  53         struct dptr_struct *next, *prev;
  54         int dnum;
  55         uint16 spid;
  56         struct connection_struct *conn;
  57         struct smb_Dir *dir_hnd;
  58         bool expect_close;
  59         char *wcard;
  60         uint32 attr;
  61         char *path;
  62         bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
  63         bool did_stat; /* Optimisation for non-wcard searches. */
  64 };
  65
  66 static struct bitmap *dptr_bmap;
  67 static struct dptr_struct *dirptrs;
  68 static int dirhandles_open = 0;
  69
  70 #define INVALID_DPTR_KEY (-3)
  71
  72 /****************************************************************************
  73  Make a dir struct.
  74 ****************************************************************************/
  75
  76 bool make_dir_struct(TALLOC_CTX *ctx,
  77                         char *buf,
  78                         const char *mask,
  79                         const char *fname,
  80                         SMB_OFF_T size,
  81                         uint32 mode,
  82                         time_t date,
  83                         bool uc)
  84 {
  85         char *p;
  86         char *mask2 = talloc_strdup(ctx, mask);
  87
  88         if (!mask2) {
  89                 return False;
  90         }
  91
  92         if ((mode & aDIR) != 0) {
  93                 size = 0;
  94         }
  95
  96         memset(buf+1,' ',11);
  97         if ((p = strchr_m(mask2,'.')) != NULL) {
  98                 *p = 0;
  99                 push_ascii(buf+1,mask2,8, 0);
 100                 push_ascii(buf+9,p+1,3, 0);
 101                 *p = '.';
 102         } else {
 103                 push_ascii(buf+1,mask2,11, 0);
 104         }
 105
 106         memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
 107         SCVAL(buf,21,mode);
 108         srv_put_dos_date(buf,22,date);
 109         SSVAL(buf,26,size & 0xFFFF);
 110         SSVAL(buf,28,(size >> 16)&0xFFFF);
 111         /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
 112            Strange, but verified on W2K3. Needed for OS/2. JRA. */
 113         push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
 114         DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
 115         return True;
 116 }
 117
 118 /****************************************************************************
 119  Initialise the dir bitmap.
 120 ****************************************************************************/
 121
 122 void init_dptrs(void)
 123 {
 124         static bool dptrs_init=False;
 125
 126         if (dptrs_init)
 127                 return;
 128
 129         dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
 130
 131         if (!dptr_bmap)
 132                 exit_server("out of memory in init_dptrs");
 133
 134         dptrs_init = True;
 135 }
 136
 137 /****************************************************************************
 138  Idle a dptr - the directory is closed but the control info is kept.
 139 ****************************************************************************/
 140
 141 static void dptr_idle(struct dptr_struct *dptr)
 142 {
 143         if (dptr->dir_hnd) {
 144                 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
 145                 TALLOC_FREE(dptr->dir_hnd);
 146         }
 147 }
 148
 149 /****************************************************************************
 150  Idle the oldest dptr.
 151 ****************************************************************************/
 152
 153 static void dptr_idleoldest(void)
 154 {
 155         struct dptr_struct *dptr;
 156
 157         /*
 158          * Go to the end of the list.
 159          */
 160         for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
 161                 ;
 162
 163         if(!dptr) {
 164                 DEBUG(0,("No dptrs available to idle ?\n"));
 165                 return;
 166         }
 167
 168         /*
 169          * Idle the oldest pointer.
 170          */
 171
 172         for(; dptr; dptr = dptr->prev) {
 173                 if (dptr->dir_hnd) {
 174                         dptr_idle(dptr);
 175                         return;
 176                 }
 177         }
 178 }
 179
 180 /****************************************************************************
 181  Get the struct dptr_struct for a dir index.
 182 ****************************************************************************/
 183
 184 static struct dptr_struct *dptr_get(int key, bool forclose)
 185 {
 186         struct dptr_struct *dptr;
 187
 188         for(dptr = dirptrs; dptr; dptr = dptr->next) {
 189                 if(dptr->dnum == key) {
 190                         if (!forclose && !dptr->dir_hnd) {
 191                                 if (dirhandles_open >= MAX_OPEN_DIRECTORIES)
 192                                         dptr_idleoldest();
 193                                 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
 194                                 if (!(dptr->dir_hnd = OpenDir(
 195                                               NULL, dptr->conn, dptr->path,
 196                                               dptr->wcard, dptr->attr))) {
 197                                         DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
 198                                                 strerror(errno)));
 199                                         return False;
 200                                 }
 201                         }
 202                         DLIST_PROMOTE(dirptrs,dptr);
 203                         return dptr;
 204                 }
 205         }
 206         return(NULL);
 207 }
 208
 209 /****************************************************************************
 210  Get the dir path for a dir index.
 211 ****************************************************************************/
 212
 213 char *dptr_path(int key)
 214 {
 215         struct dptr_struct *dptr = dptr_get(key, False);
 216         if (dptr)
 217                 return(dptr->path);
 218         return(NULL);
 219 }
 220
 221 /****************************************************************************
 222  Get the dir wcard for a dir index.
 223 ****************************************************************************/
 224
 225 char *dptr_wcard(int key)
 226 {
 227         struct dptr_struct *dptr = dptr_get(key, False);
 228         if (dptr)
 229                 return(dptr->wcard);
 230         return(NULL);
 231 }
 232
 233 /****************************************************************************
 234  Get the dir attrib for a dir index.
 235 ****************************************************************************/
 236
 237 uint16 dptr_attr(int key)
 238 {
 239         struct dptr_struct *dptr = dptr_get(key, False);
 240         if (dptr)
 241                 return(dptr->attr);
 242         return(0);
 243 }
 244
 245 /****************************************************************************
 246  Close a dptr (internal func).
 247 ****************************************************************************/
 248
 249 static void dptr_close_internal(struct dptr_struct *dptr)
 250 {
 251         DEBUG(4,("closing dptr key %d\n",dptr->dnum));
 252
 253         DLIST_REMOVE(dirptrs, dptr);
 254
 255         /*
 256          * Free the dnum in the bitmap. Remember the dnum value is always
 257          * biased by one with respect to the bitmap.
 258          */
 259
 260         if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
 261                 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
 262                         dptr->dnum ));
 263         }
 264
 265         bitmap_clear(dptr_bmap, dptr->dnum - 1);
 266
 267         TALLOC_FREE(dptr->dir_hnd);
 268
 269         /* Lanman 2 specific code */
 270         SAFE_FREE(dptr->wcard);
 271         string_set(&dptr->path,"");
 272         SAFE_FREE(dptr);
 273 }
 274
 275 /****************************************************************************
 276  Close a dptr given a key.
 277 ****************************************************************************/
 278
 279 void dptr_close(int *key)
 280 {
 281         struct dptr_struct *dptr;
 282
 283         if(*key == INVALID_DPTR_KEY)
 284                 return;
 285
 286         /* OS/2 seems to use -1 to indicate "close all directories" */
 287         if (*key == -1) {
 288                 struct dptr_struct *next;
 289                 for(dptr = dirptrs; dptr; dptr = next) {
 290                         next = dptr->next;
 291                         dptr_close_internal(dptr);
 292                 }
 293                 *key = INVALID_DPTR_KEY;
 294                 return;
 295         }
 296
 297         dptr = dptr_get(*key, True);
 298
 299         if (!dptr) {
 300                 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
 301                 return;
 302         }
 303
 304         dptr_close_internal(dptr);
 305
 306         *key = INVALID_DPTR_KEY;
 307 }
 308
 309 /****************************************************************************
 310  Close all dptrs for a cnum.
 311 ****************************************************************************/
 312
 313 void dptr_closecnum(connection_struct *conn)
 314 {
 315         struct dptr_struct *dptr, *next;
 316         for(dptr = dirptrs; dptr; dptr = next) {
 317                 next = dptr->next;
 318                 if (dptr->conn == conn)
 319                         dptr_close_internal(dptr);
 320         }
 321 }
 322
 323 /****************************************************************************
 324  Idle all dptrs for a cnum.
 325 ****************************************************************************/
 326
 327 void dptr_idlecnum(connection_struct *conn)
 328 {
 329         struct dptr_struct *dptr;
 330         for(dptr = dirptrs; dptr; dptr = dptr->next) {
 331                 if (dptr->conn == conn && dptr->dir_hnd)
 332                         dptr_idle(dptr);
 333         }
 334 }
 335
 336 /****************************************************************************
 337  Close a dptr that matches a given path, only if it matches the spid also.
 338 ****************************************************************************/
 339
 340 void dptr_closepath(char *path,uint16 spid)
 341 {
 342         struct dptr_struct *dptr, *next;
 343         for(dptr = dirptrs; dptr; dptr = next) {
 344                 next = dptr->next;
 345                 if (spid == dptr->spid && strequal(dptr->path,path))
 346                         dptr_close_internal(dptr);
 347         }
 348 }
 349
 350 /****************************************************************************
 351  Try and close the oldest handle not marked for
 352  expect close in the hope that the client has
 353  finished with that one.
 354 ****************************************************************************/
 355
 356 static void dptr_close_oldest(bool old)
 357 {
 358         struct dptr_struct *dptr;
 359
 360         /*
 361          * Go to the end of the list.
 362          */
 363         for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
 364                 ;
 365
 366         if(!dptr) {
 367                 DEBUG(0,("No old dptrs available to close oldest ?\n"));
 368                 return;
 369         }
 370
 371         /*
 372          * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
 373          * does not have expect_close set. If 'old' is false, close
 374          * one of the new dnum handles.
 375          */
 376
 377         for(; dptr; dptr = dptr->prev) {
 378                 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
 379                         (!old && (dptr->dnum > 255))) {
 380                                 dptr_close_internal(dptr);
 381                                 return;
 382                 }
 383         }
 384 }
 385
 386 /****************************************************************************
 387  Create a new dir ptr. If the flag old_handle is true then we must allocate
 388  from the bitmap range 0 - 255 as old SMBsearch directory handles are only
 389  one byte long. If old_handle is false we allocate from the range
 390  256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
 391  a directory handle is never zero.
 392  wcard must not be zero.
 393 ****************************************************************************/
 394
 395 NTSTATUS dptr_create(connection_struct *conn, const char *path, bool old_handle, bool expect_close,uint16 spid,
 396                 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
 397 {
 398         struct dptr_struct *dptr = NULL;
 399         struct smb_Dir *dir_hnd;
 400         NTSTATUS status;
 401
 402         DEBUG(5,("dptr_create dir=%s\n", path));
 403
 404         if (!wcard) {
 405                 return NT_STATUS_INVALID_PARAMETER;
 406         }
 407
 408         status = check_name(conn,path);
 409         if (!NT_STATUS_IS_OK(status)) {
 410                 return status;
 411         }
 412
 413         dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
 414         if (!dir_hnd) {
 415                 return map_nt_error_from_unix(errno);
 416         }
 417
 418         string_set(&conn->dirpath,path);
 419
 420         if (dirhandles_open >= MAX_OPEN_DIRECTORIES) {
 421                 dptr_idleoldest();
 422         }
 423
 424         dptr = SMB_MALLOC_P(struct dptr_struct);
 425         if(!dptr) {
 426                 DEBUG(0,("malloc fail in dptr_create.\n"));
 427                 TALLOC_FREE(dir_hnd);
 428                 return NT_STATUS_NO_MEMORY;
 429         }
 430
 431         ZERO_STRUCTP(dptr);
 432
 433         if(old_handle) {
 434
 435                 /*
 436                  * This is an old-style SMBsearch request. Ensure the
 437                  * value we return will fit in the range 1-255.
 438                  */
 439
 440                 dptr->dnum = bitmap_find(dptr_bmap, 0);
 441
 442                 if(dptr->dnum == -1 || dptr->dnum > 254) {
 443
 444                         /*
 445                          * Try and close the oldest handle not marked for
 446                          * expect close in the hope that the client has
 447                          * finished with that one.
 448                          */
 449
 450                         dptr_close_oldest(True);
 451
 452                         /* Now try again... */
 453                         dptr->dnum = bitmap_find(dptr_bmap, 0);
 454                         if(dptr->dnum == -1 || dptr->dnum > 254) {
 455                                 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
 456                                 SAFE_FREE(dptr);
 457                                 TALLOC_FREE(dir_hnd);
 458                                 return NT_STATUS_TOO_MANY_OPENED_FILES;
 459                         }
 460                 }
 461         } else {
 462
 463                 /*
 464                  * This is a new-style trans2 request. Allocate from
 465                  * a range that will return 256 - MAX_DIRECTORY_HANDLES.
 466                  */
 467
 468                 dptr->dnum = bitmap_find(dptr_bmap, 255);
 469
 470                 if(dptr->dnum == -1 || dptr->dnum < 255) {
 471
 472                         /*
 473                          * Try and close the oldest handle close in the hope that
 474                          * the client has finished with that one. This will only
 475                          * happen in the case of the Win98 client bug where it leaks
 476                          * directory handles.
 477                          */
 478
 479                         dptr_close_oldest(False);
 480
 481                         /* Now try again... */
 482                         dptr->dnum = bitmap_find(dptr_bmap, 255);
 483
 484                         if(dptr->dnum == -1 || dptr->dnum < 255) {
 485                                 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
 486                                 SAFE_FREE(dptr);
 487                                 TALLOC_FREE(dir_hnd);
 488                                 return NT_STATUS_TOO_MANY_OPENED_FILES;
 489                         }
 490                 }
 491         }
 492
 493         bitmap_set(dptr_bmap, dptr->dnum);
 494
 495         dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
 496
 497         string_set(&dptr->path,path);
 498         dptr->conn = conn;
 499         dptr->dir_hnd = dir_hnd;
 500         dptr->spid = spid;
 501         dptr->expect_close = expect_close;
 502         dptr->wcard = SMB_STRDUP(wcard);
 503         if (!dptr->wcard) {
 504                 bitmap_clear(dptr_bmap, dptr->dnum - 1);
 505                 SAFE_FREE(dptr);
 506                 TALLOC_FREE(dir_hnd);
 507                 return NT_STATUS_NO_MEMORY;
 508         }
 509         if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
 510                 dptr->has_wild = True;
 511         } else {
 512                 dptr->has_wild = wcard_has_wild;
 513         }
 514
 515         dptr->attr = attr;
 516
 517         DLIST_ADD(dirptrs, dptr);
 518
 519         DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
 520                 dptr->dnum,path,expect_close));
 521
 522         *dptr_ret = dptr;
 523
 524         return NT_STATUS_OK;
 525 }
 526
 527
 528 /****************************************************************************
 529  Wrapper functions to access the lower level directory handles.
 530 ****************************************************************************/
 531
 532 int dptr_CloseDir(struct dptr_struct *dptr)
 533 {
 534         DLIST_REMOVE(dirptrs, dptr);
 535         TALLOC_FREE(dptr->dir_hnd);
 536         return 0;
 537 }
 538
 539 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
 540 {
 541         SeekDir(dptr->dir_hnd, offset);
 542 }
 543
 544 long dptr_TellDir(struct dptr_struct *dptr)
 545 {
 546         return TellDir(dptr->dir_hnd);
 547 }
 548
 549 bool dptr_has_wild(struct dptr_struct *dptr)
 550 {
 551         return dptr->has_wild;
 552 }
 553
 554 int dptr_dnum(struct dptr_struct *dptr)
 555 {
 556         return dptr->dnum;
 557 }
 558
 559 /****************************************************************************
 560  Return the next visible file name, skipping veto'd and invisible files.
 561 ****************************************************************************/
 562
 563 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr, long *poffset, SMB_STRUCT_STAT *pst)
 564 {
 565         /* Normal search for the next file. */
 566         const char *name;
 567         while ((name = ReadDirName(dptr->dir_hnd, poffset)) != NULL) {
 568                 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
 569                         return name;
 570                 }
 571         }
 572         return NULL;
 573 }
 574
 575 /****************************************************************************
 576  Return the next visible file name, skipping veto'd and invisible files.
 577 ****************************************************************************/
 578
 579 const char *dptr_ReadDirName(TALLOC_CTX *ctx,
 580                         struct dptr_struct *dptr,
 581                         long *poffset,
 582                         SMB_STRUCT_STAT *pst)
 583 {
 584         SET_STAT_INVALID(*pst);
 585
 586         if (dptr->has_wild) {
 587                 return dptr_normal_ReadDirName(dptr, poffset, pst);
 588         }
 589
 590         /* If poffset is -1 then we know we returned this name before and we have
 591            no wildcards. We're at the end of the directory. */
 592         if (*poffset == END_OF_DIRECTORY_OFFSET) {
 593                 return NULL;
 594         }
 595
 596         if (!dptr->did_stat) {
 597                 char *pathreal = NULL;
 598
 599                 /* We know the stored wcard contains no wildcard characters. See if we can match
 600                    with a stat call. If we can't, then set did_stat to true to
 601                    ensure we only do this once and keep searching. */
 602
 603                 dptr->did_stat = True;
 604
 605                 /* First check if it should be visible. */
 606                 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard, pst, True)) {
 607                         /* This only returns False if the file was found, but
 608                            is explicitly not visible. Set us to end of directory,
 609                            but return NULL as we know we can't ever find it. */
 610                         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 611                         return NULL;
 612                 }
 613
 614                 if (VALID_STAT(*pst)) {
 615                         /* We need to set the underlying dir_hnd offset to -1 also as
 616                            this function is usually called with the output from TellDir. */
 617                         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 618                         return dptr->wcard;
 619                 }
 620
 621                 pathreal = talloc_asprintf(ctx,
 622                                         "%s/%s",
 623                                         dptr->path,
 624                                         dptr->wcard);
 625                 if (!pathreal) {
 626                         return NULL;
 627                 }
 628
 629                 if (SMB_VFS_STAT(dptr->conn,pathreal,pst) == 0) {
 630                         /* We need to set the underlying dir_hnd offset to -1 also as
 631                            this function is usually called with the output from TellDir. */
 632                         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 633                         TALLOC_FREE(pathreal);
 634                         return dptr->wcard;
 635                 } else {
 636                         /* If we get any other error than ENOENT or ENOTDIR
 637                            then the file exists we just can't stat it. */
 638                         if (errno != ENOENT && errno != ENOTDIR) {
 639                                 /* We need to set the underlying dir_hdn offset to -1 also as
 640                                    this function is usually called with the output from TellDir. */
 641                                 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 642                                 TALLOC_FREE(pathreal);
 643                                 return dptr->wcard;
 644                         }
 645                 }
 646
 647                 TALLOC_FREE(pathreal);
 648
 649                 /* Stat failed. We know this is authoratiative if we are
 650                  * providing case sensitive semantics or the underlying
 651                  * filesystem is case sensitive.
 652                  */
 653
 654                 if (dptr->conn->case_sensitive ||
 655                     !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
 656                         /* We need to set the underlying dir_hnd offset to -1 also as
 657                            this function is usually called with the output from TellDir. */
 658                         dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
 659                         return NULL;
 660                 }
 661         }
 662         return dptr_normal_ReadDirName(dptr, poffset, pst);
 663 }
 664
 665 /****************************************************************************
 666  Search for a file by name, skipping veto'ed and not visible files.
 667 ****************************************************************************/
 668
 669 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
 670 {
 671         SET_STAT_INVALID(*pst);
 672
 673         if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
 674                 /* This is a singleton directory and we're already at the end. */
 675                 *poffset = END_OF_DIRECTORY_OFFSET;
 676                 return False;
 677         }
 678
 679         return SearchDir(dptr->dir_hnd, name, poffset);
 680 }
 681
 682 /****************************************************************************
 683  Add the name we're returning into the underlying cache.
 684 ****************************************************************************/
 685
 686 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
 687 {
 688         DirCacheAdd(dptr->dir_hnd, name, offset);
 689 }
 690
 691 /****************************************************************************
 692  Fill the 5 byte server reserved dptr field.
 693 ****************************************************************************/
 694
 695 bool dptr_fill(char *buf1,unsigned int key)
 696 {
 697         unsigned char *buf = (unsigned char *)buf1;
 698         struct dptr_struct *dptr = dptr_get(key, False);
 699         uint32 offset;
 700         if (!dptr) {
 701                 DEBUG(1,("filling null dirptr %d\n",key));
 702                 return(False);
 703         }
 704         offset = (uint32)TellDir(dptr->dir_hnd);
 705         DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
 706                 (long)dptr->dir_hnd,(int)offset));
 707         buf[0] = key;
 708         SIVAL(buf,1,offset);
 709         return(True);
 710 }
 711
 712 /****************************************************************************
 713  Fetch the dir ptr and seek it given the 5 byte server field.
 714 ****************************************************************************/
 715
 716 struct dptr_struct *dptr_fetch(char *buf,int *num)
 717 {
 718         unsigned int key = *(unsigned char *)buf;
 719         struct dptr_struct *dptr = dptr_get(key, False);
 720         uint32 offset;
 721         long seekoff;
 722
 723         if (!dptr) {
 724                 DEBUG(3,("fetched null dirptr %d\n",key));
 725                 return(NULL);
 726         }
 727         *num = key;
 728         offset = IVAL(buf,1);
 729         if (offset == (uint32)-1) {
 730                 seekoff = END_OF_DIRECTORY_OFFSET;
 731         } else {
 732                 seekoff = (long)offset;
 733         }
 734         SeekDir(dptr->dir_hnd,seekoff);
 735         DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
 736                 key,dptr_path(key),(int)seekoff));
 737         return(dptr);
 738 }
 739
 740 /****************************************************************************
 741  Fetch the dir ptr.
 742 ****************************************************************************/
 743
 744 struct dptr_struct *dptr_fetch_lanman2(int dptr_num)
 745 {
 746         struct dptr_struct *dptr  = dptr_get(dptr_num, False);
 747
 748         if (!dptr) {
 749                 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
 750                 return(NULL);
 751         }
 752         DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
 753         return(dptr);
 754 }
 755
 756 /****************************************************************************
 757  Check that a file matches a particular file type.
 758 ****************************************************************************/
 759
 760 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
 761 {
 762         uint32 mask;
 763
 764         /* Check the "may have" search bits. */
 765         if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
 766                 return False;
 767
 768         /* Check the "must have" bits, which are the may have bits shifted eight */
 769         /* If must have bit is set, the file/dir can not be returned in search unless the matching
 770                 file attribute is set */
 771         mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
 772         if(mask) {
 773                 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask)   /* check if matching attribute present */
 774                         return True;
 775                 else
 776                         return False;
 777         }
 778
 779         return True;
 780 }
 781
 782 static bool mangle_mask_match(connection_struct *conn,
 783                 const char *filename,
 784                 const char *mask)
 785 {
 786         char mname[13];
 787
 788         if (!name_to_8_3(filename,mname,False,conn->params)) {
 789                 return False;
 790         }
 791         return mask_match_search(mname,mask,False);
 792 }
 793
 794 /****************************************************************************
 795  Get an 8.3 directory entry.
 796 ****************************************************************************/
 797
 798 bool get_dir_entry(TALLOC_CTX *ctx,
 799                 connection_struct *conn,
 800                 const char *mask,
 801                 uint32 dirtype,
 802                 char **pp_fname_out,
 803                 SMB_OFF_T *size,
 804                 uint32 *mode,
 805                 time_t *date,
 806                 bool check_descend,
 807                 bool ask_sharemode)
 808 {
 809         const char *dname = NULL;
 810         bool found = False;
 811         SMB_STRUCT_STAT sbuf;
 812         char *pathreal = NULL;
 813         const char *filename = NULL;
 814         bool needslash;
 815
 816         *pp_fname_out = NULL;
 817
 818         needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
 819
 820         if (!conn->dirptr) {
 821                 return(False);
 822         }
 823
 824         while (!found) {
 825                 long curoff = dptr_TellDir(conn->dirptr);
 826                 dname = dptr_ReadDirName(ctx, conn->dirptr, &curoff, &sbuf);
 827
 828                 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
 829                         (long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
 830
 831                 if (dname == NULL) {
 832                         return(False);
 833                 }
 834
 835                 filename = dname;
 836
 837                 /* notice the special *.* handling. This appears to be the only difference
 838                         between the wildcard handling in this routine and in the trans2 routines.
 839                         see masktest for a demo
 840                 */
 841                 if ((strcmp(mask,"*.*") == 0) ||
 842                     mask_match_search(filename,mask,False) ||
 843                     mangle_mask_match(conn,filename,mask)) {
 844                         char mname[13];
 845
 846                         if (!mangle_is_8_3(filename, False, conn->params)) {
 847                                 if (!name_to_8_3(filename,mname,False,
 848                                            conn->params)) {
 849                                         continue;
 850                                 }
 851                                 filename = mname;
 852                         }
 853
 854                         if (needslash) {
 855                                 pathreal = talloc_asprintf(ctx,
 856                                                 "%s/%s",
 857                                                 conn->dirpath,
 858                                                 dname);
 859                         } else {
 860                                 pathreal = talloc_asprintf(ctx,
 861                                                 "%s%s",
 862                                                 conn->dirpath,
 863                                                 dname);
 864                         }
 865                         if (!pathreal) {
 866                                 return False;
 867                         }
 868
 869                         if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn, pathreal, &sbuf)) != 0) {
 870                                 DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",
 871                                         pathreal, strerror(errno) ));
 872                                 TALLOC_FREE(pathreal);
 873                                 continue;
 874                         }
 875
 876                         *mode = dos_mode(conn,pathreal,&sbuf);
 877
 878                         if (!dir_check_ftype(conn,*mode,dirtype)) {
 879                                 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
 880                                 TALLOC_FREE(pathreal);
 881                                 continue;
 882                         }
 883
 884                         *size = sbuf.st_size;
 885                         *date = sbuf.st_mtime;
 886
 887                         if (ask_sharemode) {
 888                                 struct timespec write_time_ts;
 889                                 struct file_id fileid;
 890
 891                                 fileid = vfs_file_id_from_sbuf(conn, &sbuf);
 892                                 get_file_infos(fileid, NULL, &write_time_ts);
 893                                 if (!null_timespec(write_time_ts)) {
 894                                         *date = convert_timespec_to_time_t(write_time_ts);
 895                                 }
 896                         }
 897
 898                         DEBUG(3,("get_dir_entry mask=[%s] found %s "
 899                                 "fname=%s (%s)\n",
 900                                 mask,
 901                                 pathreal,
 902                                 dname,
 903                                 filename));
 904
 905                         found = True;
 906
 907                         *pp_fname_out = talloc_strdup(ctx, filename);
 908                         if (!*pp_fname_out) {
 909                                 return False;
 910                         }
 911
 912                         DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
 913                         TALLOC_FREE(pathreal);
 914                 }
 915         }
 916
 917         return(found);
 918 }
 919
 920 /*******************************************************************
 921  Check to see if a user can read a file. This is only approximate,
 922  it is used as part of the "hide unreadable" option. Don't
 923  use it for anything security sensitive.
 924 ********************************************************************/
 925
 926 static bool user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
 927 {
 928         SEC_DESC *psd = NULL;
 929         files_struct *fsp;
 930         NTSTATUS status;
 931         uint32 access_granted;
 932
 933         /*
 934          * If user is a member of the Admin group
 935          * we never hide files from them.
 936          */
 937
 938         if (conn->admin_user) {
 939                 return True;
 940         }
 941
 942         SMB_ASSERT(VALID_STAT(*pst));
 943
 944         /* Pseudo-open the file (note - no fd's created). */
 945
 946         if(S_ISDIR(pst->st_mode)) {
 947                  status = open_directory(conn, NULL, name, pst,
 948                         READ_CONTROL_ACCESS,
 949                         FILE_SHARE_READ|FILE_SHARE_WRITE,
 950                         FILE_OPEN,
 951                         0, /* no create options. */
 952                         FILE_ATTRIBUTE_DIRECTORY,
 953                         NULL, &fsp);
 954         } else {
 955                 status = open_file_stat(conn, NULL, name, pst, &fsp);
 956         }
 957
 958         if (!NT_STATUS_IS_OK(status)) {
 959                 return False;
 960         }
 961
 962         /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
 963         status = SMB_VFS_FGET_NT_ACL(fsp,
 964                         (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
 965         close_file(fsp, NORMAL_CLOSE);
 966
 967         /* No access if SD get failed. */
 968         if (!NT_STATUS_IS_OK(status)) {
 969                 return False;
 970         }
 971
 972         return se_access_check(psd, current_user.nt_user_token, FILE_READ_DATA,
 973                                  &access_granted, &status);
 974 }
 975
 976 /*******************************************************************
 977  Check to see if a user can write a file (and only files, we do not
 978  check dirs on this one). This is only approximate,
 979  it is used as part of the "hide unwriteable" option. Don't
 980  use it for anything security sensitive.
 981 ********************************************************************/
 982
 983 static bool user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
 984 {
 985         SEC_DESC *psd = NULL;
 986         files_struct *fsp;
 987         int info;
 988         NTSTATUS status;
 989         uint32 access_granted;
 990
 991         /*
 992          * If user is a member of the Admin group
 993          * we never hide files from them.
 994          */
 995
 996         if (conn->admin_user) {
 997                 return True;
 998         }
 999
1000         SMB_ASSERT(VALID_STAT(*pst));
1001
1002         /* Pseudo-open the file */
1003
1004         if(S_ISDIR(pst->st_mode)) {
1005                 return True;
1006         } else {
1007                 status = open_file_ntcreate(conn, NULL, name, pst,
1008                         FILE_WRITE_ATTRIBUTES,
1009                         FILE_SHARE_READ|FILE_SHARE_WRITE,
1010                         FILE_OPEN,
1011                         0,
1012                         FILE_ATTRIBUTE_NORMAL,
1013                         INTERNAL_OPEN_ONLY,
1014                         &info, &fsp);
1015         }
1016
1017         if (!NT_STATUS_IS_OK(status)) {
1018                 return False;
1019         }
1020
1021         /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
1022         status = SMB_VFS_FGET_NT_ACL(fsp,
1023                         (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
1024         close_file(fsp, NORMAL_CLOSE);
1025
1026         /* No access if SD get failed. */
1027         if (!NT_STATUS_IS_OK(status)) {
1028                 return False;
1029         }
1030
1031         return se_access_check(psd, current_user.nt_user_token, FILE_WRITE_DATA,
1032                                  &access_granted, &status);
1033 }
1034
1035 /*******************************************************************
1036   Is a file a "special" type ?
1037 ********************************************************************/
1038
1039 static bool file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
1040 {
1041         /*
1042          * If user is a member of the Admin group
1043          * we never hide files from them.
1044          */
1045
1046         if (conn->admin_user)
1047                 return False;
1048
1049         SMB_ASSERT(VALID_STAT(*pst));
1050
1051         if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
1052                 return False;
1053
1054         return True;
1055 }
1056
1057 /*******************************************************************
1058  Should the file be seen by the client ? NOTE: A successful return
1059  is no guarantee of the file's existence ... you also have to check
1060  whether pst is valid.
1061 ********************************************************************/
1062
1063 bool is_visible_file(connection_struct *conn, const char *dir_path, const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1064 {
1065         bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1066         bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1067         bool hide_special = lp_hide_special_files(SNUM(conn));
1068
1069         SET_STAT_INVALID(*pst);
1070
1071         if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1072                 return True; /* . and .. are always visible. */
1073         }
1074
1075         /* If it's a vetoed file, pretend it doesn't even exist */
1076         if (use_veto && IS_VETO_PATH(conn, name)) {
1077                 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1078                 return False;
1079         }
1080
1081         if (hide_unreadable || hide_unwriteable || hide_special) {
1082                 char *entry = NULL;
1083
1084                 if (asprintf(&entry, "%s/%s", dir_path, name) == -1) {
1085                         return False;
1086                 }
1087
1088                 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1089                 if (lp_host_msdfs() &&
1090                                 lp_msdfs_root(SNUM(conn)) &&
1091                                 is_msdfs_link(conn, entry, NULL)) {
1092                         SAFE_FREE(entry);
1093                         return True;
1094                 }
1095
1096                 /* If the file name does not exist, there's no point checking
1097                  * the configuration options. We succeed, on the basis that the
1098                  * checks *might* have passed if the file was present.
1099                  */
1100                 if (SMB_VFS_STAT(conn, entry, pst) != 0) {
1101                         SAFE_FREE(entry);
1102                         return True;
1103                 }
1104
1105                 /* Honour _hide unreadable_ option */
1106                 if (hide_unreadable && !user_can_read_file(conn, entry, pst)) {
1107                         DEBUG(10,("is_visible_file: file %s is unreadable.\n", entry ));
1108                         SAFE_FREE(entry);
1109                         return False;
1110                 }
1111                 /* Honour _hide unwriteable_ option */
1112                 if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
1113                         DEBUG(10,("is_visible_file: file %s is unwritable.\n", entry ));
1114                         SAFE_FREE(entry);
1115                         return False;
1116                 }
1117                 /* Honour _hide_special_ option */
1118                 if (hide_special && file_is_special(conn, entry, pst)) {
1119                         DEBUG(10,("is_visible_file: file %s is special.\n", entry ));
1120                         SAFE_FREE(entry);
1121                         return False;
1122                 }
1123                 SAFE_FREE(entry);
1124         }
1125         return True;
1126 }
1127
1128 static int smb_Dir_destructor(struct smb_Dir *dirp)
1129 {
1130         if (dirp->dir) {
1131                 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1132         }
1133         dirhandles_open--;
1134         return 0;
1135 }
1136
1137 /*******************************************************************
1138  Open a directory.
1139 ********************************************************************/
1140
1141 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1142                         const char *name, const char *mask, uint32 attr)
1143 {
1144         struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1145
1146         if (!dirp) {
1147                 return NULL;
1148         }
1149
1150         dirp->conn = conn;
1151         dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1152
1153         dirp->dir_path = talloc_strdup(dirp, name);
1154         if (!dirp->dir_path) {
1155                 goto fail;
1156         }
1157
1158         dirhandles_open++;
1159         talloc_set_destructor(dirp, smb_Dir_destructor);
1160
1161         dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1162         if (!dirp->dir) {
1163                 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1164                          strerror(errno) ));
1165                 goto fail;
1166         }
1167
1168         return dirp;
1169
1170   fail:
1171         TALLOC_FREE(dirp);
1172         return NULL;
1173 }
1174
1175 /*******************************************************************
1176  Read from a directory. Also return current offset.
1177  Don't check for veto or invisible files.
1178 ********************************************************************/
1179
1180 const char *ReadDirName(struct smb_Dir *dirp, long *poffset)
1181 {
1182         const char *n;
1183         connection_struct *conn = dirp->conn;
1184
1185         /* Cheat to allow . and .. to be the first entries returned. */
1186         if (((*poffset == START_OF_DIRECTORY_OFFSET) || (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2)) {
1187                 if (dirp->file_number == 0) {
1188                         n = ".";
1189                         *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1190                 } else {
1191                         *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1192                         n = "..";
1193                 }
1194                 dirp->file_number++;
1195                 return n;
1196         } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1197                 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1198                 return NULL;
1199         } else {
1200                 /* A real offset, seek to it. */
1201                 SeekDir(dirp, *poffset);
1202         }
1203
1204         while ((n = vfs_readdirname(conn, dirp->dir))) {
1205                 /* Ignore . and .. - we've already returned them. */
1206                 if (*n == '.') {
1207                         if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1208                                 continue;
1209                         }
1210                 }
1211                 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1212                 dirp->file_number++;
1213                 return n;
1214         }
1215         *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1216         return NULL;
1217 }
1218
1219 /*******************************************************************
1220  Rewind to the start.
1221 ********************************************************************/
1222
1223 void RewindDir(struct smb_Dir *dirp, long *poffset)
1224 {
1225         SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1226         dirp->file_number = 0;
1227         dirp->offset = START_OF_DIRECTORY_OFFSET;
1228         *poffset = START_OF_DIRECTORY_OFFSET;
1229 }
1230
1231 /*******************************************************************
1232  Seek a dir.
1233 ********************************************************************/
1234
1235 void SeekDir(struct smb_Dir *dirp, long offset)
1236 {
1237         if (offset != dirp->offset) {
1238                 if (offset == START_OF_DIRECTORY_OFFSET) {
1239                         RewindDir(dirp, &offset);
1240                         /*
1241                          * Ok we should really set the file number here
1242                          * to 1 to enable ".." to be returned next. Trouble
1243                          * is I'm worried about callers using SeekDir(dirp,0)
1244                          * as equivalent to RewindDir(). So leave this alone
1245                          * for now.
1246                          */
1247                 } else if  (offset == DOT_DOT_DIRECTORY_OFFSET) {
1248                         RewindDir(dirp, &offset);
1249                         /*
1250                          * Set the file number to 2 - we want to get the first
1251                          * real file entry (the one we return after "..")
1252                          * on the next ReadDir.
1253                          */
1254                         dirp->file_number = 2;
1255                 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1256                         ; /* Don't seek in this case. */
1257                 } else {
1258                         SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1259                 }
1260                 dirp->offset = offset;
1261         }
1262 }
1263
1264 /*******************************************************************
1265  Tell a dir position.
1266 ********************************************************************/
1267
1268 long TellDir(struct smb_Dir *dirp)
1269 {
1270         return(dirp->offset);
1271 }
1272
1273 /*******************************************************************
1274  Add an entry into the dcache.
1275 ********************************************************************/
1276
1277 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1278 {
1279         struct name_cache_entry *e;
1280
1281         if (dirp->name_cache_size == 0) {
1282                 return;
1283         }
1284
1285         if (dirp->name_cache == NULL) {
1286                 dirp->name_cache = TALLOC_ZERO_ARRAY(
1287                         dirp, struct name_cache_entry, dirp->name_cache_size);
1288
1289                 if (dirp->name_cache == NULL) {
1290                         return;
1291                 }
1292         }
1293
1294         dirp->name_cache_index = (dirp->name_cache_index+1) %
1295                                         dirp->name_cache_size;
1296         e = &dirp->name_cache[dirp->name_cache_index];
1297         TALLOC_FREE(e->name);
1298         e->name = talloc_strdup(dirp, name);
1299         e->offset = offset;
1300 }
1301
1302 /*******************************************************************
1303  Find an entry by name. Leave us at the offset after it.
1304  Don't check for veto or invisible files.
1305 ********************************************************************/
1306
1307 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1308 {
1309         int i;
1310         const char *entry;
1311         connection_struct *conn = dirp->conn;
1312
1313         /* Search back in the name cache. */
1314         if (dirp->name_cache_size && dirp->name_cache) {
1315                 for (i = dirp->name_cache_index; i >= 0; i--) {
1316                         struct name_cache_entry *e = &dirp->name_cache[i];
1317                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1318                                 *poffset = e->offset;
1319                                 SeekDir(dirp, e->offset);
1320                                 return True;
1321                         }
1322                 }
1323                 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1324                         struct name_cache_entry *e = &dirp->name_cache[i];
1325                         if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1326                                 *poffset = e->offset;
1327                                 SeekDir(dirp, e->offset);
1328                                 return True;
1329                         }
1330                 }
1331         }
1332
1333         /* Not found in the name cache. Rewind directory and start from scratch. */
1334         SMB_VFS_REWINDDIR(conn, dirp->dir);
1335         dirp->file_number = 0;
1336         *poffset = START_OF_DIRECTORY_OFFSET;
1337         while ((entry = ReadDirName(dirp, poffset))) {
1338                 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1339                         return True;
1340                 }
1341         }
1342         return False;
1343 }
1344
1345 /*****************************************************************
1346  Is this directory empty ?
1347 *****************************************************************/
1348
1349 NTSTATUS can_delete_directory(struct connection_struct *conn,
1350                                 const char *dirname)
1351 {
1352         NTSTATUS status = NT_STATUS_OK;
1353         long dirpos = 0;
1354         const char *dname;
1355         struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
1356                                           NULL, 0);
1357
1358         if (!dir_hnd) {
1359                 return map_nt_error_from_unix(errno);
1360         }
1361
1362         while ((dname = ReadDirName(dir_hnd,&dirpos))) {
1363                 SMB_STRUCT_STAT st;
1364
1365                 /* Quick check for "." and ".." */
1366                 if (dname[0] == '.') {
1367                         if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1368                                 continue;
1369                         }
1370                 }
1371
1372                 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1373                         continue;
1374                 }
1375
1376                 DEBUG(10,("can_delete_directory: got name %s - can't delete\n", dname ));
1377                 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1378                 break;
1379         }
1380         TALLOC_FREE(dir_hnd);
1381
1382         return status;
1383 }