home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 July & August / Pcwk78a98.iso / Wtestowe / Clico / UNIX / SAMBA / SOURCE / SAMBA.TAR / samba-1.9.17 / source / dir.c < prev    next >
C/C++ Source or Header  |  1997-08-22  |  25KB  |  997 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    Directory handling routines
  5.    Copyright (C) Andrew Tridgell 1992-1997
  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. extern connection_struct Connections[];
  26.  
  27. /*
  28.    This module implements directory related functions for Samba.
  29. */
  30.  
  31.  
  32.  
  33. uint32 dircounter = 0;
  34.  
  35.  
  36. #define NUMDIRPTRS 256
  37.  
  38.  
  39. static struct dptr_struct
  40. {
  41.   int pid;
  42.   int cnum;
  43.   uint32 lastused;
  44.   void *ptr;
  45.   BOOL valid;
  46.   BOOL finished;
  47.   BOOL expect_close;
  48.   char *wcard; /* Field only used for lanman2 trans2_findfirst/next searches */
  49.   uint16 attr; /* Field only used for lanman2 trans2_findfirst/next searches */
  50.   char *path;
  51. }
  52. dirptrs[NUMDIRPTRS];
  53.  
  54.  
  55. static int dptrs_open = 0;
  56.  
  57. /****************************************************************************
  58. initialise the dir array
  59. ****************************************************************************/
  60. void init_dptrs(void)
  61. {
  62.   static BOOL dptrs_init=False;
  63.   int i;
  64.  
  65.   if (dptrs_init) return;
  66.   for (i=0;i<NUMDIRPTRS;i++)    
  67.     {
  68.       dirptrs[i].valid = False;
  69.       dirptrs[i].wcard = NULL;
  70.       dirptrs[i].ptr = NULL;
  71.       string_init(&dirptrs[i].path,"");
  72.     }
  73.   dptrs_init = True;
  74. }
  75.  
  76. /****************************************************************************
  77. idle a dptr - the directory is closed but the control info is kept
  78. ****************************************************************************/
  79. static void dptr_idle(int key)
  80. {
  81.   if (dirptrs[key].valid && dirptrs[key].ptr) {
  82.     DEBUG(4,("Idling dptr key %d\n",key));
  83.     dptrs_open--;
  84.     CloseDir(dirptrs[key].ptr);
  85.     dirptrs[key].ptr = NULL;
  86.   }    
  87. }
  88.  
  89. /****************************************************************************
  90. idle the oldest dptr
  91. ****************************************************************************/
  92. static void dptr_idleoldest(void)
  93. {
  94.   int i;
  95.   uint32 old=dircounter+1;
  96.   int oldi= -1;
  97.   for (i=0;i<NUMDIRPTRS;i++)
  98.     if (dirptrs[i].valid && dirptrs[i].ptr && dirptrs[i].lastused < old) {
  99.       old = dirptrs[i].lastused;
  100.       oldi = i;
  101.     }
  102.   if (oldi != -1)
  103.     dptr_idle(oldi);
  104.   else
  105.     DEBUG(0,("No dptrs available to idle??\n"));
  106. }
  107.  
  108. /****************************************************************************
  109. get the dir ptr for a dir index
  110. ****************************************************************************/
  111. static void *dptr_get(int key,uint32 lastused)
  112. {
  113.   struct dptr_struct *dp = &dirptrs[key];
  114.  
  115.   if (dp->valid) {
  116.     if (lastused) dp->lastused = lastused;
  117.     if (!dp->ptr) {
  118.       if (dptrs_open >= MAXDIR)
  119.     dptr_idleoldest();
  120.       DEBUG(4,("Reopening dptr key %d\n",key));
  121.       if ((dp->ptr = OpenDir(dp->cnum, dp->path, True)))
  122.     dptrs_open++;
  123.     }
  124.     return(dp->ptr);
  125.   }
  126.   return(NULL);
  127. }
  128.  
  129. /****************************************************************************
  130. get the dir path for a dir index
  131. ****************************************************************************/
  132. char *dptr_path(int key)
  133. {
  134.   if (dirptrs[key].valid)
  135.     return(dirptrs[key].path);
  136.   return(NULL);
  137. }
  138.  
  139. /****************************************************************************
  140. get the dir wcard for a dir index (lanman2 specific)
  141. ****************************************************************************/
  142. char *dptr_wcard(int key)
  143. {
  144.   if (dirptrs[key].valid)
  145.     return(dirptrs[key].wcard);
  146.   return(NULL);
  147. }
  148.  
  149. /****************************************************************************
  150. set the dir wcard for a dir index (lanman2 specific)
  151. Returns 0 on ok, 1 on fail.
  152. ****************************************************************************/
  153. BOOL dptr_set_wcard(int key, char *wcard)
  154. {
  155.   if (dirptrs[key].valid) {
  156.     dirptrs[key].wcard = wcard;
  157.     return True;
  158.   }
  159.   return False;
  160. }
  161.  
  162. /****************************************************************************
  163. set the dir attrib for a dir index (lanman2 specific)
  164. Returns 0 on ok, 1 on fail.
  165. ****************************************************************************/
  166. BOOL dptr_set_attr(int key, uint16 attr)
  167. {
  168.   if (dirptrs[key].valid) {
  169.     dirptrs[key].attr = attr;
  170.     return True;
  171.   }
  172.   return False;
  173. }
  174.  
  175. /****************************************************************************
  176. get the dir attrib for a dir index (lanman2 specific)
  177. ****************************************************************************/
  178. uint16 dptr_attr(int key)
  179. {
  180.   if (dirptrs[key].valid)
  181.     return(dirptrs[key].attr);
  182.   return(0);
  183. }
  184.  
  185. /****************************************************************************
  186. close a dptr
  187. ****************************************************************************/
  188. void dptr_close(int key)
  189. {
  190.   /* OS/2 seems to use -1 to indicate "close all directories" */
  191.   if (key == -1) {
  192.     int i;
  193.     for (i=0;i<NUMDIRPTRS;i++) 
  194.       dptr_close(i);
  195.     return;
  196.   }
  197.  
  198.   if (key < 0 || key >= NUMDIRPTRS) {
  199.     DEBUG(3,("Invalid key %d given to dptr_close\n",key));
  200.     return;
  201.   }
  202.  
  203.   if (dirptrs[key].valid) {
  204.     DEBUG(4,("closing dptr key %d\n",key));
  205.     if (dirptrs[key].ptr) {
  206.       CloseDir(dirptrs[key].ptr);
  207.       dptrs_open--;
  208.     }
  209.     /* Lanman 2 specific code */
  210.     if (dirptrs[key].wcard)
  211.       free(dirptrs[key].wcard);
  212.     dirptrs[key].valid = False;
  213.     string_set(&dirptrs[key].path,"");
  214.   }
  215. }
  216.  
  217. /****************************************************************************
  218. close all dptrs for a cnum
  219. ****************************************************************************/
  220. void dptr_closecnum(int cnum)
  221. {
  222.   int i;
  223.   for (i=0;i<NUMDIRPTRS;i++)
  224.     if (dirptrs[i].valid && dirptrs[i].cnum == cnum)
  225.       dptr_close(i);
  226. }
  227.  
  228. /****************************************************************************
  229. idle all dptrs for a cnum
  230. ****************************************************************************/
  231. void dptr_idlecnum(int cnum)
  232. {
  233.   int i;
  234.   for (i=0;i<NUMDIRPTRS;i++)
  235.     if (dirptrs[i].valid && dirptrs[i].cnum == cnum && dirptrs[i].ptr)
  236.       dptr_idle(i);
  237. }
  238.  
  239. /****************************************************************************
  240. close a dptr that matches a given path, only if it matches the pid also
  241. ****************************************************************************/
  242. void dptr_closepath(char *path,int pid)
  243. {
  244.   int i;
  245.   for (i=0;i<NUMDIRPTRS;i++)
  246.     if (dirptrs[i].valid && pid == dirptrs[i].pid &&
  247.     strequal(dirptrs[i].path,path))
  248.       dptr_close(i);
  249. }
  250.  
  251. /****************************************************************************
  252.   start a directory listing
  253. ****************************************************************************/
  254. static BOOL start_dir(int cnum,char *directory)
  255. {
  256.   DEBUG(5,("start_dir cnum=%d dir=%s\n",cnum,directory));
  257.  
  258.   if (!check_name(directory,cnum))
  259.     return(False);
  260.   
  261.   if (! *directory)
  262.     directory = ".";
  263.  
  264.   Connections[cnum].dirptr = OpenDir(cnum, directory, True);
  265.   if (Connections[cnum].dirptr) {    
  266.     dptrs_open++;
  267.     string_set(&Connections[cnum].dirpath,directory);
  268.     return(True);
  269.   }
  270.   
  271.   return(False);
  272. }
  273.  
  274.  
  275. /****************************************************************************
  276. create a new dir ptr
  277. ****************************************************************************/
  278. int dptr_create(int cnum,char *path, BOOL expect_close,int pid)
  279. {
  280.   int i;
  281.   uint32 old;
  282.   int oldi;
  283.  
  284.   if (!start_dir(cnum,path))
  285.     return(-2); /* Code to say use a unix error return code. */
  286.  
  287.   if (dptrs_open >= MAXDIR)
  288.     dptr_idleoldest();
  289.  
  290.   for (i=0;i<NUMDIRPTRS;i++)
  291.     if (!dirptrs[i].valid)
  292.       break;
  293.   if (i == NUMDIRPTRS) i = -1;
  294.  
  295.  
  296.   /* as a 2nd option, grab the oldest not marked for expect_close */
  297.   if (i == -1) {
  298.     old=dircounter+1;
  299.     oldi= -1;
  300.     for (i=0;i<NUMDIRPTRS;i++)
  301.       if (!dirptrs[i].expect_close && dirptrs[i].lastused < old) {
  302.     old = dirptrs[i].lastused;
  303.     oldi = i;
  304.       }
  305.     i = oldi;
  306.   }
  307.  
  308.   /* a 3rd option - grab the oldest one */
  309.   if (i == -1) {
  310.     old=dircounter+1;
  311.     oldi= -1;
  312.     for (i=0;i<NUMDIRPTRS;i++)
  313.       if (dirptrs[i].lastused < old) {
  314.     old = dirptrs[i].lastused;
  315.     oldi = i;
  316.       }
  317.     i = oldi;
  318.   }
  319.  
  320.   if (i == -1) {
  321.     DEBUG(0,("Error - all dirptrs in use??\n"));
  322.     return(-1);
  323.   }
  324.  
  325.   if (dirptrs[i].valid)
  326.     dptr_close(i);
  327.  
  328.   dirptrs[i].ptr = Connections[cnum].dirptr;
  329.   string_set(&dirptrs[i].path,path);
  330.   dirptrs[i].lastused = dircounter++;
  331.   dirptrs[i].finished = False;
  332.   dirptrs[i].cnum = cnum;
  333.   dirptrs[i].pid = pid;
  334.   dirptrs[i].expect_close = expect_close;
  335.   dirptrs[i].wcard = NULL; /* Only used in lanman2 searches */
  336.   dirptrs[i].attr = 0; /* Only used in lanman2 searches */
  337.   dirptrs[i].valid = True;
  338.  
  339.   DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
  340.        i,path,expect_close));  
  341.  
  342.   return(i);
  343. }
  344.  
  345. #define DPTR_MASK ((uint32)(((uint32)1)<<31))
  346.  
  347. /****************************************************************************
  348. fill the 5 byte server reserved dptr field
  349. ****************************************************************************/
  350. BOOL dptr_fill(char *buf1,unsigned int key)
  351. {
  352.   unsigned char *buf = (unsigned char *)buf1;
  353.   void *p = dptr_get(key,0);
  354.   uint32 offset;
  355.   if (!p) {
  356.     DEBUG(1,("filling null dirptr %d\n",key));
  357.     return(False);
  358.   }
  359.   offset = TellDir(p);
  360.   DEBUG(6,("fill on key %d dirptr 0x%x now at %d\n",key,p,offset));
  361.   buf[0] = key;
  362.   SIVAL(buf,1,offset | DPTR_MASK);
  363.   return(True);
  364. }
  365.  
  366.  
  367. /****************************************************************************
  368. return True is the offset is at zero
  369. ****************************************************************************/
  370. BOOL dptr_zero(char *buf)
  371. {
  372.   return((IVAL(buf,1)&~DPTR_MASK) == 0);
  373. }
  374.  
  375. /****************************************************************************
  376. fetch the dir ptr and seek it given the 5 byte server field
  377. ****************************************************************************/
  378. void *dptr_fetch(char *buf,int *num)
  379. {
  380.   unsigned int key = *(unsigned char *)buf;
  381.   void *p = dptr_get(key,dircounter++);
  382.   uint32 offset;
  383.   if (!p) {
  384.     DEBUG(3,("fetched null dirptr %d\n",key));
  385.     return(NULL);
  386.   }
  387.   *num = key;
  388.   offset = IVAL(buf,1)&~DPTR_MASK;
  389.   SeekDir(p,offset);
  390.   DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
  391.        key,dptr_path(key),offset));
  392.   return(p);
  393. }
  394.  
  395. /****************************************************************************
  396. fetch the dir ptr and seek it given the lanman2 parameter block
  397. ****************************************************************************/
  398. void *dptr_fetch_lanman2(char *params,int dptr_num)
  399. {
  400.   void *p = dptr_get(dptr_num,dircounter++);
  401.   uint32 resume_key = SVAL(params,6);
  402.   BOOL uses_resume_key = BITSETW(params+10,2);
  403.   BOOL continue_bit = BITSETW(params+10,3);
  404.  
  405.   if (!p) {
  406.     DEBUG(3,("fetched null dirptr %d\n",dptr_num));
  407.     return(NULL);
  408.   }
  409.   if(uses_resume_key && !continue_bit)
  410.     SeekDir(p,resume_key);
  411.   DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
  412.   return(p);
  413. }
  414.  
  415. /****************************************************************************
  416. check a filetype for being valid
  417. ****************************************************************************/
  418. BOOL dir_check_ftype(int cnum,int mode,struct stat *st,int dirtype)
  419. {
  420.   if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
  421.     return False;
  422.   return True;
  423. }
  424.  
  425. /****************************************************************************
  426.   get a directory entry
  427. ****************************************************************************/
  428. BOOL get_dir_entry(int cnum,char *mask,int dirtype,char *fname,int *size,int *mode,time_t *date,BOOL check_descend)
  429. {
  430.   char *dname;
  431.   BOOL found = False;
  432.   struct stat sbuf;
  433.   pstring path;
  434.   pstring pathreal;
  435.   BOOL isrootdir;
  436.   pstring filename;
  437.   BOOL matched;
  438.   BOOL needslash;
  439.  
  440.   *path = *pathreal = *filename = 0;
  441.  
  442.   isrootdir = (strequal(Connections[cnum].dirpath,"./") ||
  443.            strequal(Connections[cnum].dirpath,".") ||
  444.            strequal(Connections[cnum].dirpath,"/"));
  445.   
  446.   needslash = 
  447.         ( Connections[cnum].dirpath[strlen(Connections[cnum].dirpath) -1] != '/');
  448.  
  449.   if (!Connections[cnum].dirptr)
  450.     return(False);
  451.   
  452.   while (!found)
  453.     {
  454.       dname = ReadDirName(Connections[cnum].dirptr);
  455.  
  456.       DEBUG(6,("readdir on dirptr 0x%x now at offset %d\n",
  457.         Connections[cnum].dirptr,TellDir(Connections[cnum].dirptr)));
  458.       
  459.       if (dname == NULL) 
  460.     return(False);
  461.       
  462.       matched = False;
  463.  
  464.       strcpy(filename,dname);      
  465.  
  466.       if ((strcmp(filename,mask) == 0) ||
  467.       (name_map_mangle(filename,True,SNUM(cnum)) &&
  468.        mask_match(filename,mask,False,False)))
  469.     {
  470.       if (isrootdir && (strequal(filename,"..") || strequal(filename,".")))
  471.         continue;
  472.  
  473.       strcpy(fname,filename);
  474.       *path = 0;
  475.       strcpy(path,Connections[cnum].dirpath);
  476.           if(needslash)
  477.           strcat(path,"/");
  478.       strcpy(pathreal,path);
  479.       strcat(path,fname);
  480.       strcat(pathreal,dname);
  481.       if (sys_stat(pathreal,&sbuf) != 0) 
  482.         {
  483.           DEBUG(5,("Couldn't stat 1 [%s]\n",path));
  484.           continue;
  485.         }
  486.  
  487.       if (check_descend &&
  488.           !strequal(fname,".") && !strequal(fname,".."))
  489.         continue;
  490.       
  491.       *mode = dos_mode(cnum,pathreal,&sbuf);
  492.  
  493.       if (!dir_check_ftype(cnum,*mode,&sbuf,dirtype)) {
  494.         DEBUG(5,("[%s] attribs didn't match %x\n",filename,dirtype));
  495.         continue;
  496.       }
  497.  
  498.       *size = sbuf.st_size;
  499.       *date = sbuf.st_mtime;
  500.  
  501.       DEBUG(5,("get_dir_entry found %s fname=%s\n",pathreal,fname));
  502.       
  503.       found = True;
  504.     }
  505.     }
  506.  
  507.   return(found);
  508. }
  509.  
  510.  
  511.  
  512. typedef struct
  513. {
  514.   int pos;
  515.   int numentries;
  516.   int mallocsize;
  517.   char *data;
  518.   char *current;
  519. } Dir;
  520.  
  521.  
  522. /*******************************************************************
  523. open a directory
  524. ********************************************************************/
  525. void *OpenDir(int cnum, char *name, BOOL use_veto)
  526. {
  527.   Dir *dirp;
  528.   char *n;
  529.   void *p = sys_opendir(name);
  530.   int used=0;
  531.  
  532.   if (!p) return(NULL);
  533.   dirp = (Dir *)malloc(sizeof(Dir));
  534.   if (!dirp) {
  535.     closedir(p);
  536.     return(NULL);
  537.   }
  538.   dirp->pos = dirp->numentries = dirp->mallocsize = 0;
  539.   dirp->data = dirp->current = NULL;
  540.  
  541.   while ((n = readdirname(p)))
  542.   {
  543.     int l = strlen(n)+1;
  544.  
  545.     /* If it's a vetoed file, pretend it doesn't even exist */
  546.     if (use_veto && IS_VETO_PATH(cnum, n)) continue;
  547.  
  548.     if (used + l > dirp->mallocsize) {
  549.       int s = MAX(used+l,used+2000);
  550.       char *r;
  551.       r = (char *)Realloc(dirp->data,s);
  552.       if (!r) {
  553.     DEBUG(0,("Out of memory in OpenDir\n"));
  554.     break;
  555.       }
  556.       dirp->data = r;
  557.       dirp->mallocsize = s;
  558.       dirp->current = dirp->data;
  559.     }
  560.     strcpy(dirp->data+used,n);
  561.     used += l;
  562.     dirp->numentries++;
  563.   }
  564.  
  565.   closedir(p);
  566.   return((void *)dirp);
  567. }
  568.  
  569.  
  570. /*******************************************************************
  571. close a directory
  572. ********************************************************************/
  573. void CloseDir(void *p)
  574. {
  575.   Dir *dirp = (Dir *)p;
  576.   if (!dirp) return;    
  577.   if (dirp->data) free(dirp->data);
  578.   free(dirp);
  579. }
  580.  
  581. /*******************************************************************
  582. read from a directory
  583. ********************************************************************/
  584. char *ReadDirName(void *p)
  585. {
  586.   char *ret;
  587.   Dir *dirp = (Dir *)p;
  588.  
  589.   if (!dirp || !dirp->current || dirp->pos >= dirp->numentries) return(NULL);
  590.  
  591.   ret = dirp->current;
  592.   dirp->current = skip_string(dirp->current,1);
  593.   dirp->pos++;
  594.  
  595.   return(ret);
  596. }
  597.  
  598.  
  599. /*******************************************************************
  600. seek a dir
  601. ********************************************************************/
  602. BOOL SeekDir(void *p,int pos)
  603. {
  604.   Dir *dirp = (Dir *)p;
  605.  
  606.   if (!dirp) return(False);
  607.  
  608.   if (pos < dirp->pos) {
  609.     dirp->current = dirp->data;
  610.     dirp->pos = 0;
  611.   }
  612.  
  613.   while (dirp->pos < pos && ReadDirName(p)) ;
  614.  
  615.   return(dirp->pos == pos);
  616. }
  617.  
  618. /*******************************************************************
  619. tell a dir position
  620. ********************************************************************/
  621. int TellDir(void *p)
  622. {
  623.   Dir *dirp = (Dir *)p;
  624.  
  625.   if (!dirp) return(-1);
  626.   
  627.   return(dirp->pos);
  628. }
  629.  
  630.  
  631. static int dir_cache_size = 0;
  632. static struct dir_cache {
  633.   struct dir_cache *next;
  634.   struct dir_cache *prev;
  635.   char *path;
  636.   char *name;
  637.   char *dname;
  638.   int snum;
  639. } *dir_cache = NULL;
  640.  
  641. /*******************************************************************
  642. add an entry to the directory cache
  643. ********************************************************************/
  644. void DirCacheAdd(char *path,char *name,char *dname,int snum)
  645. {
  646.   int count;
  647.   struct dir_cache *entry = (struct dir_cache *)malloc(sizeof(*entry));
  648.   if (!entry) return;
  649.   entry->path = strdup(path);
  650.   entry->name = strdup(name);
  651.   entry->dname = strdup(dname);
  652.   entry->snum = snum;
  653.   if (!entry->path || !entry->name || !entry->dname) return;
  654.  
  655.   entry->next = dir_cache;
  656.   entry->prev = NULL;
  657.   if (entry->next) entry->next->prev = entry;
  658.   dir_cache = entry;
  659.  
  660.   DEBUG(4,("Added dir cache entry %s %s -> %s\n",path,name,dname));
  661.   
  662.   if (dir_cache_size == DIRCACHESIZE) {
  663.     for (entry=dir_cache, count=1; 
  664.      entry->next && count < dir_cache_size + 1; 
  665.      entry=entry->next, count++) ;
  666.     if (entry->next || count != dir_cache_size + 1) {
  667.       DEBUG(0,("DirCache bug - please report %d %d\n",dir_cache_size,count));
  668.     }
  669.     free(entry->path);
  670.     free(entry->name);
  671.     free(entry->dname);
  672.     if (entry->prev) entry->prev->next = entry->next;
  673.     free(entry);
  674.   } else {
  675.     dir_cache_size++;
  676.   }
  677. }
  678.  
  679.  
  680. /*******************************************************************
  681. check for an entry in the directory cache
  682. ********************************************************************/
  683. char *DirCacheCheck(char *path,char *name,int snum)
  684. {
  685.   struct dir_cache *entry;
  686.  
  687.   for (entry=dir_cache; entry; entry=entry->next) {
  688.     if (entry->snum == snum &&
  689.     strcmp(path,entry->path) == 0 &&
  690.     strcmp(name,entry->name) == 0) {
  691.       DEBUG(4,("Got dir cache hit on %s %s -> %s\n",path,name,entry->dname));
  692.       return(entry->dname);
  693.     }
  694.   }
  695.  
  696.   return(NULL);
  697. }
  698.  
  699. /*******************************************************************
  700. flush entries in the dir_cache
  701. ********************************************************************/
  702. void DirCacheFlush(int snum)
  703. {
  704.   struct dir_cache *entry,*next;
  705.  
  706.   for (entry=dir_cache; entry; entry=next) {
  707.     if (entry->snum == snum) {
  708.       free(entry->path);
  709.       free(entry->dname);
  710.       free(entry->name);
  711.       next = entry->next;
  712.       if (entry->prev) entry->prev->next = entry->next;
  713.       if (entry->next) entry->next->prev = entry->prev;
  714.       if (dir_cache == entry) dir_cache = entry->next; 
  715.       free(entry);
  716.       dir_cache_size--;
  717.     } else {
  718.       next = entry->next;
  719.     }
  720.   }
  721. }
  722.  
  723.  
  724. #ifdef REPLACE_GETWD
  725. /* This is getcwd.c from bash.  It is needed in Interactive UNIX.  To
  726.  * add support for another OS you need to determine which of the
  727.  * conditional compilation macros you need to define.  All the options
  728.  * are defined for Interactive UNIX.
  729.  */
  730. #ifdef ISC
  731. #define HAVE_UNISTD_H
  732. #define USGr3
  733. #define USG
  734. #endif
  735.  
  736. #if defined (HAVE_UNISTD_H)
  737. #  include <unistd.h>
  738. #endif
  739.  
  740. #if defined (__STDC__)
  741. #  define CONST const
  742. #  define PTR void *
  743. #else /* !__STDC__ */
  744. #  define CONST
  745. #  define PTR char *
  746. #endif /* !__STDC__ */
  747.  
  748. #if !defined (PATH_MAX)
  749. #  if defined (MAXPATHLEN)
  750. #    define PATH_MAX MAXPATHLEN
  751. #  else /* !MAXPATHLEN */
  752. #    define PATH_MAX 1024
  753. #  endif /* !MAXPATHLEN */
  754. #endif /* !PATH_MAX */
  755.  
  756. #if defined (_POSIX_VERSION) || defined (USGr3) || defined (HAVE_DIRENT_H)
  757. #  if !defined (HAVE_DIRENT)
  758. #    define HAVE_DIRENT
  759. #  endif /* !HAVE_DIRENT */
  760. #endif /* _POSIX_VERSION || USGr3 || HAVE_DIRENT_H */
  761.  
  762. #if defined (HAVE_DIRENT)
  763. #  define D_NAMLEN(d)    (strlen ((d)->d_name))
  764. #else
  765. #  define D_NAMLEN(d)    ((d)->d_namlen)
  766. #endif /* ! (_POSIX_VERSION || USGr3) */
  767.  
  768. #if defined (USG) || defined (USGr3)
  769. #  define d_fileno d_ino
  770. #endif
  771.  
  772. #if !defined (alloca)
  773. extern char *alloca ();
  774. #endif /* alloca */
  775.  
  776. /* Get the pathname of the current working directory,
  777.    and put it in SIZE bytes of BUF.  Returns NULL if the
  778.    directory couldn't be determined or SIZE was too small.
  779.    If successful, returns BUF.  In GNU, if BUF is NULL,
  780.    an array is allocated with `malloc'; the array is SIZE
  781.    bytes long, unless SIZE <= 0, in which case it is as
  782.    big as necessary.  */
  783. #if defined (__STDC__)
  784. char *
  785. getcwd (char *buf, size_t size)
  786. #else /* !__STDC__ */
  787. char *
  788. getcwd (buf, size)
  789.      char *buf;
  790.      int size;
  791. #endif /* !__STDC__ */
  792. {
  793.   static CONST char dots[]
  794.     = "../../../../../../../../../../../../../../../../../../../../../../../\
  795. ../../../../../../../../../../../../../../../../../../../../../../../../../../\
  796. ../../../../../../../../../../../../../../../../../../../../../../../../../..";
  797.   CONST char *dotp, *dotlist;
  798.   size_t dotsize;
  799.   dev_t rootdev, thisdev;
  800.   ino_t rootino, thisino;
  801.   char path[PATH_MAX + 1];
  802.   register char *pathp;
  803.   char *pathbuf;
  804.   size_t pathsize;
  805.   struct stat st;
  806.  
  807.   if (buf != NULL && size == 0)
  808.     {
  809.       errno = EINVAL;
  810.       return ((char *)NULL);
  811.     }
  812.  
  813.   pathsize = sizeof (path);
  814.   pathp = &path[pathsize];
  815.   *--pathp = '\0';
  816.   pathbuf = path;
  817.  
  818.   if (stat (".", &st) < 0)
  819.     return ((char *)NULL);
  820.   thisdev = st.st_dev;
  821.   thisino = st.st_ino;
  822.  
  823.   if (stat ("/", &st) < 0)
  824.     return ((char *)NULL);
  825.   rootdev = st.st_dev;
  826.   rootino = st.st_ino;
  827.  
  828.   dotsize = sizeof (dots) - 1;
  829.   dotp = &dots[sizeof (dots)];
  830.   dotlist = dots;
  831.   while (!(thisdev == rootdev && thisino == rootino))
  832.     {
  833.       register DIR *dirstream;
  834.       register struct dirent *d;
  835.       dev_t dotdev;
  836.       ino_t dotino;
  837.       char mount_point;
  838.       int namlen;
  839.  
  840.       /* Look at the parent directory.  */
  841.       if (dotp == dotlist)
  842.     {
  843.       /* My, what a deep directory tree you have, Grandma.  */
  844.       char *new;
  845.       if (dotlist == dots)
  846.         {
  847.           new = malloc (dotsize * 2 + 1);
  848.           if (new == NULL)
  849.         goto lose;
  850.           memcpy (new, dots, dotsize);
  851.         }
  852.       else
  853.         {
  854.           new = realloc ((PTR) dotlist, dotsize * 2 + 1);
  855.           if (new == NULL)
  856.         goto lose;
  857.         }
  858.       memcpy (&new[dotsize], new, dotsize);
  859.       dotp = &new[dotsize];
  860.       dotsize *= 2;
  861.       new[dotsize] = '\0';
  862.       dotlist = new;
  863.     }
  864.  
  865.       dotp -= 3;
  866.  
  867.       /* Figure out if this directory is a mount point.  */
  868.       if (stat (dotp, &st) < 0)
  869.     goto lose;
  870.       dotdev = st.st_dev;
  871.       dotino = st.st_ino;
  872.       mount_point = dotdev != thisdev;
  873.  
  874.       /* Search for the last directory.  */
  875.       dirstream = opendir(dotp);
  876.       if (dirstream == NULL)
  877.     goto lose;
  878.       while ((d = (struct dirent *)readdir(dirstream)) != NULL)
  879.     {
  880.       if (d->d_name[0] == '.' &&
  881.           (d->d_name[1] == '\0' ||
  882.         (d->d_name[1] == '.' && d->d_name[2] == '\0')))
  883.         continue;
  884.       if (mount_point || d->d_fileno == thisino)
  885.         {
  886.           char *name;
  887.  
  888.           namlen = D_NAMLEN(d);
  889.           name = (char *)
  890.         alloca (dotlist + dotsize - dotp + 1 + namlen + 1);
  891.           memcpy (name, dotp, dotlist + dotsize - dotp);
  892.           name[dotlist + dotsize - dotp] = '/';
  893.           memcpy (&name[dotlist + dotsize - dotp + 1],
  894.               d->d_name, namlen + 1);
  895.           if (lstat (name, &st) < 0)
  896.         {
  897.           int save = errno;
  898.           closedir(dirstream);
  899.           errno = save;
  900.           goto lose;
  901.         }
  902.           if (st.st_dev == thisdev && st.st_ino == thisino)
  903.         break;
  904.         }
  905.     }
  906.       if (d == NULL)
  907.     {
  908.       int save = errno;
  909.       closedir(dirstream);
  910.       errno = save;
  911.       goto lose;
  912.     }
  913.       else
  914.     {
  915.       size_t space;
  916.  
  917.       while ((space = pathp - pathbuf) <= namlen)
  918.         {
  919.           char *new;
  920.  
  921.           if (pathbuf == path)
  922.         {
  923.           new = malloc (pathsize * 2);
  924.           if (!new)
  925.             goto lose;
  926.         }
  927.           else
  928.         {
  929.           new = realloc ((PTR) pathbuf, (pathsize * 2));
  930.           if (!new)
  931.             goto lose;
  932.           pathp = new + space;
  933.         }
  934.           (void) memcpy (new + pathsize + space, pathp, pathsize - space);
  935.           pathp = new + pathsize + space;
  936.           pathbuf = new;
  937.           pathsize *= 2;
  938.         }
  939.  
  940.       pathp -= namlen;
  941.       (void) memcpy (pathp, d->d_name, namlen);
  942.       *--pathp = '/';
  943.       closedir(dirstream);
  944.     }
  945.  
  946.       thisdev = dotdev;
  947.       thisino = dotino;
  948.     }
  949.  
  950.   if (pathp == &path[sizeof(path) - 1])
  951.     *--pathp = '/';
  952.  
  953.   if (dotlist != dots)
  954.     free ((PTR) dotlist);
  955.  
  956.   {
  957.     size_t len = pathbuf + pathsize - pathp;
  958.     if (buf == NULL)
  959.       {
  960.     if (len < (size_t) size)
  961.       len = size;
  962.     buf = (char *) malloc (len);
  963.     if (buf == NULL)
  964.       goto lose2;
  965.       }
  966.     else if ((size_t) size < len)
  967.       {
  968.     errno = ERANGE;
  969.     goto lose2;
  970.       }
  971.     (void) memcpy((PTR) buf, (PTR) pathp, len);
  972.   }
  973.  
  974.   if (pathbuf != path)
  975.     free (pathbuf);
  976.  
  977.   return (buf);
  978.  
  979.  lose:
  980.   if ((dotlist != dots) && dotlist)
  981.     {
  982.       int e = errno;
  983.       free ((PTR) dotlist);
  984.       errno = e;
  985.     }
  986.  
  987.  lose2:
  988.   if ((pathbuf != path) && pathbuf)
  989.     {
  990.       int e = errno;
  991.       free ((PTR) pathbuf);
  992.       errno = e;
  993.     }
  994.   return ((char *)NULL);
  995. }
  996. #endif
  997.