lib/careadlinkat.c

   1 /* Read symbolic links into a buffer without size limitation, relative to fd.
   2
   3    Copyright (C) 2001, 2003-2004, 2007, 2009-2011 Free Software Foundation,
   4    Inc.
   5
   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.
  10
  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.
  15
  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/>.  */
  18
  19 /* Written by Paul Eggert, Bruno Haible, and Jim Meyering.  */
  20
  21 #include <config.h>
  22
  23 #include "careadlinkat.h"
  24
  25 #include "allocator.h"
  26
  27 #include <errno.h>
  28 #include <limits.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31
  32 /* Define this independently so that stdint.h is not a prerequisite.  */
  33 #ifndef SIZE_MAX
  34 # define SIZE_MAX ((size_t) -1)
  35 #endif
  36
  37 #ifndef SSIZE_MAX
  38 # define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))
  39 #endif
  40
  41 #if ! HAVE_READLINKAT
  42 /* Ignore FD.  Get the symbolic link value of FILENAME and put it into
  43    BUFFER, with size BUFFER_SIZE.  This function acts like readlink
  44    but has readlinkat's signature.  */
  45 ssize_t
  46 careadlinkatcwd (int fd, char const *filename, char *buffer,
  47                  size_t buffer_size)
  48 {
  49   (void) fd;
  50   return readlink (filename, buffer, buffer_size);
  51 }
  52 #endif
  53
  54 /* Assuming the current directory is FD, get the symbolic link value
  55    of FILENAME as a null-terminated string and put it into a buffer.
  56    If FD is AT_FDCWD, FILENAME is interpreted relative to the current
  57    working directory, as in openat.
  58
  59    If the link is small enough to fit into BUFFER put it there.
  60    BUFFER's size is BUFFER_SIZE, and BUFFER can be null
  61    if BUFFER_SIZE is zero.
  62
  63    If the link is not small, put it into a dynamically allocated
  64    buffer managed by ALLOC.  It is the caller's responsibility to free
  65    the returned value if it is nonnull and is not BUFFER.  A null
  66    ALLOC stands for the standard allocator.
  67
  68    The PREADLINKAT function specifies how to read links.  It operates
  69    like POSIX readlinkat()
  70    <http://pubs.opengroup.org/onlinepubs/9699919799/functions/readlink.html>
  71    but can assume that its first argument is the same as FD.
  72
  73    If successful, return the buffer address; otherwise return NULL and
  74    set errno.  */
  75
  76 char *
  77 careadlinkat (int fd, char const *filename,
  78               char *buffer, size_t buffer_size,
  79               struct allocator const *alloc,
  80               ssize_t (*preadlinkat) (int, char const *, char *, size_t))
  81 {
  82   char *buf;
  83   size_t buf_size;
  84   size_t buf_size_max =
  85     SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX;
  86   char stack_buf[1024];
  87
  88   if (! alloc)
  89     alloc = &stdlib_allocator;
  90
  91   if (! buffer_size)
  92     {
  93       /* Allocate the initial buffer on the stack.  This way, in the
  94          common case of a symlink of small size, we get away with a
  95          single small malloc() instead of a big malloc() followed by a
  96          shrinking realloc().  */
  97       buffer = stack_buf;
  98       buffer_size = sizeof stack_buf;
  99     }
 100
 101   buf = buffer;
 102   buf_size = buffer_size;
 103
 104   do
 105     {
 106       /* Attempt to read the link into the current buffer.  */
 107       ssize_t link_length = preadlinkat (fd, filename, buf, buf_size);
 108       size_t link_size;
 109       if (link_length < 0)
 110         {
 111           /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1
 112              with errno == ERANGE if the buffer is too small.  */
 113           int readlinkat_errno = errno;
 114           if (readlinkat_errno != ERANGE)
 115             {
 116               if (buf != buffer)
 117                 {
 118                   alloc->free (buf);
 119                   errno = readlinkat_errno;
 120                 }
 121               return NULL;
 122             }
 123         }
 124
 125       link_size = link_length;
 126
 127       if (link_size < buf_size)
 128         {
 129           buf[link_size++] = '\0';
 130
 131           if (buf == stack_buf)
 132             {
 133               char *b = (char *) alloc->allocate (link_size);
 134               if (! b)
 135                 break;
 136               memcpy (b, buf, link_size);
 137               buf = b;
 138             }
 139           else if (link_size < buf_size && buf != buffer && alloc->reallocate)
 140             {
 141               /* Shrink BUF before returning it.  */
 142               char *b = (char *) alloc->reallocate (buf, link_size);
 143               if (b)
 144                 buf = b;
 145             }
 146
 147           return buf;
 148         }
 149
 150       if (buf != buffer)
 151         alloc->free (buf);
 152
 153       if (buf_size <= buf_size_max / 2)
 154         buf_size *= 2;
 155       else if (buf_size < buf_size_max)
 156         buf_size = buf_size_max;
 157       else
 158         break;
 159       buf = (char *) alloc->allocate (buf_size);
 160     }
 161   while (buf);
 162
 163   if (alloc->die)
 164     alloc->die ();
 165   errno = ENOMEM;
 166   return NULL;
 167 }