[thirdparty/glibc.git] / sysdeps / posix / getcwd.c

/* Copyright (C) 1991-2017 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

/* Wants:
   AC_STDC_HEADERS
   AC_DIR_HEADER
   AC_UNISTD_H
   AC_MEMORY_H
   AC_CONST
   AC_ALLOCA
 */

/* AIX requires this to be the first thing in the file.  */
#if defined _AIX && !defined __GNUC__
 #pragma alloca
#endif

#ifdef	HAVE_CONFIG_H
# include "config.h"
#endif

#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>

#ifdef	STDC_HEADERS
# include <stddef.h>
#endif

#if !defined __GNU_LIBRARY__ && !defined STDC_HEADERS
extern int errno;
#endif
#ifndef __set_errno
# define __set_errno(val) errno = (val)
#endif

#ifndef	NULL
# define NULL	0
#endif

#if defined USGr3 && !defined DIRENT
# define DIRENT
#endif /* USGr3 */
#if defined Xenix && !defined SYSNDIR
# define SYSNDIR
#endif /* Xenix */

#if defined POSIX || defined DIRENT || defined __GNU_LIBRARY__
# include <dirent.h>
# ifndef __GNU_LIBRARY__
#  define D_NAMLEN(d) strlen((d)->d_name)
# else
#  define HAVE_D_NAMLEN
#  define D_NAMLEN(d) ((d)->d_namlen)
# endif
#else /* not POSIX or DIRENT */
# define dirent		direct
# define D_NAMLEN(d)	((d)->d_namlen)
# define HAVE_D_NAMLEN
# if defined USG && !defined sgi
#  if defined SYSNDIR
#   include <sys/ndir.h>
#  else /* Not SYSNDIR */
#   include "ndir.h"
#  endif /* SYSNDIR */
# else /* not USG */
#  include <sys/dir.h>
# endif /* USG */
#endif /* POSIX or DIRENT or __GNU_LIBRARY__ */

#if defined HAVE_UNISTD_H || defined __GNU_LIBRARY__
# include <unistd.h>
#endif

#if defined STDC_HEADERS || defined __GNU_LIBRARY__ || defined POSIX
# include <stdlib.h>
# include <string.h>
# define ANSI_STRING
#else	/* No standard headers.  */

# ifdef	USG

#  include <string.h>
#  ifdef NEED_MEMORY_H
#   include <memory.h>
#  endif
#  define	ANSI_STRING

# else	/* Not USG.  */

#  ifdef NeXT

#   include <string.h>

#  else	/* Not NeXT.  */

#   include <strings.h>

#   ifndef bcmp
extern int bcmp ();
#   endif
#   ifndef bzero
extern void bzero ();
#   endif
#   ifndef bcopy
extern void bcopy ();
#   endif

#  endif /* NeXT. */

# endif	/* USG.  */

extern char *malloc (), *realloc ();
extern void free ();

#endif /* Standard headers.  */

#ifndef	ANSI_STRING
# define memcpy(d, s, n)	bcopy((s), (d), (n))
# define memmove memcpy
#endif	/* Not ANSI_STRING.  */

#ifndef MAX
# define MAX(a, b) ((a) < (b) ? (b) : (a))
#endif

#ifdef _LIBC
# ifndef mempcpy
#  define mempcpy __mempcpy
# endif
# define HAVE_MEMPCPY	1
#endif

#if !defined __alloca && !defined __GNU_LIBRARY__

# ifdef	__GNUC__
#  undef alloca
#  define alloca(n)	__builtin_alloca (n)
# else	/* Not GCC.  */
#  if	defined sparc || defined HAVE_ALLOCA_H
#   include <alloca.h>
#  else	/* Not sparc or HAVE_ALLOCA_H.  */
#   ifndef _AIX
extern char *alloca ();
#   endif /* Not _AIX.  */
#  endif /* sparc or HAVE_ALLOCA_H.  */
# endif	/* GCC.  */

# define __alloca	alloca

#endif

#if defined HAVE_LIMITS_H || defined STDC_HEADERS || defined __GNU_LIBRARY__
# include <limits.h>
#else
# include <sys/param.h>
#endif

#if defined _LIBC
# include <not-cancel.h>
# include <kernel-features.h>
#else
# define openat64_not_cancel_3(dfd, name, mode) openat64 (dfd, name, mode)
# define close_not_cancel_no_status(fd) close (fd)
#endif

#ifndef PATH_MAX
# ifdef	MAXPATHLEN
#  define PATH_MAX MAXPATHLEN
# else
#  define PATH_MAX 1024
# endif
#endif

