Makefile: Added UNIXWARE 2.x with shadow passwords from fja@extratech.com
[kai/samba.git] / source3 / smbd / dir.c
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(-1);
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