kc3-lang/gnulib/lib/careadlinkat.c

• Show log

  Commit

• Hash : 3f9fff25
  Author :
  Date : 2011-06-06T11:01:52
  

  careadlinkat: Avoid mismatch between ssize_t and int.
  
  * lib/careadlinkat.h (careadlinkatcwd): Declare as a function always.
  * lib/careadlinkat.c (careadlinkatcwd): Define always.
  

Download

• lib/careadlinkat.c

• /* Read symbolic links into a buffer without size limitation, relative to fd.
  
     Copyright (C) 2001, 2003-2004, 2007, 2009-2011 Free Software Foundation,
     Inc.
  
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 3 of the License, or
     (at your option) any later version.
  
     This program 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 General Public License for more details.
  
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  
  /* Written by Paul Eggert, Bruno Haible, and Jim Meyering.  */
  
  #include <config.h>
  
  #include "careadlinkat.h"
  
  #include <errno.h>
  #include <limits.h>
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>
  
  /* Define this independently so that stdint.h is not a prerequisite.  */
  #ifndef SIZE_MAX
  # define SIZE_MAX ((size_t) -1)
  #endif
  
  #ifndef SSIZE_MAX
  # define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))
  #endif
  
  #include "allocator.h"
  
  /* Get the symbolic link value of FILENAME and put it into BUFFER, with
     size BUFFER_SIZE.  This function acts like readlink  but has
     readlinkat's signature.  */
  ssize_t
  careadlinkatcwd (int fd, char const *filename, char *buffer,
                   size_t buffer_size)
  {
    /* FD must be AT_FDCWD here, otherwise the caller is using this
       function in contexts for which it was not meant for.  */
    if (fd != AT_FDCWD)
      abort ();
    return readlink (filename, buffer, buffer_size);
  }
  
  /* Assuming the current directory is FD, get the symbolic link value
     of FILENAME as a null-terminated string and put it into a buffer.
     If FD is AT_FDCWD, FILENAME is interpreted relative to the current
     working directory, as in openat.
  
     If the link is small enough to fit into BUFFER put it there.
     BUFFER's size is BUFFER_SIZE, and BUFFER can be null
     if BUFFER_SIZE is zero.
  
     If the link is not small, put it into a dynamically allocated
     buffer managed by ALLOC.  It is the caller's responsibility to free
     the returned value if it is nonnull and is not BUFFER.  A null
     ALLOC stands for the standard allocator.
  
     The PREADLINKAT function specifies how to read links.  It operates
     like POSIX readlinkat()
     <http://pubs.opengroup.org/onlinepubs/9699919799/functions/readlink.html>
     but can assume that its first argument is the same as FD.
  
     If successful, return the buffer address; otherwise return NULL and
     set errno.  */
  
  char *
  careadlinkat (int fd, char const *filename,
                char *buffer, size_t buffer_size,
                struct allocator const *alloc,
                ssize_t (*preadlinkat) (int, char const *, char *, size_t))
  {
    char *buf;
    size_t buf_size;
    size_t buf_size_max =
      SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX;
    char stack_buf[1024];
  
    if (! alloc)
      alloc = &stdlib_allocator;
  
    if (! buffer_size)
      {
        /* Allocate the initial buffer on the stack.  This way, in the
           common case of a symlink of small size, we get away with a
           single small malloc() instead of a big malloc() followed by a
           shrinking realloc().  */
        buffer = stack_buf;
        buffer_size = sizeof stack_buf;
      }
  
    buf = buffer;
    buf_size = buffer_size;
  
    do
      {
        /* Attempt to read the link into the current buffer.  */
        ssize_t link_length = preadlinkat (fd, filename, buf, buf_size);
        size_t link_size;
        if (link_length < 0)
          {
            /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1
               with errno == ERANGE if the buffer is too small.  */
            int readlinkat_errno = errno;
            if (readlinkat_errno != ERANGE)
              {
                if (buf != buffer)
                  {
                    alloc->free (buf);
                    errno = readlinkat_errno;
                  }
                return NULL;
              }
          }
  
        link_size = link_length;
  
        if (link_size < buf_size)
          {
            buf[link_size++] = '\0';
  
            if (buf == stack_buf)
              {
                char *b = (char *) alloc->allocate (link_size);
                buf_size = link_size;
                if (! b)
                  break;
                memcpy (b, buf, link_size);
                buf = b;
              }
            else if (link_size < buf_size && buf != buffer && alloc->reallocate)
              {
                /* Shrink BUF before returning it.  */
                char *b = (char *) alloc->reallocate (buf, link_size);
                if (b)
                  buf = b;
              }
  
            return buf;
          }
  
        if (buf != buffer)
          alloc->free (buf);
  
        if (buf_size <= buf_size_max / 2)
          buf_size *= 2;
        else if (buf_size < buf_size_max)
          buf_size = buf_size_max;
        else if (buf_size_max < SIZE_MAX)
          {
            errno = ENAMETOOLONG;
            return NULL;
          }
        else
          break;
        buf = (char *) alloc->allocate (buf_size);
      }
    while (buf);
  
    if (alloc->die)
      alloc->die (buf_size);
    errno = ENOMEM;
    return NULL;
  }
  

Download