usr/src/lib/libast/common/misc/getcwd.c

   1 /***********************************************************************
   2 *                                                                      *
   3 *               This software is part of the ast package               *
   4 *          Copyright (c) 1985-2010 AT&T Intellectual Property          *
   5 *                      and is licensed under the                       *
   6 *                  Common Public License, Version 1.0                  *
   7 *                    by AT&T Intellectual Property                     *
   8 *                                                                      *
   9 *                A copy of the License is available at                 *
  10 *            http://www.opensource.org/licenses/cpl1.0.txt             *
  11 *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
  12 *                                                                      *
  13 *              Information and Software Systems Research               *
  14 *                            AT&T Research                             *
  15 *                           Florham Park NJ                            *
  16 *                                                                      *
  17 *                 Glenn Fowler <gsf@research.att.com>                  *
  18 *                  David Korn <dgk@research.att.com>                   *
  19 *                   Phong Vo <kpv@research.att.com>                    *
  20 *                                                                      *
  21 ***********************************************************************/
  22 #pragma prototyped
  23 /*
  24  * Glenn Fowler
  25  * AT&T Research
  26  *
  27  * pwd library support
  28  */
  29
  30 #include <ast.h>
  31
  32 #if _WINIX
  33
  34 NoN(getcwd)
  35
  36 #else
  37
  38 #include <ast_dir.h>
  39 #include <error.h>
  40 #include <fs3d.h>
  41
  42 #ifndef ERANGE
  43 #define ERANGE          E2BIG
  44 #endif
  45
  46 #define ERROR(e)        { errno = e; goto error; }
  47
  48 struct dirlist                          /* long path chdir(2) component */
  49 {
  50         struct dirlist* next;           /* next component               */
  51         int             index;          /* index from end of buf        */
  52 };
  53
  54 /*
  55  * pop long dir component chdir stack
  56  */
  57
  58 static int
  59 popdir(register struct dirlist* d, register char* end)
  60 {
  61         register struct dirlist*        dp;
  62         int                             v;
  63
  64         v = 0;
  65         while (dp = d)
  66         {
  67                 d = d->next;
  68                 if (!v)
  69                 {
  70                         if (d) *(end - d->index - 1) = 0;
  71                         v = chdir(end - dp->index);
  72                         if (d) *(end - d->index - 1) = '/';
  73                 }
  74                 free(dp);
  75         }
  76         return v;
  77 }
  78
  79 /*
  80  * push long dir component onto stack
  81  */
  82
  83 static struct dirlist*
  84 pushdir(register struct dirlist* d, char* dots, char* path, char* end)
  85 {
  86         register struct dirlist*        p;
  87
  88         if (!(p = newof(0, struct dirlist, 1, 0)) || chdir(dots))
  89         {
  90                 if (p) free(p);
  91                 if (d) popdir(d, end);
  92                 return 0;
  93         }
  94         p->index = end - path;
  95         p->next = d;
  96         return p;
  97 }
  98
  99 /*
 100  * return a pointer to the absolute path name of .
 101  * this path name may be longer than PATH_MAX
 102  *
 103  * a few environment variables are checked before the search algorithm
 104  * return value is placed in buf of len chars
 105  * if buf is 0 then space is allocated via malloc() with
 106  * len extra chars after the path name
 107  * 0 is returned on error with errno set as appropriate
 108  */
 109
 110 char*
 111 getcwd(char* buf, size_t len)
 112 {
 113         register char*  d;
 114         register char*  p;
 115         register char*  s;
 116         DIR*            dirp = 0;
 117         int             n;
 118         int             x;
 119         size_t          namlen;
 120         ssize_t         extra = -1;
 121         struct dirent*  entry;
 122         struct dirlist* dirstk = 0;
 123         struct stat*    cur;
 124         struct stat*    par;
 125         struct stat*    tmp;
 126         struct stat     curst;
 127         struct stat     parst;
 128         struct stat     tstst;
 129         char            dots[PATH_MAX];
 130
 131         static struct
 132         {
 133                 char*   name;
 134                 char*   path;
 135                 dev_t   dev;
 136                 ino_t   ino;
 137         }               env[] =
 138         {
 139                 { /*previous*/0 },
 140                 { "PWD"         },
 141                 { "HOME"        },
 142         };
 143
 144         if (buf && !len) ERROR(EINVAL);
 145         if (fs3d(FS3D_TEST) && (namlen = mount(".", dots, FS3D_GET|FS3D_VIEW|FS3D_SIZE(sizeof(dots)), NiL)) > 1 && namlen < sizeof(dots))
 146         {
 147                 p = dots;
 148         easy:
 149                 namlen++;
 150                 if (buf)
 151                 {
 152                         if (len < namlen) ERROR(ERANGE);
 153                 }
 154                 else if (!(buf = newof(0, char, namlen, len))) ERROR(ENOMEM);
 155                 return (char*)memcpy(buf, p, namlen);
 156         }
 157         cur = &curst;
 158         par = &parst;
 159         if (stat(".", par)) ERROR(errno);
 160         for (n = 0; n < elementsof(env); n++)
 161         {
 162                 if ((env[n].name && (p = getenv(env[n].name)) || (p = env[n].path)) && *p == '/' && !stat(p, cur))
 163                 {
 164                         env[n].path = p;
 165                         env[n].dev = cur->st_dev;
 166                         env[n].ino = cur->st_ino;
 167                         if (cur->st_ino == par->st_ino && cur->st_dev == par->st_dev)
 168                         {
 169                                 namlen = strlen(p);
 170                                 goto easy;
 171                         }
 172                 }
 173         }
 174         if (!buf)
 175         {
 176                 extra = len;
 177                 len = PATH_MAX;
 178                 if (!(buf = newof(0, char, len, extra))) ERROR(ENOMEM);
 179         }
 180         d = dots;
 181         p = buf + len - 1;
 182         *p = 0;
 183         n = elementsof(env);
 184         for (;;)
 185         {
 186                 tmp = cur;
 187                 cur = par;
 188                 par = tmp;
 189                 if ((d - dots) > (PATH_MAX - 4))
 190                 {
 191                         if (!(dirstk = pushdir(dirstk, dots, p, buf + len - 1))) ERROR(ERANGE);
 192                         d = dots;
 193                 }
 194                 *d++ = '.';
 195                 *d++ = '.';
 196                 *d = 0;
 197                 if (!(dirp = opendir(dots))) ERROR(errno);
 198 #if !_dir_ok || _mem_dd_fd_DIR
 199                 if (fstat(dirp->dd_fd, par)) ERROR(errno);
 200 #else
 201                 if (stat(dots, par)) ERROR(errno);
 202 #endif
 203                 *d++ = '/';
 204                 if (par->st_dev == cur->st_dev)
 205                 {
 206                         if (par->st_ino == cur->st_ino)
 207                         {
 208                                 closedir(dirp);
 209                                 *--p = '/';
 210                         pop:
 211                                 if (p != buf)
 212                                 {
 213                                         d = buf;
 214                                         while (*d++ = *p++);
 215                                         len = d - buf;
 216                                         if (extra >= 0 && !(buf = newof(buf, char, len, extra))) ERROR(ENOMEM);
 217                                 }
 218                                 if (dirstk && popdir(dirstk, buf + len - 1))
 219                                 {
 220                                         dirstk = 0;
 221                                         ERROR(errno);
 222                                 }
 223                                 if (env[0].path)
 224                                         free(env[0].path);
 225                                 env[0].path = strdup(buf);
 226                                 return buf;
 227                         }
 228 #ifdef D_FILENO
 229                         while (entry = readdir(dirp))
 230                                 if (D_FILENO(entry) == cur->st_ino)
 231                                 {
 232                                         namlen = D_NAMLEN(entry);
 233                                         goto found;
 234                                 }
 235 #endif
 236
 237                         /*
 238                          * this fallthrough handles logical naming
 239                          */
 240
 241                         rewinddir(dirp);
 242                 }
 243                 do
 244                 {
 245                         if (!(entry = readdir(dirp))) ERROR(ENOENT);
 246                         namlen = D_NAMLEN(entry);
 247                         if ((d - dots) > (PATH_MAX - 1 - namlen))
 248                         {
 249                                 *d = 0;
 250                                 if (namlen >= PATH_MAX || !(dirstk = pushdir(dirstk, dots + 3, p, buf + len - 1))) ERROR(ERANGE);
 251                                 d = dots + 3;
 252                         }
 253                         memcpy(d, entry->d_name, namlen + 1);
 254                 } while (stat(dots, &tstst) || tstst.st_ino != cur->st_ino || tstst.st_dev != cur->st_dev);
 255         found:
 256                 if (*p) *--p = '/';
 257                 while ((p -= namlen) <= (buf + 1))
 258                 {
 259                         x = (buf + len - 1) - (p += namlen);
 260                         s = buf + len;
 261                         if (extra < 0 || !(buf = newof(buf, char, len += PATH_MAX, extra))) ERROR(ERANGE);
 262                         p = buf + len;
 263                         while (p > buf + len - 1 - x) *--p = *--s;
 264                 }
 265                 if (n < elementsof(env))
 266                 {
 267                         memcpy(p, env[n].path, namlen);
 268                         goto pop;
 269                 }
 270                 memcpy(p, entry->d_name, namlen);
 271                 closedir(dirp);
 272                 dirp = 0;
 273                 for (n = 0; n < elementsof(env); n++)
 274                         if (env[n].ino == par->st_ino && env[n].dev == par->st_dev)
 275                         {
 276                                 namlen = strlen(env[n].path);
 277                                 goto found;
 278                         }
 279         }
 280  error:
 281         if (buf)
 282         {
 283                 if (dirstk) popdir(dirstk, buf + len - 1);
 284                 if (extra >= 0) free(buf);
 285         }
 286         if (dirp) closedir(dirp);
 287         return 0;
 288 }
 289
 290 #endif