pintos-os.org Git - pspp/blob - lib/xreadlink.c

   1 /* xreadlink.c -- readlink wrapper to return the link name in malloc'd storage
   2
   3    Copyright (C) 2001, 2003-2007 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; see the file COPYING.
  17    If not, write to the Free Software Foundation,
  18    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 /* Written by Jim Meyering <jim@meyering.net>
  21    and Bruno Haible <bruno@clisp.org>.  */
  22
  23 #include <config.h>
  24
  25 /* Specification.  */
  26 #include "xreadlink.h"
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #include <limits.h>
  32 #include <sys/types.h>
  33 #include <stdlib.h>
  34 #if HAVE_UNISTD_H
  35 # include <unistd.h>
  36 #endif
  37
  38 #ifndef SIZE_MAX
  39 # define SIZE_MAX ((size_t) -1)
  40 #endif
  41 #ifndef SSIZE_MAX
  42 # define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))
  43 #endif
  44
  45 #ifdef NO_XMALLOC
  46 # define xmalloc malloc
  47 #else
  48 # include "xalloc.h"
  49 #endif
  50
  51 /* Call readlink to get the symbolic link value of FILENAME.
  52    Return a pointer to that NUL-terminated string in malloc'd storage.
  53    If readlink fails, return NULL (caller may use errno to diagnose).
  54    If realloc fails, or if the link value is longer than SIZE_MAX :-),
  55    give a diagnostic and exit.  */
  56
  57 char *
  58 xreadlink (char const *filename)
  59 {
  60   /* The initial buffer size for the link value.  A power of 2
  61      detects arithmetic overflow earlier, but is not required.  */
  62 #define INITIAL_BUF_SIZE 1024
  63
  64   /* Allocate the initial buffer on the stack.  This way, in the common
  65      case of a symlink of small size, we get away with a single small malloc()
  66      instead of a big malloc() followed by a shrinking realloc().  */
  67   char initial_buf[INITIAL_BUF_SIZE];
  68
  69   char *buffer = initial_buf;
  70   size_t buf_size = sizeof (initial_buf);
  71
  72   while (1)
  73     {
  74       /* Attempt to read the link into the current buffer.  */
  75       ssize_t link_length = readlink (filename, buffer, buf_size);
  76
  77       /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1
  78          with errno == ERANGE if the buffer is too small.  */
  79       if (link_length < 0 && errno != ERANGE)
  80         {
  81           if (buffer != initial_buf)
  82             {
  83               int saved_errno = errno;
  84               free (buffer);
  85               errno = saved_errno;
  86             }
  87           return NULL;
  88         }
  89
  90       if ((size_t) link_length < buf_size)
  91         {
  92           buffer[link_length++] = '\0';
  93
  94           /* Return it in a chunk of memory as small as possible.  */
  95           if (buffer == initial_buf)
  96             {
  97               buffer = (char *) xmalloc (link_length);
  98 #ifdef NO_XMALLOC
  99               if (buffer == NULL)
 100                 return NULL;
 101 #endif
 102               memcpy (buffer, initial_buf, link_length);
 103             }
 104           else
 105             {
 106               /* Shrink buffer before returning it.  */
 107               if ((size_t) link_length < buf_size)
 108                 {
 109                   char *smaller_buffer = (char *) realloc (buffer, link_length);
 110
 111                   if (smaller_buffer != NULL)
 112                     buffer = smaller_buffer;
 113                 }
 114             }
 115           return buffer;
 116         }
 117
 118       if (buffer != initial_buf)
 119         free (buffer);
 120       buf_size *= 2;
 121       if (SSIZE_MAX < buf_size || (SIZE_MAX / 2 < SSIZE_MAX && buf_size == 0))
 122 #ifdef NO_XMALLOC
 123         return NULL;
 124 #else
 125         xalloc_die ();
 126 #endif
 127       buffer = (char *) xmalloc (buf_size);
 128 #ifdef NO_XMALLOC
 129       if (buffer == NULL)
 130         return NULL;
 131 #endif
 132     }
 133 }