sysdeps/posix/getcwd.c

   1 /* Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
   2 This file is part of the GNU C Library.
   3
   4 The GNU C Library is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU Library General Public License as
   6 published by the Free Software Foundation; either version 2 of the
   7 License, or (at your option) any later version.
   8
   9 The GNU C Library is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public
  15 License along with the GNU C Library; see the file COPYING.LIB.  If
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 /* Wants:
  20    AC_STDC_HEADERS
  21    AC_DIR_HEADER
  22    AC_UNISTD_H
  23    AC_MEMORY_H
  24    AC_CONST
  25    AC_ALLOCA
  26  */
  27
  28 /* AIX requires this to be the first thing in the file.  */
  29 #if defined (_AIX) && !defined (__GNUC__)
  30  #pragma alloca
  31 #endif
  32
  33 #ifdef  HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 #include <errno.h>
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40
  41 #ifdef  STDC_HEADERS
  42 #include <stddef.h>
  43 #endif
  44
  45 #if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
  46 extern int errno;
  47 #endif
  48
  49 #ifndef NULL
  50 #define NULL    0
  51 #endif
  52
  53 #if defined (USGr3) && !defined (DIRENT)
  54 #define DIRENT
  55 #endif /* USGr3 */
  56 #if defined (Xenix) && !defined (SYSNDIR)
  57 #define SYSNDIR
  58 #endif /* Xenix */
  59
  60 #if defined (POSIX) || defined (DIRENT) || defined (__GNU_LIBRARY__)
  61 #include <dirent.h>
  62 #ifndef __GNU_LIBRARY__
  63 #define D_NAMLEN(d) strlen((d)->d_name)
  64 #else
  65 #define HAVE_D_NAMLEN
  66 #define D_NAMLEN(d) ((d)->d_namlen)
  67 #endif
  68 #else /* not POSIX or DIRENT */
  69 #define dirent          direct
  70 #define D_NAMLEN(d)     ((d)->d_namlen)
  71 #define HAVE_D_NAMLEN
  72 #if defined (USG) && !defined (sgi)
  73 #if defined (SYSNDIR)
  74 #include <sys/ndir.h>
  75 #else /* Not SYSNDIR */
  76 #include "ndir.h"
  77 #endif /* SYSNDIR */
  78 #else /* not USG */
  79 #include <sys/dir.h>
  80 #endif /* USG */
  81 #endif /* POSIX or DIRENT or __GNU_LIBRARY__ */
  82
  83 #ifdef  HAVE_UNISTD_H
  84 #include <unistd.h>
  85 #endif
  86
  87 #if     (defined (STDC_HEADERS) || defined (__GNU_LIBRARY__) \
  88          || defined (POSIX))
  89 #include <stdlib.h>
  90 #include <string.h>
  91 #define ANSI_STRING
  92 #else   /* No standard headers.  */
  93
  94 #ifdef  USG
  95
  96 #include <string.h>
  97 #ifdef  NEED_MEMORY_H
  98 #include <memory.h>
  99 #endif
 100 #define ANSI_STRING
 101
 102 #else   /* Not USG.  */
 103
 104 #ifdef  NeXT
 105
 106 #include <string.h>
 107
 108 #else   /* Not NeXT.  */
 109
 110 #include <strings.h>
 111
 112 #ifndef bcmp
 113 extern int bcmp ();
 114 #endif
 115 #ifndef bzero
 116 extern void bzero ();
 117 #endif
 118 #ifndef bcopy
 119 extern void bcopy ();
 120 #endif
 121
 122 #endif  /* NeXT. */
 123
 124 #endif  /* USG.  */
 125
 126 extern char *malloc (), *realloc ();
 127 extern void free ();
 128
 129 #endif /* Standard headers.  */
 130
 131 #ifndef ANSI_STRING
 132 #define memcpy(d, s, n) bcopy((s), (d), (n))
 133 #define memmove memcpy
 134 #endif  /* Not ANSI_STRING.  */
 135
 136 #if     !defined(__alloca) && !defined(__GNU_LIBRARY__)
 137
 138 #ifdef  __GNUC__
 139 #undef  alloca
 140 #define alloca(n)       __builtin_alloca (n)
 141 #else   /* Not GCC.  */
 142 #if     defined (sparc) || defined (HAVE_ALLOCA_H)
 143 #include <alloca.h>
 144 #else   /* Not sparc or HAVE_ALLOCA_H.  */
 145 #ifndef _AIX
 146 extern char *alloca ();
 147 #endif  /* Not _AIX.  */
 148 #endif  /* sparc or HAVE_ALLOCA_H.  */
 149 #endif  /* GCC.  */
 150
 151 #define __alloca        alloca
 152
 153 #endif
 154
 155 #if (defined (HAVE_LIMITS_H) || defined (STDC_HEADERS) || \
 156      defined (__GNU_LIBRARY__))
 157 #include <limits.h>
 158 #else
 159 #include <sys/param.h>
 160 #endif
 161
 162 #ifndef PATH_MAX
 163 #ifdef  MAXPATHLEN
 164 #define PATH_MAX MAXPATHLEN
 165 #else
 166 #define PATH_MAX 1024
 167 #endif
 168 #endif
 169
 170 #ifndef STDC_HEADERS
 171 #undef  size_t
 172 #define size_t  unsigned int
 173 #endif
 174
 175 #if !__STDC__ && !defined (const)
 176 #define const
 177 #endif
 178
 179 #ifndef __GNU_LIBRARY__
 180 #define __lstat stat
 181 #endif
 182 \f
 183 /* Get the pathname of the current working directory, and put it in SIZE
 184    bytes of BUF.  Returns NULL if the directory couldn't be determined or
 185    SIZE was too small.  If successful, returns BUF.  In GNU, if BUF is
 186    NULL, an array is allocated with `malloc'; the array is SIZE bytes long,
 187    unless SIZE <= 0, in which case it is as big as necessary.  */
 188
 189 char *
 190 getcwd (buf, size)
 191      char *buf;
 192      size_t size;
 193 {
 194   static const char dots[]
 195     = "../../../../../../../../../../../../../../../../../../../../../../../\
 196 ../../../../../../../../../../../../../../../../../../../../../../../../../../\
 197 ../../../../../../../../../../../../../../../../../../../../../../../../../..";
 198   const char *dotp, *dotlist;
 199   size_t dotsize;
 200   dev_t rootdev, thisdev;
 201   ino_t rootino, thisino;
 202   char *path;
 203   register char *pathp;
 204   struct stat st;
 205
 206   if (size == 0)
 207     {
 208       if (buf != NULL)
 209         {
 210           errno = EINVAL;
 211           return NULL;
 212         }
 213
 214       size = PATH_MAX + 1;
 215     }
 216
 217   if (buf != NULL)
 218     path = buf;
 219   else
 220     {
 221       path = malloc (size);
 222       if (path == NULL)
 223         return NULL;
 224     }
 225
 226   pathp = path + size;
 227   *--pathp = '\0';
 228
 229   if (__lstat (".", &st) < 0)
 230     return NULL;
 231   thisdev = st.st_dev;
 232   thisino = st.st_ino;
 233
 234   if (__lstat ("/", &st) < 0)
 235     return NULL;
 236   rootdev = st.st_dev;
 237   rootino = st.st_ino;
 238
 239   dotsize = sizeof (dots) - 1;
 240   dotp = &dots[sizeof (dots)];
 241   dotlist = dots;
 242   while (!(thisdev == rootdev && thisino == rootino))
 243     {
 244       register DIR *dirstream;
 245       register struct dirent *d;
 246       dev_t dotdev;
 247       ino_t dotino;
 248       char mount_point;
 249
 250       /* Look at the parent directory.  */
 251       if (dotp == dotlist)
 252         {
 253           /* My, what a deep directory tree you have, Grandma.  */
 254           char *new;
 255           if (dotlist == dots)
 256             {
 257               new = malloc (dotsize * 2 + 1);
 258               if (new == NULL)
 259                 return NULL;
 260               memcpy (new, dots, dotsize);
 261             }
 262           else
 263             {
 264               new = realloc ((__ptr_t) dotlist, dotsize * 2 + 1);
 265               if (new == NULL)
 266                 goto lose;
 267             }
 268           memcpy (&new[dotsize], new, dotsize);
 269           dotp = &new[dotsize];
 270           dotsize *= 2;
 271           new[dotsize] = '\0';
 272           dotlist = new;
 273         }
 274
 275       dotp -= 3;
 276
 277       /* Figure out if this directory is a mount point.  */
 278       if (__lstat (dotp, &st) < 0)
 279         goto lose;
 280       dotdev = st.st_dev;
 281       dotino = st.st_ino;
 282       mount_point = dotdev != thisdev;
 283
 284       /* Search for the last directory.  */
 285       dirstream = opendir (dotp);
 286       if (dirstream == NULL)
 287         goto lose;
 288       while ((d = readdir (dirstream)) != NULL)
 289         {
 290           if (d->d_name[0] == '.' &&
 291               (d->d_namlen == 1 || (d->d_namlen == 2 && d->d_name[1] == '.')))
 292             continue;
 293           if (mount_point || d->d_ino == thisino)
 294             {
 295               char *name = __alloca (dotlist + dotsize - dotp +
 296                                      1 + d->d_namlen + 1);
 297               memcpy (name, dotp, dotlist + dotsize - dotp);
 298               name[dotlist + dotsize - dotp] = '/';
 299               memcpy (&name[dotlist + dotsize - dotp + 1],
 300                       d->d_name, d->d_namlen + 1);
 301               if (__lstat (name, &st) < 0)
 302                 {
 303                   int save = errno;
 304                   (void) closedir (dirstream);
 305                   errno = save;
 306                   goto lose;
 307                 }
 308               if (st.st_dev == thisdev && st.st_ino == thisino)
 309                 break;
 310             }
 311         }
 312       if (d == NULL)
 313         {
 314           int save = errno;
 315           (void) closedir (dirstream);
 316           errno = save;
 317           goto lose;
 318         }
 319       else
 320         {
 321           if (pathp - path < d->d_namlen + 1)
 322             {
 323               if (buf != NULL)
 324                 {
 325                   errno = ERANGE;
 326                   return NULL;
 327                 }
 328               else
 329                 {
 330                   size *= 2;
 331                   buf = realloc (path, size);
 332                   if (buf == NULL)
 333                     {
 334                       (void) closedir (dirstream);
 335                       free (path);
 336                       errno = ENOMEM; /* closedir might have changed it.  */
 337                       return NULL;
 338                     }
 339                   pathp = &buf[pathp - path];
 340                   path = buf;
 341                 }
 342             }
 343           pathp -= d->d_namlen;
 344           (void) memcpy (pathp, d->d_name, d->d_namlen);
 345           *--pathp = '/';
 346           (void) closedir (dirstream);
 347         }
 348
 349       thisdev = dotdev;
 350       thisino = dotino;
 351     }
 352
 353   if (pathp == &path[size - 1])
 354     *--pathp = '/';
 355
 356   if (dotlist != dots)
 357     free ((__ptr_t) dotlist);
 358
 359   memmove (path, pathp, path + size - pathp);
 360   return path;
 361
 362  lose:
 363   if (dotlist != dots)
 364     free ((__ptr_t) dotlist);
 365   return NULL;
 366 }