release/src/router/samba/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     BOOL filename_is_mask = False;
 595     dname = ReadDirName(conn->dirptr);
 596
 597     DEBUG(6,("readdir on dirptr 0x%lx now at offset %d\n",
 598           (long)conn->dirptr,TellDir(conn->dirptr)));
 599
 600     if (dname == NULL)
 601       return(False);
 602
 603     pstrcpy(filename,dname);
 604
 605     if ((filename_is_mask = (strcmp(filename,mask) == 0)) ||
 606         (name_map_mangle(filename,True,False,SNUM(conn)) &&
 607          mask_match(filename,mask,False,False)))
 608     {
 609       if (isrootdir && (strequal(filename,"..") || strequal(filename,".")))
 610         continue;
 611
 612       pstrcpy(fname,filename);
 613       *path = 0;
 614       pstrcpy(path,conn->dirpath);
 615       if(needslash)
 616         pstrcat(path,"/");
 617       pstrcpy(pathreal,path);
 618       pstrcat(path,fname);
 619       pstrcat(pathreal,dname);
 620       if (dos_stat(pathreal,&sbuf) != 0)
 621       {
 622         DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",path, strerror(errno) ));
 623         continue;
 624       }
 625
 626       if (check_descend && !strequal(fname,".") && !strequal(fname,".."))
 627         continue;
 628
 629       *mode = dos_mode(conn,pathreal,&sbuf);
 630
 631       if (!dir_check_ftype(conn,*mode,&sbuf,dirtype))
 632       {
 633         DEBUG(5,("[%s] attribs didn't match %x\n",filename,dirtype));
 634         continue;
 635       }
 636
 637       if (!filename_is_mask)
 638       {
 639         /* Now we can allow the mangled cache to be updated */
 640         pstrcpy(filename,dname);
 641         name_map_mangle(filename,True,True,SNUM(conn));
 642       }
 643
 644       *size = sbuf.st_size;
 645       *date = sbuf.st_mtime;
 646
 647       DEBUG(5,("get_dir_entry found %s fname=%s\n",pathreal,fname));
 648
 649       found = True;
 650     }
 651   }
 652
 653   return(found);
 654 }
 655
 656
 657
 658 typedef struct
 659 {
 660   int pos;
 661   int numentries;
 662   int mallocsize;
 663   char *data;
 664   char *current;
 665 } Dir;
 666
 667
 668 /*******************************************************************
 669  Open a directory.
 670 ********************************************************************/
 671
 672 void *OpenDir(connection_struct *conn, char *name, BOOL use_veto)
 673 {
 674   Dir *dirp;
 675   char *n;
 676   DIR *p = dos_opendir(name);
 677   int used=0;
 678
 679   if (!p) return(NULL);
 680   dirp = (Dir *)malloc(sizeof(Dir));
 681   if (!dirp) {
 682     closedir(p);
 683     return(NULL);
 684   }
 685   dirp->pos = dirp->numentries = dirp->mallocsize = 0;
 686   dirp->data = dirp->current = NULL;
 687
 688   while ((n = dos_readdirname(p)))
 689   {
 690     int l = strlen(n)+1;
 691
 692     /* If it's a vetoed file, pretend it doesn't even exist */
 693     if (use_veto && conn && IS_VETO_PATH(conn, n)) continue;
 694
 695     if (used + l > dirp->mallocsize) {
 696       int s = MAX(used+l,used+2000);
 697       char *r;
 698       r = (char *)Realloc(dirp->data,s);
 699       if (!r) {
 700         DEBUG(0,("Out of memory in OpenDir\n"));
 701         break;
 702       }
 703       dirp->data = r;
 704       dirp->mallocsize = s;
 705       dirp->current = dirp->data;
 706     }
 707     pstrcpy(dirp->data+used,n);
 708     used += l;
 709     dirp->numentries++;
 710   }
 711
 712   closedir(p);
 713   return((void *)dirp);
 714 }
 715
 716
 717 /*******************************************************************
 718  Close a directory.
 719 ********************************************************************/
 720
 721 void CloseDir(void *p)
 722 {
 723   Dir *dirp = (Dir *)p;
 724   if (!dirp) return;
 725   if (dirp->data) free(dirp->data);
 726   free(dirp);
 727 }
 728
 729 /*******************************************************************
 730  Read from a directory.
 731 ********************************************************************/
 732
 733 char *ReadDirName(void *p)
 734 {
 735   char *ret;
 736   Dir *dirp = (Dir *)p;
 737
 738   if (!dirp || !dirp->current || dirp->pos >= dirp->numentries) return(NULL);
 739
 740   ret = dirp->current;
 741   dirp->current = skip_string(dirp->current,1);
 742   dirp->pos++;
 743
 744   return(ret);
 745 }
 746
 747
 748 /*******************************************************************
 749  Seek a dir.
 750 ********************************************************************/
 751
 752 BOOL SeekDir(void *p,int pos)
 753 {
 754   Dir *dirp = (Dir *)p;
 755
 756   if (!dirp) return(False);
 757
 758   if (pos < dirp->pos) {
 759     dirp->current = dirp->data;
 760     dirp->pos = 0;
 761   }
 762
 763   while (dirp->pos < pos && ReadDirName(p)) ;
 764
 765   return(dirp->pos == pos);
 766 }
 767
 768 /*******************************************************************
 769  Tell a dir position.
 770 ********************************************************************/
 771
 772 int TellDir(void *p)
 773 {
 774   Dir *dirp = (Dir *)p;
 775
 776   if (!dirp) return(-1);
 777
 778   return(dirp->pos);
 779 }
 780
 781
 782 /* -------------------------------------------------------------------------- **
 783  * This section manages a global directory cache.
 784  * (It should probably be split into a separate module.  crh)
 785  * -------------------------------------------------------------------------- **
 786  */
 787
 788 typedef struct
 789   {
 790   ubi_dlNode  node;
 791   char       *path;
 792   char       *name;
 793   char       *dname;
 794   int         snum;
 795   } dir_cache_entry;
 796
 797 static ubi_dlNewList( dir_cache );
 798
 799 void DirCacheAdd( char *path, char *name, char *dname, int snum )
 800   /* ------------------------------------------------------------------------ **
 801    * Add an entry to the directory cache.
 802    *
 803    *  Input:  path  -
 804    *          name  -
 805    *          dname -
 806    *          snum  -
 807    *
 808    *  Output: None.
 809    *
 810    * ------------------------------------------------------------------------ **
 811    */
 812   {
 813   int               pathlen;
 814   int               namelen;
 815   dir_cache_entry  *entry;
 816
 817   /* Allocate the structure & string space in one go so that it can be freed
 818    * in one call to free().
 819    */
 820   pathlen = strlen( path ) +1;  /* Bytes required to store path (with nul). */
 821   namelen = strlen( name ) +1;  /* Bytes required to store name (with nul). */
 822   entry = (dir_cache_entry *)malloc( sizeof( dir_cache_entry )
 823                                    + pathlen
 824                                    + namelen
 825                                    + strlen( dname ) +1 );
 826   if( NULL == entry )   /* Not adding to the cache is not fatal,  */
 827     return;             /* so just return as if nothing happened. */
 828
 829   /* Set pointers correctly and load values. */
 830   entry->path  = pstrcpy( (char *)&entry[1],       path);
 831   entry->name  = pstrcpy( &(entry->path[pathlen]), name);
 832   entry->dname = pstrcpy( &(entry->name[namelen]), dname);
 833   entry->snum  = snum;
 834
 835   /* Add the new entry to the linked list. */
 836   (void)ubi_dlAddHead( dir_cache, entry );
 837   DEBUG( 4, ("Added dir cache entry %s %s -> %s\n", path, name, dname ) );
 838
 839   /* Free excess cache entries. */
 840   while( DIRCACHESIZE < dir_cache->count )
 841     free( ubi_dlRemTail( dir_cache ) );
 842
 843   } /* DirCacheAdd */
 844
 845
 846 char *DirCacheCheck( char *path, char *name, int snum )
 847   /* ------------------------------------------------------------------------ **
 848    * Search for an entry to the directory cache.
 849    *
 850    *  Input:  path  -
 851    *          name  -
 852    *          snum  -
 853    *
 854    *  Output: The dname string of the located entry, or NULL if the entry was
 855    *          not found.
 856    *
 857    *  Notes:  This uses a linear search, which is is okay because of
 858    *          the small size of the cache.  Use a splay tree or hash
 859    *          for large caches.
 860    *
 861    * ------------------------------------------------------------------------ **
 862    */
 863   {
 864   dir_cache_entry *entry;
 865
 866   for( entry = (dir_cache_entry *)ubi_dlFirst( dir_cache );
 867        NULL != entry;
 868        entry = (dir_cache_entry *)ubi_dlNext( entry ) )
 869     {
 870     if( entry->snum == snum
 871         && 0 == strcmp( name, entry->name )
 872         && 0 == strcmp( path, entry->path ) )
 873       {
 874       DEBUG(4, ("Got dir cache hit on %s %s -> %s\n",path,name,entry->dname));
 875       return( entry->dname );
 876       }
 877     }
 878
 879   return(NULL);
 880   } /* DirCacheCheck */
 881
 882 void DirCacheFlush(int snum)
 883   /* ------------------------------------------------------------------------ **
 884    * Remove all cache entries which have an snum that matches the input.
 885    *
 886    *  Input:  snum  -
 887    *
 888    *  Output: None.
 889    *
 890    * ------------------------------------------------------------------------ **
 891    */
 892 {
 893         dir_cache_entry *entry;
 894         ubi_dlNodePtr    next;
 895
 896         for(entry = (dir_cache_entry *)ubi_dlFirst( dir_cache );
 897             NULL != entry; )  {
 898                 next = ubi_dlNext( entry );
 899                 if( entry->snum == snum )
 900                         free( ubi_dlRemThis( dir_cache, entry ) );
 901                 entry = (dir_cache_entry *)next;
 902         }
 903 } /* DirCacheFlush */
 904
 905 /* -------------------------------------------------------------------------- **
 906  * End of the section that manages the global directory cache.
 907  * -------------------------------------------------------------------------- **
 908  */
 909
 910