source3/smbd/dir.c

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