source/smbd/dir.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Directory handling routines
   5    Copyright (C) Andrew Tridgell 1992-1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern int DEBUGLEVEL;
  25
  26 /*
  27    This module implements directory related functions for Samba.
  28 */
  29
  30 typedef struct _dptr_struct {
  31         struct _dptr_struct *next, *prev;
  32         int dnum;
  33         uint16 spid;
  34         connection_struct *conn;
  35         void *ptr;
  36         BOOL expect_close;
  37         char *wcard; /* Field only used for trans2_ searches */
  38         uint16 attr; /* Field only used for trans2_ searches */
  39         char *path;
  40 } dptr_struct;
  41
  42 static struct bitmap *dptr_bmap;
  43 static dptr_struct *dirptrs;
  44
  45 static int dptrs_open = 0;
  46
  47 #define INVALID_DPTR_KEY (-3)
  48
  49 /****************************************************************************
  50  Initialise the dir bitmap.
  51 ****************************************************************************/
  52
  53 void init_dptrs(void)
  54 {
  55   static BOOL dptrs_init=False;
  56
  57   if (dptrs_init)
  58     return;
  59
  60   dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
  61
  62   if (!dptr_bmap)
  63     exit_server("out of memory in init_dptrs\n");
  64
  65   dptrs_init = True;
  66 }
  67
  68 /****************************************************************************
  69  Idle a dptr - the directory is closed but the control info is kept.
  70 ****************************************************************************/
  71
  72 static void dptr_idle(dptr_struct *dptr)
  73 {
  74   if (dptr->ptr) {
  75     DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
  76     dptrs_open--;
  77     CloseDir(dptr->ptr);
  78     dptr->ptr = NULL;
  79   }
  80 }
  81
  82 /****************************************************************************
  83  Idle the oldest dptr.
  84 ****************************************************************************/
  85
  86 static void dptr_idleoldest(void)
  87 {
  88   dptr_struct *dptr;
  89
  90   /*
  91    * Go to the end of the list.
  92    */
  93   for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
  94     ;
  95
  96   if(!dptr) {
  97     DEBUG(0,("No dptrs available to idle ?\n"));
  98     return;
  99   }
 100
 101   /*
 102    * Idle the oldest pointer.
 103    */
 104
 105   for(; dptr; dptr = dptr->prev) {
 106     if (dptr->ptr) {
 107       dptr_idle(dptr);
 108       return;
 109     }
 110   }
 111 }
 112
 113 /****************************************************************************
 114  Get the dptr_struct for a dir index.
 115 ****************************************************************************/
 116
 117 static dptr_struct *dptr_get(int key, BOOL forclose)
 118 {
 119   dptr_struct *dptr;
 120
 121   for(dptr = dirptrs; dptr; dptr = dptr->next) {
 122     if(dptr->dnum == key) {
 123       if (!forclose && !dptr->ptr) {
 124         if (dptrs_open >= MAX_OPEN_DIRECTORIES)
 125           dptr_idleoldest();
 126         DEBUG(4,("Reopening dptr key %d\n",key));
 127         if ((dptr->ptr = OpenDir(dptr->conn, dptr->path, True)))
 128           dptrs_open++;
 129       }
 130       DLIST_PROMOTE(dirptrs,dptr);
 131       return dptr;
 132     }
 133   }
 134   return(NULL);
 135 }
 136
 137 /****************************************************************************
 138  Get the dptr ptr for a dir index.
 139 ****************************************************************************/
 140
 141 static void *dptr_ptr(int key)
 142 {
 143   dptr_struct *dptr = dptr_get(key, False);
 144
 145   if (dptr)
 146     return(dptr->ptr);
 147   return(NULL);
 148 }
 149
 150 /****************************************************************************
 151  Get the dir path for a dir index.
 152 ****************************************************************************/
 153
 154 char *dptr_path(int key)
 155 {
 156   dptr_struct *dptr = dptr_get(key, False);
 157
 158   if (dptr)
 159     return(dptr->path);
 160   return(NULL);
 161 }
 162
 163 /****************************************************************************
 164  Get the dir wcard for a dir index (lanman2 specific).
 165 ****************************************************************************/
 166
 167 char *dptr_wcard(int key)
 168 {
 169   dptr_struct *dptr = dptr_get(key, False);
 170
 171   if (dptr)
 172     return(dptr->wcard);
 173   return(NULL);
 174 }
 175
 176 /****************************************************************************
 177  Set the dir wcard for a dir index (lanman2 specific).
 178  Returns 0 on ok, 1 on fail.
 179 ****************************************************************************/
 180
 181 BOOL dptr_set_wcard(int key, char *wcard)
 182 {
 183   dptr_struct *dptr = dptr_get(key, False);
 184
 185   if (dptr) {
 186     dptr->wcard = wcard;
 187     return True;
 188   }
 189   return False;
 190 }
 191
 192 /****************************************************************************
 193  Set the dir attrib for a dir index (lanman2 specific).
 194  Returns 0 on ok, 1 on fail.
 195 ****************************************************************************/
 196
 197 BOOL dptr_set_attr(int key, uint16 attr)
 198 {
 199   dptr_struct *dptr = dptr_get(key, False);
 200
 201   if (dptr) {
 202     dptr->attr = attr;
 203     return True;
 204   }
 205   return False;
 206 }
 207
 208 /****************************************************************************
 209  Get the dir attrib for a dir index (lanman2 specific)
 210 ****************************************************************************/
 211
 212 uint16 dptr_attr(int key)
 213 {
 214   dptr_struct *dptr = dptr_get(key, False);
 215
 216   if (dptr)
 217     return(dptr->attr);
 218   return(0);
 219 }
 220
 221 /****************************************************************************
 222  Close a dptr (internal func).
 223 ****************************************************************************/
 224
 225 static void dptr_close_internal(dptr_struct *dptr)
 226 {
 227   DEBUG(4,("closing dptr key %d\n",dptr->dnum));
 228
 229   DLIST_REMOVE(dirptrs, dptr);
 230
 231   /*
 232    * Free the dnum in the bitmap. Remember the dnum value is always
 233    * biased by one with respect to the bitmap.
 234    */
 235
 236   if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
 237     DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
 238                         dptr->dnum ));
 239   }
 240
 241   bitmap_clear(dptr_bmap, dptr->dnum - 1);
 242
 243   if (dptr->ptr) {
 244     CloseDir(dptr->ptr);
 245     dptrs_open--;
 246   }
 247
 248   /* Lanman 2 specific code */
 249   if (dptr->wcard)
 250     free(dptr->wcard);
 251   string_set(&dptr->path,"");
 252   free((char *)dptr);
 253 }
 254
 255 /****************************************************************************
 256  Close a dptr given a key.
 257 ****************************************************************************/
 258
 259 void dptr_close(int *key)
 260 {
 261   dptr_struct *dptr;
 262
 263   if(*key == INVALID_DPTR_KEY)
 264     return;
 265
 266   /* OS/2 seems to use -1 to indicate "close all directories" */
 267   if (*key == -1) {
 268     dptr_struct *next;
 269     for(dptr = dirptrs; dptr; dptr = next) {
 270       next = dptr->next;
 271       dptr_close_internal(dptr);
 272     }
 273     *key = INVALID_DPTR_KEY;
 274     return;
 275   }
 276
 277   dptr = dptr_get(*key, True);
 278
 279   if (!dptr) {
 280     DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
 281     return;
 282   }
 283
 284   dptr_close_internal(dptr);
 285
 286   *key = INVALID_DPTR_KEY;
 287 }
 288
 289 /****************************************************************************
 290  Close all dptrs for a cnum.
 291 ****************************************************************************/
 292
 293 void dptr_closecnum(connection_struct *conn)
 294 {
 295   dptr_struct *dptr, *next;
 296   for(dptr = dirptrs; dptr; dptr = next) {
 297     next = dptr->next;
 298     if (dptr->conn == conn)
 299       dptr_close_internal(dptr);
 300   }
 301 }
 302
 303 /****************************************************************************
 304  Idle all dptrs for a cnum.
 305 ****************************************************************************/
 306
 307 void dptr_idlecnum(connection_struct *conn)
 308 {
 309   dptr_struct *dptr;
 310   for(dptr = dirptrs; dptr; dptr = dptr->next) {
 311     if (dptr->conn == conn && dptr->ptr)
 312       dptr_idle(dptr);
 313   }
 314 }
 315
 316 /****************************************************************************
 317  Close a dptr that matches a given path, only if it matches the spid also.
 318 ****************************************************************************/
 319
 320 void dptr_closepath(char *path,uint16 spid)
 321 {
 322   dptr_struct *dptr, *next;
 323   for(dptr = dirptrs; dptr; dptr = next) {
 324     next = dptr->next;
 325     if (spid == dptr->spid && strequal(dptr->path,path))
 326       dptr_close_internal(dptr);
 327   }
 328 }
 329
 330 /****************************************************************************
 331  Start a directory listing.
 332 ****************************************************************************/
 333
 334 static BOOL start_dir(connection_struct *conn,char *directory)
 335 {
 336   DEBUG(5,("start_dir dir=%s\n",directory));
 337
 338   if (!check_name(directory,conn))
 339     return(False);
 340
 341   if (! *directory)
 342     directory = ".";
 343
 344   conn->dirptr = OpenDir(conn, directory, True);
 345   if (conn->dirptr) {
 346     dptrs_open++;
 347     string_set(&conn->dirpath,directory);
 348     return(True);
 349   }
 350
 351   return(False);
 352 }
 353
 354 /****************************************************************************
 355  Try and close the oldest handle not marked for
 356  expect close in the hope that the client has
 357  finished with that one.
 358 ****************************************************************************/
 359
 360 static void dptr_close_oldest(BOOL old)
 361 {
 362   dptr_struct *dptr;
 363
 364   /*
 365    * Go to the end of the list.
 366    */
 367   for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
 368     ;
 369
 370   if(!dptr) {
 371     DEBUG(0,("No old dptrs available to close oldest ?\n"));
 372     return;
 373   }
 374
 375   /*
 376    * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
 377    * does not have expect_close set. If 'old' is false, close
 378    * one of the new dnum handles.
 379    */
 380
 381   for(; dptr; dptr = dptr->prev) {
 382     if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
 383         (!old && (dptr->dnum > 255))) {
 384       dptr_close_internal(dptr);
 385       return;
 386     }
 387   }
 388 }
 389
 390 /****************************************************************************
 391  Create a new dir ptr. If the flag old_handle is true then we must allocate
 392  from the bitmap range 0 - 255 as old SMBsearch directory handles are only
 393  one byte long. If old_handle is false we allocate from the range
 394  256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
 395  a directory handle is never zero. All the above is folklore taught to
 396  me at Andrew's knee.... :-) :-). JRA.
 397 ****************************************************************************/
 398
 399 int dptr_create(connection_struct *conn,char *path, BOOL old_handle, BOOL expect_close,uint16 spid)
 400 {
 401   dptr_struct *dptr;
 402
 403   if (!start_dir(conn,path))
 404     return(-2); /* Code to say use a unix error return code. */
 405
 406   if (dptrs_open >= MAX_OPEN_DIRECTORIES)
 407     dptr_idleoldest();
 408
 409   dptr = (dptr_struct *)malloc(sizeof(dptr_struct));
 410   if(!dptr) {
 411     DEBUG(0,("malloc fail in dptr_create.\n"));
 412     return -1;
 413   }
 414
 415   ZERO_STRUCTP(dptr);
 416
 417   if(old_handle) {
 418
 419     /*
 420      * This is an old-style SMBsearch request. Ensure the
 421      * value we return will fit in the range 1-255.
 422      */
 423
 424     dptr->dnum = bitmap_find(dptr_bmap, 0);
 425
 426     if(dptr->dnum == -1 || dptr->dnum > 254) {
 427
 428       /*
 429        * Try and close the oldest handle not marked for
 430        * expect close in the hope that the client has
 431        * finished with that one.
 432        */
 433
 434       dptr_close_oldest(True);
 435
 436       /* Now try again... */
 437       dptr->dnum = bitmap_find(dptr_bmap, 0);
 438
 439       if(dptr->dnum == -1 || dptr->dnum > 254) {
 440         DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
 441         free((char *)dptr);
 442         return -1;
 443       }
 444     }
 445   } else {
 446
 447     /*
 448      * This is a new-style trans2 request. Allocate from
 449      * a range that will return 256 - MAX_DIRECTORY_HANDLES.
 450      */
 451
 452     dptr->dnum = bitmap_find(dptr_bmap, 255);
 453
 454     if(dptr->dnum == -1 || dptr->dnum < 255) {
 455
 456       /*
 457        * Try and close the oldest handle close in the hope that
 458        * the client has finished with that one. This will only
 459        * happen in the case of the Win98 client bug where it leaks
 460        * directory handles.
 461        */
 462
 463       dptr_close_oldest(False);
 464
 465       /* Now try again... */
 466       dptr->dnum = bitmap_find(dptr_bmap, 255);
 467
 468       if(dptr->dnum == -1 || dptr->dnum < 255) {
 469         DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
 470         free((char *)dptr);
 471         return -1;
 472       }
 473     }
 474   }
 475
 476   bitmap_set(dptr_bmap, dptr->dnum);
 477
 478   dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
 479
 480   dptr->ptr = conn->dirptr;
 481   string_set(&dptr->path,path);
 482   dptr->conn = conn;
 483   dptr->spid = spid;
 484   dptr->expect_close = expect_close;
 485   dptr->wcard = NULL; /* Only used in lanman2 searches */
 486   dptr->attr = 0; /* Only used in lanman2 searches */
 487
 488   DLIST_ADD(dirptrs, dptr);
 489
 490   DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
 491            dptr->dnum,path,expect_close));
 492
 493   return(dptr->dnum);
 494 }
 495
 496 /****************************************************************************
 497  Fill the 5 byte server reserved dptr field.
 498 ****************************************************************************/
 499
 500 BOOL dptr_fill(char *buf1,unsigned int key)
 501 {
 502   unsigned char *buf = (unsigned char *)buf1;
 503   void *p = dptr_ptr(key);
 504   uint32 offset;
 505   if (!p) {
 506     DEBUG(1,("filling null dirptr %d\n",key));
 507     return(False);
 508   }
 509   offset = TellDir(p);
 510   DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
 511            (long)p,(int)offset));
 512   buf[0] = key;
 513   SIVAL(buf,1,offset | DPTR_MASK);
 514   return(True);
 515 }
 516
 517 /****************************************************************************
 518  Fetch the dir ptr and seek it given the 5 byte server field.
 519 ****************************************************************************/
 520
 521 void *dptr_fetch(char *buf,int *num)
 522 {
 523   unsigned int key = *(unsigned char *)buf;
 524   void *p = dptr_ptr(key);
 525   uint32 offset;
 526   if (!p) {
 527     DEBUG(3,("fetched null dirptr %d\n",key));
 528     return(NULL);
 529   }
 530   *num = key;
 531   offset = IVAL(buf,1)&~DPTR_MASK;
 532   SeekDir(p,offset);
 533   DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
 534            key,dptr_path(key),offset));
 535   return(p);
 536 }
 537
 538 /****************************************************************************
 539  Fetch the dir ptr.
 540 ****************************************************************************/
 541
 542 void *dptr_fetch_lanman2(int dptr_num)
 543 {
 544   void *p = dptr_ptr(dptr_num);
 545
 546   if (!p) {
 547     DEBUG(3,("fetched null dirptr %d\n",dptr_num));
 548     return(NULL);
 549   }
 550   DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
 551   return(p);
 552 }
 553
 554 /****************************************************************************
 555  Check a filetype for being valid.
 556 ****************************************************************************/
 557
 558 BOOL dir_check_ftype(connection_struct *conn,int mode,SMB_STRUCT_STAT *st,int dirtype)
 559 {
 560   if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
 561     return False;
 562   return True;
 563 }
 564
 565 /****************************************************************************
 566  Get an 8.3 directory entry.
 567 ****************************************************************************/
 568
 569 BOOL get_dir_entry(connection_struct *conn,char *mask,int dirtype,char *fname,
 570                    SMB_OFF_T *size,int *mode,time_t *date,BOOL check_descend)
 571 {
 572   char *dname;
 573   BOOL found = False;
 574   SMB_STRUCT_STAT sbuf;
 575   pstring path;
 576   pstring pathreal;
 577   BOOL isrootdir;
 578   pstring filename;
 579   BOOL needslash;
 580
 581   *path = *pathreal = *filename = 0;
 582
 583   isrootdir = (strequal(conn->dirpath,"./") ||
 584                strequal(conn->dirpath,".") ||
 585                strequal(conn->dirpath,"/"));
 586
 587   needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
 588
 589   if (!conn->dirptr)
 590     return(False);
 591
 592   while (!found)
 593   {
 594     dname = ReadDirName(conn->dirptr);
 595
 596     DEBUG(6,("readdir on dirptr 0x%lx now at offset %d\n",
 597           (long)conn->dirptr,TellDir(conn->dirptr)));
 598
 599     if (dname == NULL)
 600       return(False);
 601
 602     pstrcpy(filename,dname);
 603
 604     /* notice the special *.* handling. This appears to be the only difference
 605        between the wildcard handling in this routine and in the trans2 routines.
 606        see masktest for a demo
 607     */
 608     if ((strcmp(mask,"*.*") == 0) ||
 609         mask_match(filename,mask,False) ||
 610         (name_map_mangle(filename,True,False,SNUM(conn)) &&
 611          mask_match(filename,mask,False)))
 612     {
 613       if (isrootdir && (strequal(filename,"..") || strequal(filename,".")))
 614         continue;
 615
 616       if (!is_8_3(filename, False)) {
 617               name_map_mangle(filename,True,False,SNUM(conn));
 618       }
 619
 620       pstrcpy(fname,filename);
 621       *path = 0;
 622       pstrcpy(path,conn->dirpath);
 623       if(needslash)
 624         pstrcat(path,"/");
 625       pstrcpy(pathreal,path);
 626       pstrcat(path,fname);
 627       pstrcat(pathreal,dname);
 628       if (conn->vfs_ops.stat(conn,dos_to_unix(pathreal, False), &sbuf) != 0)
 629       {
 630         DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",path, strerror(errno) ));
 631         continue;
 632       }
 633
 634       *mode = dos_mode(conn,pathreal,&sbuf);
 635
 636       if (!dir_check_ftype(conn,*mode,&sbuf,dirtype))
 637       {
 638         DEBUG(5,("[%s] attribs didn't match %x\n",filename,dirtype));
 639         continue;
 640       }
 641
 642       *size = sbuf.st_size;
 643       *date = sbuf.st_mtime;
 644
 645       DEBUG(3,("get_dir_entry mask=[%s] found %s fname=%s\n",mask, pathreal,fname));
 646
 647       found = True;
 648     }
 649   }
 650
 651   return(found);
 652 }
 653
 654
 655
 656 typedef struct
 657 {
 658   int pos;
 659   int numentries;
 660   int mallocsize;
 661   char *data;
 662   char *current;
 663 } Dir;
 664
 665
 666
 667 /*******************************************************************
 668 check to see if a user can read a file. This is only approximate,
 669 it is used as part of the "hide unreadable" option. Don't
 670 use it for anything security sensitive
 671 ********************************************************************/
 672 static BOOL user_can_read_file(connection_struct *conn, char *name)
 673 {
 674         SMB_STRUCT_STAT ste;
 675
 676         /* if we can't stat it does not show it */
 677         if (vfs_stat(conn, name, &ste) != 0) return False;
 678
 679         if (ste.st_uid == conn->uid) {
 680                 return (ste.st_mode & S_IRUSR) == S_IRUSR;
 681         } else {
 682                 int i;
 683                 if (ste.st_gid == conn->gid) {
 684                         return (ste.st_mode & S_IRGRP) == S_IRGRP;
 685                 }
 686                 for (i=0; i<conn->ngroups; i++) {
 687                         if (conn->groups[i] == ste.st_gid) {
 688                                 return (ste.st_mode & S_IRGRP) == S_IRGRP;
 689                         }
 690                 }
 691         }
 692
 693         return (ste.st_mode & S_IROTH) == S_IROTH;
 694 }
 695
 696 /*******************************************************************
 697  Open a directory.
 698 ********************************************************************/
 699
 700 void *OpenDir(connection_struct *conn, char *name, BOOL use_veto)
 701 {
 702   Dir *dirp;
 703   char *n;
 704   DIR *p = conn->vfs_ops.opendir(conn,dos_to_unix(name,False));
 705   int used=0;
 706
 707   if (!p) return(NULL);
 708   dirp = (Dir *)malloc(sizeof(Dir));
 709   if (!dirp) {
 710     DEBUG(0,("Out of memory in OpenDir\n"));
 711     conn->vfs_ops.closedir(conn,p);
 712     return(NULL);
 713   }
 714   dirp->pos = dirp->numentries = dirp->mallocsize = 0;
 715   dirp->data = dirp->current = NULL;
 716
 717   while ((n = vfs_readdirname(conn, p)))
 718   {
 719     int l;
 720
 721     l = strlen(n)+1;
 722
 723     /* Return value of vfs_readdirname has already gone through
 724        unix_to_dos() */
 725
 726     /* If it's a vetoed file, pretend it doesn't even exist */
 727     if (use_veto && conn && IS_VETO_PATH(conn, n)) continue;
 728
 729     /* Honour _hide unreadable_ option */
 730     if (conn && lp_hideunreadable(SNUM(conn))) {
 731             char *entry;
 732             int ret=0;
 733
 734             if (asprintf(&entry, "%s/%s/%s", conn->origpath, name, n) > 0) {
 735                     ret = user_can_read_file(conn, entry);
 736                     free(entry);
 737             }
 738             if (!ret) continue;
 739     }
 740
 741     if (used + l > dirp->mallocsize) {
 742       int s = MAX(used+l,used+2000);
 743       char *r;
 744       r = (char *)Realloc(dirp->data,s);
 745       if (!r) {
 746         DEBUG(0,("Out of memory in OpenDir\n"));
 747         break;
 748       }
 749       dirp->data = r;
 750       dirp->mallocsize = s;
 751       dirp->current = dirp->data;
 752     }
 753     pstrcpy(dirp->data+used,n);
 754     used += l;
 755     dirp->numentries++;
 756   }
 757
 758   conn->vfs_ops.closedir(conn,p);
 759   return((void *)dirp);
 760 }
 761
 762
 763 /*******************************************************************
 764  Close a directory.
 765 ********************************************************************/
 766
 767 void CloseDir(void *p)
 768 {
 769   Dir *dirp = (Dir *)p;
 770   if (!dirp) return;
 771   if (dirp->data) free(dirp->data);
 772   free(dirp);
 773 }
 774
 775 /*******************************************************************
 776  Read from a directory.
 777 ********************************************************************/
 778
 779 char *ReadDirName(void *p)
 780 {
 781   char *ret;
 782   Dir *dirp = (Dir *)p;
 783
 784   if (!dirp || !dirp->current || dirp->pos >= dirp->numentries) return(NULL);
 785
 786   ret = dirp->current;
 787   dirp->current = skip_string(dirp->current,1);
 788   dirp->pos++;
 789
 790   return(ret);
 791 }
 792
 793
 794 /*******************************************************************
 795  Seek a dir.
 796 ********************************************************************/
 797
 798 BOOL SeekDir(void *p,int pos)
 799 {
 800   Dir *dirp = (Dir *)p;
 801
 802   if (!dirp) return(False);
 803
 804   if (pos < dirp->pos) {
 805     dirp->current = dirp->data;
 806     dirp->pos = 0;
 807   }
 808
 809   while (dirp->pos < pos && ReadDirName(p)) ;
 810
 811   return(dirp->pos == pos);
 812 }
 813
 814 /*******************************************************************
 815  Tell a dir position.
 816 ********************************************************************/
 817
 818 int TellDir(void *p)
 819 {
 820   Dir *dirp = (Dir *)p;
 821
 822   if (!dirp) return(-1);
 823
 824   return(dirp->pos);
 825 }
 826
 827 /*******************************************************************************
 828  This section manages a global directory cache.
 829  (It should probably be split into a separate module.  crh)
 830 ********************************************************************************/
 831
 832 typedef struct {
 833   ubi_dlNode  node;
 834   char       *path;
 835   char       *name;
 836   char       *dname;
 837   int         snum;
 838 } dir_cache_entry;
 839
 840 static ubi_dlNewList( dir_cache );
 841
 842 /*****************************************************************************
 843  Add an entry to the directory cache.
 844  Input:  path  -
 845          name  -
 846          dname -
 847          snum  -
 848  Output: None.
 849 *****************************************************************************/
 850
 851 void DirCacheAdd( char *path, char *name, char *dname, int snum )
 852 {
 853   int               pathlen;
 854   int               namelen;
 855   dir_cache_entry  *entry;
 856
 857   /* Allocate the structure & string space in one go so that it can be freed
 858    * in one call to free().
 859    */
 860   pathlen = strlen( path ) +1;  /* Bytes required to store path (with nul). */
 861   namelen = strlen( name ) +1;  /* Bytes required to store name (with nul). */
 862   entry = (dir_cache_entry *)malloc( sizeof( dir_cache_entry )
 863                                    + pathlen
 864                                    + namelen
 865                                    + strlen( dname ) +1 );
 866   if( NULL == entry )   /* Not adding to the cache is not fatal,  */
 867     return;             /* so just return as if nothing happened. */
 868
 869   /* Set pointers correctly and load values. */
 870   entry->path  = pstrcpy( (char *)&entry[1],       path);
 871   entry->name  = pstrcpy( &(entry->path[pathlen]), name);
 872   entry->dname = pstrcpy( &(entry->name[namelen]), dname);
 873   entry->snum  = snum;
 874
 875   /* Add the new entry to the linked list. */
 876   (void)ubi_dlAddHead( dir_cache, entry );
 877   DEBUG( 4, ("Added dir cache entry %s %s -> %s\n", path, name, dname ) );
 878
 879   /* Free excess cache entries. */
 880   while( DIRCACHESIZE < dir_cache->count )
 881     free( ubi_dlRemTail( dir_cache ) );
 882
 883 }
 884
 885 /*****************************************************************************
 886  Search for an entry to the directory cache.
 887  Input:  path  -
 888          name  -
 889          snum  -
 890  Output: The dname string of the located entry, or NULL if the entry was
 891          not found.
 892
 893  Notes:  This uses a linear search, which is is okay because of
 894          the small size of the cache.  Use a splay tree or hash
 895          for large caches.
 896 *****************************************************************************/
 897
 898 char *DirCacheCheck( char *path, char *name, int snum )
 899 {
 900   dir_cache_entry *entry;
 901
 902   for( entry = (dir_cache_entry *)ubi_dlFirst( dir_cache );
 903        NULL != entry;
 904        entry = (dir_cache_entry *)ubi_dlNext( entry ) )
 905     {
 906     if( entry->snum == snum
 907         && 0 == strcmp( name, entry->name )
 908         && 0 == strcmp( path, entry->path ) )
 909       {
 910       DEBUG(4, ("Got dir cache hit on %s %s -> %s\n",path,name,entry->dname));
 911       return( entry->dname );
 912       }
 913     }
 914
 915   return(NULL);
 916 }
 917
 918 /*****************************************************************************
 919  Remove all cache entries which have an snum that matches the input.
 920  Input:  snum  -
 921  Output: None.
 922 *****************************************************************************/
 923
 924 void DirCacheFlush(int snum)
 925 {
 926         dir_cache_entry *entry;
 927         ubi_dlNodePtr    next;
 928
 929         for(entry = (dir_cache_entry *)ubi_dlFirst( dir_cache );
 930             NULL != entry; )  {
 931                 next = ubi_dlNext( entry );
 932                 if( entry->snum == snum )
 933                         free( ubi_dlRemThis( dir_cache, entry ) );
 934                 entry = (dir_cache_entry *)next;
 935         }
 936 }