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