2014-04-22 Daniel Colascione <dancol@dancol.org>
[emacs.git] / lib / careadlinkat.c
blobb36fea28302078d8935dfa78d22effdedf74100a
1 /* Read symbolic links into a buffer without size limitation, relative to fd.
3 Copyright (C) 2001, 2003-2004, 2007, 2009-2014 Free Software Foundation,
4 Inc.
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program 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
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 /* Written by Paul Eggert, Bruno Haible, and Jim Meyering. */
21 #include <config.h>
23 #include "careadlinkat.h"
25 #include <errno.h>
26 #include <limits.h>
27 #include <string.h>
28 #include <unistd.h>
30 /* Define this independently so that stdint.h is not a prerequisite. */
31 #ifndef SIZE_MAX
32 # define SIZE_MAX ((size_t) -1)
33 #endif
35 #ifndef SSIZE_MAX
36 # define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))
37 #endif
39 #include "allocator.h"
41 /* Assuming the current directory is FD, get the symbolic link value
42 of FILENAME as a null-terminated string and put it into a buffer.
43 If FD is AT_FDCWD, FILENAME is interpreted relative to the current
44 working directory, as in openat.
46 If the link is small enough to fit into BUFFER put it there.
47 BUFFER's size is BUFFER_SIZE, and BUFFER can be null
48 if BUFFER_SIZE is zero.
50 If the link is not small, put it into a dynamically allocated
51 buffer managed by ALLOC. It is the caller's responsibility to free
52 the returned value if it is nonnull and is not BUFFER. A null
53 ALLOC stands for the standard allocator.
55 The PREADLINKAT function specifies how to read links. It operates
56 like POSIX readlinkat()
57 <http://pubs.opengroup.org/onlinepubs/9699919799/functions/readlink.html>
58 but can assume that its first argument is the same as FD.
60 If successful, return the buffer address; otherwise return NULL and
61 set errno. */
63 char *
64 careadlinkat (int fd, char const *filename,
65 char *buffer, size_t buffer_size,
66 struct allocator const *alloc,
67 ssize_t (*preadlinkat) (int, char const *, char *, size_t))
69 char *buf;
70 size_t buf_size;
71 size_t buf_size_max =
72 SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX;
73 char stack_buf[1024];
75 if (! alloc)
76 alloc = &stdlib_allocator;
78 if (! buffer_size)
80 /* Allocate the initial buffer on the stack. This way, in the
81 common case of a symlink of small size, we get away with a
82 single small malloc() instead of a big malloc() followed by a
83 shrinking realloc(). */
84 buffer = stack_buf;
85 buffer_size = sizeof stack_buf;
88 buf = buffer;
89 buf_size = buffer_size;
93 /* Attempt to read the link into the current buffer. */
94 ssize_t link_length = preadlinkat (fd, filename, buf, buf_size);
95 size_t link_size;
96 if (link_length < 0)
98 /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1
99 with errno == ERANGE if the buffer is too small. */
100 int readlinkat_errno = errno;
101 if (readlinkat_errno != ERANGE)
103 if (buf != buffer)
105 alloc->free (buf);
106 errno = readlinkat_errno;
108 return NULL;
112 link_size = link_length;
114 if (link_size < buf_size)
116 buf[link_size++] = '\0';
118 if (buf == stack_buf)
120 char *b = (char *) alloc->allocate (link_size);
121 buf_size = link_size;
122 if (! b)
123 break;
124 memcpy (b, buf, link_size);
125 buf = b;
127 else if (link_size < buf_size && buf != buffer && alloc->reallocate)
129 /* Shrink BUF before returning it. */
130 char *b = (char *) alloc->reallocate (buf, link_size);
131 if (b)
132 buf = b;
135 return buf;
138 if (buf != buffer)
139 alloc->free (buf);
141 if (buf_size <= buf_size_max / 2)
142 buf_size *= 2;
143 else if (buf_size < buf_size_max)
144 buf_size = buf_size_max;
145 else if (buf_size_max < SIZE_MAX)
147 errno = ENAMETOOLONG;
148 return NULL;
150 else
151 break;
152 buf = (char *) alloc->allocate (buf_size);
154 while (buf);
156 if (alloc->die)
157 alloc->die (buf_size);
158 errno = ENOMEM;
159 return NULL;