#if !defined STDC_HEADERS && !defined __GNU_LIBRARY__
# undef	size_t
# define size_t	unsigned int
#endif

#ifndef __GNU_LIBRARY__
# define __lstat64	stat64
#endif

#ifndef _LIBC
# define __rewinddir	rewinddir
#endif
\f
#ifndef _LIBC
# define __getcwd getcwd
#endif

#ifndef GETCWD_RETURN_TYPE
# define GETCWD_RETURN_TYPE char *
#endif

#ifdef __ASSUME_ATFCTS
# define __have_atfcts 1
#elif IS_IN (rtld)
static int __rtld_have_atfcts;
# define __have_atfcts __rtld_have_atfcts
#endif

/* Get the pathname of the current working directory, and put it in SIZE
   bytes of BUF.  Returns NULL if the directory couldn't be determined or
   SIZE was too small.  If successful, returns BUF.  In GNU, if BUF is
   NULL, an array is allocated with `malloc'; the array is SIZE bytes long,
   unless SIZE == 0, in which case it is as big as necessary.  */

GETCWD_RETURN_TYPE
__getcwd (char *buf, size_t size)
{
#ifndef __ASSUME_ATFCTS
  static const char dots[]
    = "../../../../../../../../../../../../../../../../../../../../../../../\
../../../../../../../../../../../../../../../../../../../../../../../../../../\
../../../../../../../../../../../../../../../../../../../../../../../../../..";
  const char *dotp = &dots[sizeof (dots)];
  const char *dotlist = dots;
  size_t dotsize = sizeof (dots) - 1;
#endif
  int prev_errno = errno;
  DIR *dirstream = NULL;
  bool fd_needs_closing = false;
  int fd = AT_FDCWD;

  char *path;
#ifndef NO_ALLOCATION
  size_t allocated = size;
  if (size == 0)
    {
      if (buf != NULL)
	{
	  __set_errno (EINVAL);
	  return NULL;
	}

      allocated = PATH_MAX + 1;
    }

  if (buf == NULL)
    {
      path = malloc (allocated);
      if (path == NULL)
	return NULL;
    }
  else
#else
# define allocated size
#endif
    path = buf;

  char *pathp = path + allocated;
  *--pathp = '\0';

  struct stat64 st;
  if (__lstat64 (".", &st) < 0)
    goto lose;
  dev_t thisdev = st.st_dev;
  ino_t thisino = st.st_ino;

  if (__lstat64 ("/", &st) < 0)
    goto lose;
  dev_t rootdev = st.st_dev;
  ino_t rootino = st.st_ino;

  while (!(thisdev == rootdev && thisino == rootino))
    {
      if (__have_atfcts >= 0)
	  fd = openat64_not_cancel_3 (fd, "..", O_RDONLY | O_CLOEXEC);
      else
	fd = -1;
      if (fd >= 0)
	{
	  fd_needs_closing = true;
	  if (__fstat64 (fd, &st) < 0)
	    goto lose;
	}
#ifndef __ASSUME_ATFCTS
      else if (errno == ENOSYS)
	{
	  __have_atfcts = -1;

	  /* Look at the parent directory.  */
	  if (dotp == dotlist)
	    {
# ifdef NO_ALLOCATION
	      __set_errno (ENOMEM);
	      goto lose;
# else
	      /* My, what a deep directory tree you have, Grandma.  */
	      char *new;
	      if (dotlist == dots)
		{
		  new = malloc (dotsize * 2 + 1);
		  if (new == NULL)
		    goto lose;
#  ifdef HAVE_MEMPCPY
		  dotp = mempcpy (new, dots, dotsize);
#  else
		  memcpy (new, dots, dotsize);
		  dotp = &new[dotsize];
#  endif
		}
	      else
		{
		  new = realloc ((void *) dotlist, dotsize * 2 + 1);
		  if (new == NULL)
		    goto lose;
		  dotp = &new[dotsize];
		}
#  ifdef HAVE_MEMPCPY
	      *((char *) mempcpy ((char *) dotp, new, dotsize)) = '\0';
	      dotsize *= 2;
#  else
	      memcpy ((char *) dotp, new, dotsize);
	      dotsize *= 2;
	      new[dotsize] = '\0';
#  endif
	      dotlist = new;
# endif
	    }

	  dotp -= 3;

	  /* Figure out if this directory is a mount point.  */
	  if (__lstat64 (dotp, &st) < 0)
	    goto lose;
	}
#endif
      else
	goto lose;

      if (dirstream && __closedir (dirstream) != 0)
	{
	  dirstream = NULL;
	  goto lose;
       }

      dev_t dotdev = st.st_dev;
      ino_t dotino = st.st_ino;
      bool mount_point = dotdev != thisdev;

      /* Search for the last directory.  */
      if (__have_atfcts >= 0)
	dirstream = __fdopendir (fd);
#ifndef __ASSUME_ATFCTS
      else
	dirstream = __opendir (dotp);
#endif
      if (dirstream == NULL)
	goto lose;
      fd_needs_closing = false;

      struct dirent *d;
      bool use_d_ino = true;
      while (1)
	{
	  /* Clear errno to distinguish EOF from error if readdir returns
	     NULL.  */
	  __set_errno (0);
	  d = __readdir (dirstream);
	  if (d == NULL)
	    {
	      if (errno == 0)
		{
		  /* When we've iterated through all directory entries
		     without finding one with a matching d_ino, rewind the
		     stream and consider each name again, but this time, using
		     lstat64.  This is necessary in a chroot on at least one
		     system.  */
		  if (use_d_ino)
		    {
		      use_d_ino = false;
		      __rewinddir (dirstream);
		      continue;
		    }

		  /* EOF on dirstream, which means that the current directory
		     has been removed.  */
		  __set_errno (ENOENT);
		}
	      goto lose;
	    }

#ifdef _DIRENT_HAVE_D_TYPE
	  if (d->d_type != DT_DIR && d->d_type != DT_UNKNOWN)
	    continue;
#endif
	  if (d->d_name[0] == '.'
	      && (d->d_name[1] == '\0'
		  || (d->d_name[1] == '.' && d->d_name[2] == '\0')))
	    continue;
	  if (use_d_ino && !mount_point && (ino_t) d->d_ino != thisino)
	    continue;

	  if (__have_atfcts >= 0)
	    {
	      /* We don't fail here if we cannot stat64() a directory entry.
		 This can happen when (network) filesystems fail.  If this
		 entry is in fact the one we are looking for we will find
		 out soon as we reach the end of the directory without
		 having found anything.  */
	      if (__fstatat64 (fd, d->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
		continue;
	    }
#ifndef __ASSUME_ATFCTS
	  else
	    {
	      char name[dotlist + dotsize - dotp + 1 + _D_ALLOC_NAMLEN (d)];
# ifdef HAVE_MEMPCPY
	      char *tmp = mempcpy (name, dotp, dotlist + dotsize - dotp);
	      *tmp++ = '/';
	      strcpy (tmp, d->d_name);
# else
	      memcpy (name, dotp, dotlist + dotsize - dotp);
	      name[dotlist + dotsize - dotp] = '/';
	      strcpy (&name[dotlist + dotsize - dotp + 1], d->d_name);
# endif
	      /* We don't fail here if we cannot stat64() a directory entry.
		 This can happen when (network) filesystems fail.  If this
		 entry is in fact the one we are looking for we will find
		 out soon as we reach the end of the directory without
		 having found anything.  */
	      if (__lstat64 (name, &st) < 0)
		continue;
	    }
#endif
	  if (S_ISDIR (st.st_mode)
	      && st.st_dev == thisdev && st.st_ino == thisino)
	    break;
	}

      size_t namlen = _D_EXACT_NAMLEN (d);

      if ((size_t) (pathp - path) <= namlen)
	{
#ifndef NO_ALLOCATION
	  if (size == 0)
	    {
	      size_t oldsize = allocated;

	      allocated = 2 * MAX (allocated, namlen);
	      char *tmp = realloc (path, allocated);
	      if (tmp == NULL)
		goto lose;

	      /* Move current contents up to the end of the buffer.
		 This is guaranteed to be non-overlapping.  */
	      pathp = memcpy (tmp + allocated - (path + oldsize - pathp),
			      tmp + (pathp - path),
			      path + oldsize - pathp);
	      path = tmp;
	    }
	  else
#endif
	    {
	      __set_errno (ERANGE);
	      goto lose;
	    }
	}
      pathp -= namlen;
      (void) memcpy (pathp, d->d_name, namlen);
      *--pathp = '/';

      thisdev = dotdev;
      thisino = dotino;
    }

  if (dirstream != NULL && __closedir (dirstream) != 0)
    {
      dirstream = NULL;
      goto lose;
    }

  if (pathp == &path[allocated - 1])
    *--pathp = '/';

#ifndef __ASSUME_ATFCTS
  if (dotlist != dots)
    free ((void *) dotlist);
#endif

  size_t used = path + allocated - pathp;
  memmove (path, pathp, used);

  if (size == 0)
    /* Ensure that the buffer is only as large as necessary.  */
    buf = realloc (path, used);

  if (buf == NULL)
    /* Either buf was NULL all along, or `realloc' failed but
       we still have the original string.  */
    buf = path;

  /* Restore errno on successful return.  */
  __set_errno (prev_errno);

  return buf;

 lose:;
  int save_errno = errno;
#ifndef __ASSUME_ATFCTS
  if (dotlist != dots)
    free ((void *) dotlist);
#endif
  if (dirstream != NULL)
    __closedir (dirstream);
  if (fd_needs_closing)
    close_not_cancel_no_status (fd);
#ifndef NO_ALLOCATION
  if (buf == NULL)
    free (path);
#endif
  __set_errno (save_errno);
  return NULL;
}

#if defined _LIBC && !defined __getcwd
weak_alias (__getcwd, getcwd)
#endif
Commit	Line	Data
bfff8b1b	1	/* Copyright (C) 1991-2017 Free Software Foundation, Inc.
47707456	2	This file is part of the GNU C Library.
28f540f4	3
47707456	4	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	5	modify it under the terms of the GNU Lesser General Public
	6	License as published by the Free Software Foundation; either
	7	version 2.1 of the License, or (at your option) any later version.
28f540f4	8
47707456 UD	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
41bdb6e2	12	Lesser General Public License for more details.
28f540f4	13
41bdb6e2	14	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	15	License along with the GNU C Library; if not, see
59ba27a6 PE	16	<http://www.gnu.org/licenses/>. */
28f540f4 RM	17
	18	/* Wants:
	19	AC_STDC_HEADERS
	20	AC_DIR_HEADER
	21	AC_UNISTD_H
	22	AC_MEMORY_H
	23	AC_CONST
	24	AC_ALLOCA
	25	*/
	26
	27	/* AIX requires this to be the first thing in the file. */
86187531	28	#if defined _AIX && !defined __GNUC__
28f540f4 RM	29	#pragma alloca
	30	#endif
	31
	32	#ifdef HAVE_CONFIG_H
86187531	33	# include "config.h"
28f540f4 RM	34	#endif
	35
	36	#include <errno.h>
7fb90fb8	37	#include <fcntl.h>
28f540f4 RM	38	#include <sys/types.h>
	39	#include <sys/stat.h>
	40
	41	#ifdef STDC_HEADERS
86187531	42	# include <stddef.h>
28f540f4 RM	43	#endif
28f540f4 RM	44
86187531	45	#if !defined __GNU_LIBRARY__ && !defined STDC_HEADERS
28f540f4 RM	46	extern int errno;
28f540f4 RM	47	#endif
c4029823	48	#ifndef __set_errno
86187531	49	# define __set_errno(val) errno = (val)
c4029823	50	#endif
28f540f4 RM	51
28f540f4 RM	52	#ifndef NULL
86187531	53	# define NULL 0
28f540f4 RM	54	#endif
28f540f4 RM	55
86187531 UD	56	#if defined USGr3 && !defined DIRENT
86187531 UD	57	# define DIRENT
28f540f4	58	#endif /* USGr3 */
86187531 UD	59	#if defined Xenix && !defined SYSNDIR
86187531 UD	60	# define SYSNDIR
28f540f4 RM	61	#endif /* Xenix */
28f540f4 RM	62
86187531 UD	63	#if defined POSIX \|\| defined DIRENT \|\| defined __GNU_LIBRARY__
	64	# include <dirent.h>
	65	# ifndef __GNU_LIBRARY__
	66	# define D_NAMLEN(d) strlen((d)->d_name)
	67	# else
	68	# define HAVE_D_NAMLEN
	69	# define D_NAMLEN(d) ((d)->d_namlen)
	70	# endif
28f540f4	71	#else /* not POSIX or DIRENT */
86187531 UD	72	# define dirent direct
	73	# define D_NAMLEN(d) ((d)->d_namlen)
	74	# define HAVE_D_NAMLEN
	75	# if defined USG && !defined sgi
	76	# if defined SYSNDIR
	77	# include <sys/ndir.h>
	78	# else /* Not SYSNDIR */
	79	# include "ndir.h"
	80	# endif /* SYSNDIR */
	81	# else /* not USG */
	82	# include <sys/dir.h>
	83	# endif /* USG */
28f540f4 RM	84	#endif /* POSIX or DIRENT or __GNU_LIBRARY__ */
28f540f4 RM	85
86187531 UD	86	#if defined HAVE_UNISTD_H \|\| defined __GNU_LIBRARY__
86187531 UD	87	# include <unistd.h>
28f540f4 RM	88	#endif
28f540f4 RM	89
86187531 UD	90	#if defined STDC_HEADERS \|\| defined __GNU_LIBRARY__ \|\| defined POSIX
	91	# include <stdlib.h>
	92	# include <string.h>
	93	# define ANSI_STRING
28f540f4 RM	94	#else /* No standard headers. */
28f540f4 RM	95
86187531	96	# ifdef USG
28f540f4	97
86187531 UD	98	# include <string.h>
	99	# ifdef NEED_MEMORY_H
	100	# include <memory.h>
	101	# endif
	102	# define ANSI_STRING
28f540f4	103
86187531	104	# else /* Not USG. */
28f540f4	105
86187531	106	# ifdef NeXT
28f540f4	107
86187531	108	# include <string.h>
28f540f4	109
86187531	110	# else /* Not NeXT. */
28f540f4	111
86187531	112	# include <strings.h>
28f540f4	113
86187531	114	# ifndef bcmp
28f540f4	115	extern int bcmp ();
86187531 UD	116	# endif
86187531 UD	117	# ifndef bzero
28f540f4	118	extern void bzero ();
86187531 UD	119	# endif
86187531 UD	120	# ifndef bcopy
28f540f4	121	extern void bcopy ();
86187531	122	# endif
28f540f4	123
86187531	124	# endif /* NeXT. */
28f540f4	125
86187531	126	# endif /* USG. */
28f540f4 RM	127
	128	extern char malloc (), realloc ();
	129	extern void free ();
	130
	131	#endif /* Standard headers. */
	132
	133	#ifndef ANSI_STRING
86187531 UD	134	# define memcpy(d, s, n) bcopy((s), (d), (n))
86187531 UD	135	# define memmove memcpy
28f540f4 RM	136	#endif /* Not ANSI_STRING. */
28f540f4 RM	137
c9cddf51 UD	138	#ifndef MAX
	139	# define MAX(a, b) ((a) < (b) ? (b) : (a))
	140	#endif
	141
cc3fa755	142	#ifdef _LIBC
50a1b837 UD	143	# ifndef mempcpy
	144	# define mempcpy __mempcpy
	145	# endif
cc3fa755 UD	146	# define HAVE_MEMPCPY 1
	147	#endif
	148
86187531	149	#if !defined __alloca && !defined __GNU_LIBRARY__
28f540f4	150
86187531 UD	151	# ifdef __GNUC__
	152	# undef alloca
	153	# define alloca(n) __builtin_alloca (n)
	154	# else /* Not GCC. */
	155	# if defined sparc \|\| defined HAVE_ALLOCA_H
	156	# include <alloca.h>
	157	# else /* Not sparc or HAVE_ALLOCA_H. */
	158	# ifndef _AIX
28f540f4	159	extern char *alloca ();
86187531 UD	160	# endif /* Not _AIX. */
	161	# endif /* sparc or HAVE_ALLOCA_H. */
	162	# endif /* GCC. */
28f540f4	163
86187531	164	# define __alloca alloca
28f540f4 RM	165
	166	#endif
	167
86187531 UD	168	#if defined HAVE_LIMITS_H \|\| defined STDC_HEADERS \|\| defined __GNU_LIBRARY__
86187531 UD	169	# include <limits.h>
28f540f4	170	#else
86187531	171	# include <sys/param.h>
28f540f4 RM	172	#endif
28f540f4 RM	173
6fb2dde3	174	#if defined _LIBC
7fb90fb8	175	# include <not-cancel.h>
37233df9	176	# include <kernel-features.h>
7fb90fb8	177	#else
6fb2dde3	178	# define openat64_not_cancel_3(dfd, name, mode) openat64 (dfd, name, mode)
7fb90fb8 UD	179	# define close_not_cancel_no_status(fd) close (fd)
	180	#endif
	181
28f540f4	182	#ifndef PATH_MAX
86187531 UD	183	# ifdef MAXPATHLEN
	184	# define PATH_MAX MAXPATHLEN
	185	# else
	186	# define PATH_MAX 1024
	187	# endif
28f540f4 RM	188	#endif
28f540f4 RM	189
86187531 UD	190	#if !defined STDC_HEADERS && !defined __GNU_LIBRARY__
	191	# undef size_t
	192	# define size_t unsigned int
28f540f4 RM	193	#endif
28f540f4 RM	194
28f540f4	195	#ifndef __GNU_LIBRARY__
6fb2dde3	196	# define __lstat64 stat64
28f540f4	197	#endif
2f5c1b00 JM	198
	199	#ifndef _LIBC
	200	# define __rewinddir rewinddir
	201	#endif
28f540f4	202	\f
7f811679	203	#ifndef _LIBC
86187531	204	# define __getcwd getcwd
7f811679 RM	205	#endif
7f811679 RM	206
04be94a8 UD	207	#ifndef GETCWD_RETURN_TYPE
04be94a8 UD	208	# define GETCWD_RETURN_TYPE char *
fe0ec73e UD	209	#endif
fe0ec73e UD	210
7fb90fb8	211	#ifdef __ASSUME_ATFCTS
6fb2dde3	212	# define __have_atfcts 1
a3848485	213	#elif IS_IN (rtld)
6fb2dde3 UD	214	static int __rtld_have_atfcts;
6fb2dde3 UD	215	# define __have_atfcts __rtld_have_atfcts
7fb90fb8 UD	216	#endif
7fb90fb8 UD	217
7f811679	218	/* Get the pathname of the current working directory, and put it in SIZE
28f540f4 RM	219	bytes of BUF. Returns NULL if the directory couldn't be determined or
	220	SIZE was too small. If successful, returns BUF. In GNU, if BUF is
	221	NULL, an array is allocated with `malloc'; the array is SIZE bytes long,
a2b3aa73	222	unless SIZE == 0, in which case it is as big as necessary. */
28f540f4	223
04be94a8	224	GETCWD_RETURN_TYPE
bd2260a2	225	__getcwd (char *buf, size_t size)
28f540f4	226	{
7fb90fb8	227	#ifndef __ASSUME_ATFCTS
28f540f4 RM	228	static const char dots[]
	229	= "../../../../../../../../../../../../../../../../../../../../../../../\
	230	../../../../../../../../../../../../../../../../../../../../../../../../../../\
	231	../../../../../../../../../../../../../../../../../../../../../../../../../..";
475e390e UD	232	const char *dotp = &dots[sizeof (dots)];
	233	const char *dotlist = dots;
	234	size_t dotsize = sizeof (dots) - 1;
7fb90fb8	235	#endif
f4017d20	236	int prev_errno = errno;
7fb90fb8 UD	237	DIR *dirstream = NULL;
	238	bool fd_needs_closing = false;
	239	int fd = AT_FDCWD;
28f540f4	240
7fb90fb8 UD	241	char *path;
	242	#ifndef NO_ALLOCATION
	243	size_t allocated = size;
a2b3aa73	244	if (size == 0)
28f540f4 RM	245	{
	246	if (buf != NULL)
	247	{
c4029823	248	__set_errno (EINVAL);
28f540f4 RM	249	return NULL;
	250	}
	251
1823e76b	252	allocated = PATH_MAX + 1;
28f540f4 RM	253	}
28f540f4 RM	254
7fb90fb8	255	if (buf == NULL)
28f540f4	256	{
1823e76b	257	path = malloc (allocated);
28f540f4 RM	258	if (path == NULL)
	259	return NULL;
	260	}
7fb90fb8 UD	261	else
	262	#else
	263	# define allocated size
	264	#endif
	265	path = buf;
28f540f4	266
7fb90fb8	267	char *pathp = path + allocated;
28f540f4 RM	268	*--pathp = '\0';
28f540f4 RM	269
6fb2dde3 UD	270	struct stat64 st;
6fb2dde3 UD	271	if (__lstat64 (".", &st) < 0)
7fb90fb8 UD	272	goto lose;
	273	dev_t thisdev = st.st_dev;
	274	ino_t thisino = st.st_ino;
28f540f4	275
6fb2dde3	276	if (__lstat64 ("/", &st) < 0)
7fb90fb8 UD	277	goto lose;
	278	dev_t rootdev = st.st_dev;
	279	ino_t rootino = st.st_ino;
28f540f4	280
28f540f4 RM	281	while (!(thisdev == rootdev && thisino == rootino))
28f540f4 RM	282	{
6fb2dde3	283	if (__have_atfcts >= 0)
cef9b653	284	fd = openat64_not_cancel_3 (fd, "..", O_RDONLY \| O_CLOEXEC);
7fb90fb8 UD	285	else
	286	fd = -1;
	287	if (fd >= 0)
	288	{
	289	fd_needs_closing = true;
6fb2dde3	290	if (__fstat64 (fd, &st) < 0)
7fb90fb8 UD	291	goto lose;
	292	}
	293	#ifndef __ASSUME_ATFCTS
	294	else if (errno == ENOSYS)
	295	{
6fb2dde3	296	__have_atfcts = -1;
7fb90fb8 UD	297
	298	/* Look at the parent directory. */
	299	if (dotp == dotlist)
28f540f4	300	{
7fb90fb8 UD	301	# ifdef NO_ALLOCATION
	302	__set_errno (ENOMEM);
	303	goto lose;
	304	# else
	305	/* My, what a deep directory tree you have, Grandma. */
	306	char *new;
	307	if (dotlist == dots)
	308	{
	309	new = malloc (dotsize * 2 + 1);
	310	if (new == NULL)
	311	goto lose;
	312	# ifdef HAVE_MEMPCPY
	313	dotp = mempcpy (new, dots, dotsize);
	314	# else
	315	memcpy (new, dots, dotsize);
	316	dotp = &new[dotsize];
	317	# endif
	318	}
	319	else
	320	{
f17a4233	321	new = realloc ((void ) dotlist, dotsize 2 + 1);
7fb90fb8 UD	322	if (new == NULL)
	323	goto lose;
	324	dotp = &new[dotsize];
	325	}
	326	# ifdef HAVE_MEMPCPY
	327	((char ) mempcpy ((char *) dotp, new, dotsize)) = '\0';
	328	dotsize *= 2;
	329	# else
	330	memcpy ((char *) dotp, new, dotsize);
	331	dotsize *= 2;
	332	new[dotsize] = '\0';
	333	# endif
	334	dotlist = new;
	335	# endif
28f540f4	336	}
28f540f4	337
7fb90fb8	338	dotp -= 3;
28f540f4	339
7fb90fb8	340	/* Figure out if this directory is a mount point. */
6fb2dde3	341	if (__lstat64 (dotp, &st) < 0)
7fb90fb8 UD	342	goto lose;
	343	}
	344	#endif
	345	else
28f540f4	346	goto lose;
7fb90fb8 UD	347
	348	if (dirstream && __closedir (dirstream) != 0)
	349	{
	350	dirstream = NULL;
	351	goto lose;
	352	}
	353
	354	dev_t dotdev = st.st_dev;
	355	ino_t dotino = st.st_ino;
	356	bool mount_point = dotdev != thisdev;
28f540f4 RM	357
28f540f4 RM	358	/* Search for the last directory. */
6fb2dde3	359	if (__have_atfcts >= 0)
7fb90fb8 UD	360	dirstream = __fdopendir (fd);
	361	#ifndef __ASSUME_ATFCTS
	362	else
	363	dirstream = __opendir (dotp);
	364	#endif
28f540f4 RM	365	if (dirstream == NULL)
28f540f4 RM	366	goto lose;
7fb90fb8 UD	367	fd_needs_closing = false;
	368
	369	struct dirent *d;
	370	bool use_d_ino = true;
	371	while (1)
28f540f4	372	{
7fb90fb8 UD	373	/* Clear errno to distinguish EOF from error if readdir returns
	374	NULL. */
	375	__set_errno (0);
	376	d = __readdir (dirstream);
	377	if (d == NULL)
	378	{
	379	if (errno == 0)
	380	{
	381	/* When we've iterated through all directory entries
	382	without finding one with a matching d_ino, rewind the
	383	stream and consider each name again, but this time, using
6fb2dde3	384	lstat64. This is necessary in a chroot on at least one
7fb90fb8 UD	385	system. */
	386	if (use_d_ino)
	387	{
	388	use_d_ino = false;
2f5c1b00	389	__rewinddir (dirstream);
7fb90fb8 UD	390	continue;
	391	}
	392
	393	/* EOF on dirstream, which means that the current directory
	394	has been removed. */
	395	__set_errno (ENOENT);
	396	}
	397	goto lose;
	398	}
	399
bea9b193	400	#ifdef _DIRENT_HAVE_D_TYPE
7fb90fb8 UD	401	if (d->d_type != DT_DIR && d->d_type != DT_UNKNOWN)
7fb90fb8 UD	402	continue;
bea9b193	403	#endif
7fb90fb8 UD	404	if (d->d_name[0] == '.'
	405	&& (d->d_name[1] == '\0'
	406	\|\| (d->d_name[1] == '.' && d->d_name[2] == '\0')))
28f540f4	407	continue;
7fb90fb8 UD	408	if (use_d_ino && !mount_point && (ino_t) d->d_ino != thisino)
	409	continue;
	410
6fb2dde3	411	if (__have_atfcts >= 0)
7fb90fb8	412	{
6fb2dde3	413	/* We don't fail here if we cannot stat64() a directory entry.
7fb90fb8 UD	414	This can happen when (network) filesystems fail. If this
	415	entry is in fact the one we are looking for we will find
	416	out soon as we reach the end of the directory without
	417	having found anything. */
6fb2dde3	418	if (__fstatat64 (fd, d->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
7fb90fb8 UD	419	continue;
	420	}
	421	#ifndef __ASSUME_ATFCTS
	422	else
28f540f4	423	{
92777700	424	char name[dotlist + dotsize - dotp + 1 + _D_ALLOC_NAMLEN (d)];
7fb90fb8	425	# ifdef HAVE_MEMPCPY
86187531 UD	426	char *tmp = mempcpy (name, dotp, dotlist + dotsize - dotp);
	427	*tmp++ = '/';
	428	strcpy (tmp, d->d_name);
7fb90fb8	429	# else
28f540f4 RM	430	memcpy (name, dotp, dotlist + dotsize - dotp);
28f540f4 RM	431	name[dotlist + dotsize - dotp] = '/';
92777700	432	strcpy (&name[dotlist + dotsize - dotp + 1], d->d_name);
7fb90fb8	433	# endif
6fb2dde3	434	/* We don't fail here if we cannot stat64() a directory entry.
74f7e7c0 UD	435	This can happen when (network) filesystems fail. If this
	436	entry is in fact the one we are looking for we will find
	437	out soon as we reach the end of the directory without
	438	having found anything. */
6fb2dde3	439	if (__lstat64 (name, &st) < 0)
7fb90fb8	440	continue;
28f540f4	441	}
7fb90fb8 UD	442	#endif
	443	if (S_ISDIR (st.st_mode)
	444	&& st.st_dev == thisdev && st.st_ino == thisino)
	445	break;
28f540f4	446	}
92777700	447
7fb90fb8 UD	448	size_t namlen = _D_EXACT_NAMLEN (d);
	449
	450	if ((size_t) (pathp - path) <= namlen)
	451	{
	452	#ifndef NO_ALLOCATION
	453	if (size == 0)
28f540f4	454	{
7fb90fb8	455	size_t oldsize = allocated;
8325d82c	456
7fb90fb8 UD	457	allocated = 2 * MAX (allocated, namlen);
	458	char *tmp = realloc (path, allocated);
	459	if (tmp == NULL)
	460	goto lose;
1823e76b	461
7fb90fb8 UD	462	/* Move current contents up to the end of the buffer.
	463	This is guaranteed to be non-overlapping. */
	464	pathp = memcpy (tmp + allocated - (path + oldsize - pathp),
	465	tmp + (pathp - path),
	466	path + oldsize - pathp);
	467	path = tmp;
	468	}
	469	else
	470	#endif
	471	{
	472	__set_errno (ERANGE);
	473	goto lose;
28f540f4	474	}
28f540f4	475	}
7fb90fb8 UD	476	pathp -= namlen;
	477	(void) memcpy (pathp, d->d_name, namlen);
	478	*--pathp = '/';
28f540f4 RM	479
	480	thisdev = dotdev;
	481	thisino = dotino;
	482	}
	483
7fb90fb8 UD	484	if (dirstream != NULL && __closedir (dirstream) != 0)
	485	{
	486	dirstream = NULL;
	487	goto lose;
	488	}
	489
1823e76b	490	if (pathp == &path[allocated - 1])
28f540f4 RM	491	*--pathp = '/';
28f540f4 RM	492
7fb90fb8	493	#ifndef __ASSUME_ATFCTS
28f540f4	494	if (dotlist != dots)
f17a4233	495	free ((void *) dotlist);
7fb90fb8	496	#endif
28f540f4	497
7fb90fb8 UD	498	size_t used = path + allocated - pathp;
	499	memmove (path, pathp, used);
	500
	501	if (size == 0)
	502	/* Ensure that the buffer is only as large as necessary. */
	503	buf = realloc (path, used);
	504
	505	if (buf == NULL)
	506	/* Either buf was NULL all along, or `realloc' failed but
	507	we still have the original string. */
	508	buf = path;
f4017d20 UD	509
	510	/* Restore errno on successful return. */
	511	__set_errno (prev_errno);
	512
7fb90fb8	513	return buf;
28f540f4	514
7fb90fb8 UD	515	lose:;
	516	int save_errno = errno;
	517	#ifndef __ASSUME_ATFCTS
28f540f4	518	if (dotlist != dots)
f17a4233	519	free ((void *) dotlist);
7fb90fb8 UD	520	#endif
	521	if (dirstream != NULL)
	522	__closedir (dirstream);
	523	if (fd_needs_closing)
	524	close_not_cancel_no_status (fd);
	525	#ifndef NO_ALLOCATION
475e390e UD	526	if (buf == NULL)
475e390e UD	527	free (path);
7fb90fb8 UD	528	#endif
7fb90fb8 UD	529	__set_errno (save_errno);
28f540f4 RM	530	return NULL;
28f540f4 RM	531	}
3ec41e03	532
fe0ec73e	533	#if defined _LIBC && !defined __getcwd
3ec41e03 RM	534	weak_alias (__getcwd, getcwd)
3ec41e03 RM	535	#endif