dmake/unix/sysvr3/pwd/getcwd.c

   1 /*
   2     getcwd -- get pathname of current working directory
   3
   4     public-domain implementation
   5
   6     last edit:  03-Nov-1990     Gwyn@BRL.MIL
   7
   8     complies with the following standards:
   9         IEEE Std 1003.1-1988
  10         SVID Issue 3
  11         X/Open Portability Guide Issue 2 (when "XPG2" is defined)
  12         X/Open Portability Guide Issue 3
  13
  14     This implementation of getcwd() can be used to replace the UNIX
  15     System V library routine (which uses popen() to capture the output of
  16     the "pwd" command).  Once that is done, "pwd" can be reimplemented as
  17     just puts(getcwd((char*)0,0)), assuming "XPG2" is defined below.
  18
  19     This implementation depends on every directory having entries for
  20     "." and "..".  It also depends on the internals of the <dirent.h>
  21     data structures to some degree.
  22
  23     I considered using chdir() to ascend the hierarchy, followed by a
  24     final chdir() to the path being returned by getcwd() to restore the
  25     location, but decided that error recovery was too difficult that way.
  26     The algorithm I settled on was inspired by my rewrite of the "pwd"
  27     utility, combined with the dotdots[] array trick from the SVR2 shell.
  28 */
  29 #define XPG2    /* define to support obsolete XPG2-mandated feature */
  30
  31
  32 #include        <sys/types.h>
  33 #include        <sys/stat.h>
  34
  35 #ifdef M_XENIX
  36 # include        <sys/ndir.h>
  37 # define dirent direct
  38 #else
  39 # include        <dirent.h>
  40 #endif
  41
  42 #include        <errno.h>
  43 #include        <string.h>
  44
  45 typedef char    *pointer;               /* (void *) if you have it */
  46
  47 extern void     free();
  48 extern pointer  malloc();
  49 extern int      fstat(), stat();
  50
  51 extern int      errno;                  /* normally done by <errno.h> */
  52
  53 #ifndef NULL
  54 #define NULL    0                       /* amorphous null pointer constant */
  55 #endif
  56
  57 #ifndef NAME_MAX
  58 #define NAME_MAX        255             /* maximum directory entry size */
  59 #endif
  60
  61
  62 char    *
  63 getcwd( buf, size )                     /* returns pointer to CWD pathname */
  64     char                *buf;           /* where to put name (NULL to malloc) */
  65     int         size;           /* size of buf[] or malloc()ed memory */
  66     {
  67     static char dotdots[] =
  68 "../../../../../../../../../../../../../../../../../../../../../../../../../..";
  69     char                *dotdot;        /* -> dotdots[.], right to left */
  70     DIR         *dirp;          /* -> parent directory stream */
  71     struct dirent       *dir;           /* -> directory entry */
  72     struct stat stat1,
  73             stat2;              /* info from stat() */
  74     struct stat *d = &stat1;    /* -> info about "." */
  75     struct stat *dd = &stat2;   /* -> info about ".." */
  76     register char       *buffer;        /* local copy of buf, or malloc()ed */
  77     char                *bufend;        /* -> buffer[size] */
  78     register char       *endp;          /* -> end of reversed string */
  79     register char       *dname;         /* entry name ("" for root) */
  80     int         serrno = errno; /* save entry errno */
  81
  82     if ( buf != NULL && size <= 0
  83 #ifndef XPG2
  84       || buf == NULL
  85 #endif
  86        )        {
  87         errno = EINVAL;         /* invalid argument */
  88         return NULL;
  89         }
  90
  91     buffer = buf;
  92 #ifdef XPG2
  93     if ( buf == NULL            /* wants us to malloc() the string */
  94       && (buffer = (char *) malloc( (unsigned) size )) == NULL
  95     /* XXX -- actually should probably not pay attention to "size" arg */
  96        )        {
  97         errno = ENOMEM;         /* cannot malloc() specified size */
  98         return NULL;
  99         }
 100 #endif
 101
 102     if ( stat( ".", dd ) != 0 ) /* prime the pump */
 103         goto error;             /* errno already set */
 104
 105     endp = buffer;                      /* initially, empty string */
 106     bufend = &buffer[size];
 107
 108     for ( dotdot = &dotdots[sizeof dotdots]; dotdot != dotdots; )
 109         {
 110         dotdot -= 3;            /* include one more "/.." section */
 111                     /* (first time is actually "..") */
 112
 113         /* swap stat() info buffers */
 114         {
 115         register struct stat    *temp = d;
 116
 117         d = dd;                 /* new current dir is old parent dir */
 118         dd = temp;
 119         }
 120
 121         if ( (dirp = opendir( dotdot )) == NULL )       /* new parent */
 122             goto error; /* errno already set */
 123
 124         if ( fstat( dirp->dd_fd, dd ) != 0 )
 125             {
 126             serrno = errno;     /* set by fstat() */
 127             (void)closedir( dirp );
 128             errno = serrno;     /* in case closedir() clobbered it */
 129             goto error;
 130             }
 131
 132         if ( d->st_dev == dd->st_dev )
 133             {           /* not crossing a mount point */
 134             if ( d->st_ino == dd->st_ino )
 135                 {       /* root directory */
 136                 dname = "";
 137                 goto append;
 138                 }
 139
 140             do
 141                 if ( (dir = readdir( dirp )) == NULL )
 142                     {
 143                     (void)closedir( dirp );
 144                     errno = ENOENT;     /* missing entry */
 145                     goto error;
 146                     }
 147             while ( dir->d_ino != d->st_ino );
 148             }
 149         else    {               /* crossing a mount point */
 150             struct stat t;      /* info re. test entry */
 151             char                name[sizeof dotdots + 1 + NAME_MAX];
 152
 153             (void)strcpy( name, dotdot );
 154             dname = &name[strlen( name )];
 155             *dname++ = '/';
 156
 157             do  {
 158                 if ( (dir = readdir( dirp )) == NULL )
 159                     {
 160                     (void)closedir( dirp );
 161                     errno = ENOENT;     /* missing entry */
 162                     goto error;
 163                     }
 164
 165                 (void)strcpy( dname, dir->d_name );
 166                 /* must fit if NAME_MAX is not a lie */
 167                 }
 168             while ( stat( name, &t ) != 0
 169                  || t.st_ino != d->st_ino
 170                  || t.st_dev != d->st_dev
 171                   );
 172             }
 173
 174         dname = dir->d_name;
 175
 176         /* append "/" and reversed dname string onto buffer */
 177     append:
 178         if ( endp != buffer     /* avoid trailing / in final name */
 179           || dname[0] == '\0'   /* but allow "/" when CWD is root */
 180            )
 181             *endp++ = '/';
 182
 183         {
 184         register char   *app;   /* traverses dname string */
 185
 186         for ( app = dname; *app != '\0'; ++app )
 187             ;
 188
 189         if ( app - dname >= bufend - endp )
 190             {
 191             (void)closedir( dirp );
 192             errno = ERANGE;     /* won't fit allotted space */
 193             goto error;
 194             }
 195
 196         while ( app != dname )
 197             *endp++ = *--app;
 198         }
 199
 200         (void)closedir( dirp );
 201
 202         if ( dname[0] == '\0' ) /* reached root; wrap it up */
 203             {
 204             register char       *startp;        /* -> buffer[.] */
 205
 206             *endp = '\0';       /* plant null terminator */
 207
 208             /* straighten out reversed pathname string */
 209             for ( startp = buffer; --endp > startp; ++startp )
 210                 {
 211                 char    temp = *endp;
 212
 213                 *endp = *startp;
 214                 *startp = temp;
 215                 }
 216
 217             errno = serrno;     /* restore entry errno */
 218             /* XXX -- if buf==NULL, realloc here? */
 219             return buffer;
 220             }
 221         }
 222
 223     errno = ENOMEM;                     /* actually, algorithm failure */
 224
 225     error:
 226     if ( buf == NULL )
 227         free( (pointer)buffer );
 228
 229     return NULL;
 230     }
 231