sysdeps/unix/sysv/linux/getcwd.c

   1 /* Determine current working directory.  Linux version.
   2    Copyright (C) 1997, 1998 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Library General Public License as
   8    published by the Free Software Foundation; either version 2 of the
   9    License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Library General Public License for more details.
  15
  16    You should have received a copy of the GNU Library General Public
  17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include <errno.h>
  22 #include <limits.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25
  26 #include <sysdep.h>
  27 #include <sys/syscall.h>
  28
  29
  30 /* The "proc" filesystem provides an easy method to retrieve the value.
  31    For each process, the corresponding directory contains a symbolic link
  32    named `cwd'.  Reading the content of this link immediate gives us the
  33    information.  But we have to take care for systems which do not have
  34    the proc filesystem mounted.  Use the POSIX implementation in this case.  */
  35 static char *generic_getcwd (char *buf, size_t size) internal_function;
  36
  37 #ifdef __NR_getcwd
  38 /* Kernel 2.1.92 introduced a third way to get the current working
  39    directory: a syscall.  We've got to be careful that even when
  40    compiling under 2.1.92+ the libc still runs under older kernels. */
  41 extern int __syscall_getcwd (char *buf, unsigned long size);
  42 static int no_syscall_getcwd;
  43 static int no_new_dcache = 1;
  44 #else
  45 # define no_syscall_getcwd 1
  46 static int no_new_dcache;
  47 #endif
  48
  49 char *
  50 __getcwd (char *buf, size_t size)
  51 {
  52   int save_errno;
  53   char *path;
  54   int n;
  55   char *result;
  56   size_t alloc_size = size;
  57
  58   if (no_syscall_getcwd && no_new_dcache)
  59     return generic_getcwd (buf, size);
  60
  61   if (size == 0)
  62     {
  63       if (buf != NULL)
  64         {
  65           __set_errno (EINVAL);
  66           return NULL;
  67         }
  68
  69       alloc_size = PATH_MAX;
  70     }
  71
  72   if (buf != NULL)
  73     path = buf;
  74   else
  75     {
  76       path = malloc (alloc_size);
  77       if (path == NULL)
  78         return NULL;
  79     }
  80
  81   save_errno = errno;
  82
  83 #ifdef __NR_getcwd
  84   if (!no_syscall_getcwd)
  85     {
  86       int retval;
  87
  88       retval = INLINE_SYSCALL (getcwd, 2, path, alloc_size);
  89       if (retval >= 0)
  90         {
  91           if (buf == NULL)
  92             {
  93               buf = realloc (path, (size_t) retval);
  94               if (buf == NULL)
  95                 /* `realloc' failed but we still have the original string.  */
  96                 buf = path;
  97             }
  98           return buf;
  99         }
 100
 101       if (errno == ENOSYS)
 102         {
 103            no_syscall_getcwd = 1;
 104            no_new_dcache = 0;   /* Now we will try the /proc method.  */
 105         }
 106       else if (errno != ERANGE || buf != NULL)
 107         {
 108           if (buf == NULL)
 109             free (path);
 110           return NULL;
 111         }
 112
 113       __set_errno (save_errno);
 114     }
 115 #endif
 116
 117   n = __readlink ("/proc/self/cwd", path, alloc_size - 1);
 118   if (n != -1)
 119     {
 120       if (path[0] == '/')
 121         {
 122           if (n >= alloc_size - 1)
 123             {
 124               if (buf == NULL)
 125                 free (path);
 126               return NULL;
 127             }
 128
 129           path[n] = '\0';
 130           if (buf == NULL)
 131             {
 132               buf = realloc (path, (size_t) n + 1);
 133               if (buf == NULL)
 134                 /* `relloc' failed but we still have the original string.  */
 135                 buf = path;
 136             }
 137           return buf;
 138         }
 139       else
 140         no_new_dcache = 1;
 141     }
 142
 143   /* Set to no_new_dcache only if error indicates that proc doesn't exist.  */
 144   if (errno != EACCES && errno != ENAMETOOLONG)
 145     no_new_dcache = 1;
 146
 147   /* Something went wrong.  Restore the error number and use the generic
 148      version.  */
 149   __set_errno (save_errno);
 150
 151   /* Don't put restrictions on the length of the path unless the user does.  */
 152   if (size == 0)
 153     {
 154       free (path);
 155       path = NULL;
 156     }
 157
 158   result = generic_getcwd (path, size);
 159
 160   if (result == NULL && buf == NULL && size != 0)
 161     free (path);
 162
 163   return result;
 164 }
 165 weak_alias (__getcwd, getcwd)
 166
 167 /* Get the code for the generic version.  */
 168 #define GETCWD_RETURN_TYPE      static char * internal_function
 169 #define __getcwd                generic_getcwd
 170 #include <sysdeps/posix/getcwd.c>