[BACK]Return to areadlink.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libiconv / srclib

Diff for /embedaddon/libiconv/srclib/areadlink.c between versions 1.1 and 1.1.1.3

version 1.1, 2012/02/21 22:57:48 version 1.1.1.3, 2021/03/17 13:38:46
Line 1 Line 1
 /* areadlink.c -- readlink wrapper to return the link name in malloc'd storage  /* areadlink.c -- readlink wrapper to return the link name in malloc'd storage
    Unlike xreadlink and xreadlink_with_size, don't ever call exit.     Unlike xreadlink and xreadlink_with_size, don't ever call exit.
   
   Copyright (C) 2001, 2003-2007 Free Software Foundation, Inc.   Copyright (C) 2001, 2003-2007, 2009-2019 Free Software Foundation, Inc.
   
    This program is free software: you can redistribute it and/or modify     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     it under the terms of the GNU General Public License as published by
Line 14 Line 14
    GNU General Public License for more details.     GNU General Public License for more details.
   
    You should have received a copy of the GNU General Public License     You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
   
 /* Written by Jim Meyering <jim@meyering.net>  /* Written by Jim Meyering <jim@meyering.net>
    and Bruno Haible <bruno@clisp.org>.  */     and Bruno Haible <bruno@clisp.org>.  */
Line 24 Line 24
 /* Specification.  */  /* Specification.  */
 #include "areadlink.h"  #include "areadlink.h"
   
#include <string.h>#include "careadlinkat.h"
#include <errno.h>
#include <limits.h> 
#include <sys/types.h> 
 #include <stdlib.h>  #include <stdlib.h>
 #include <unistd.h>  #include <unistd.h>
   
#ifndef SIZE_MAX/* Get the symbolic link value of FILENAME and put it into BUFFER, with
# define SIZE_MAX ((size_t) -1)   size BUFFER_SIZE.  This function acts like readlink but has
#endif   readlinkat's signature.  */
#ifndef SSIZE_MAXstatic ssize_t
# define SSIZE_MAX ((ssize_t) (SIZE_MAX / 2))careadlinkatcwd (int fd, char const *filename, char *buffer,
#endif                 size_t buffer_size)
 {
   /* FD must be AT_FDCWD here, otherwise the caller is using this
      function in contexts it was not meant for.  */
   if (fd != AT_FDCWD)
     abort ();
   return readlink (filename, buffer, buffer_size);
 }
   
 /* Call readlink to get the symbolic link value of FILENAME.  /* Call readlink to get the symbolic link value of FILENAME.
    Return a pointer to that NUL-terminated string in malloc'd storage.     Return a pointer to that NUL-terminated string in malloc'd storage.
    If readlink fails, return NULL and set errno.     If readlink fails, return NULL and set errno.
   If realloc fails, or if the link value is longer than SIZE_MAX :-),   If allocation fails, or if the link value is longer than SIZE_MAX :-),
    return NULL and set errno to ENOMEM.  */     return NULL and set errno to ENOMEM.  */
   
 char *  char *
 areadlink (char const *filename)  areadlink (char const *filename)
 {  {
  /* The initial buffer size for the link value.  A power of 2  return careadlinkat (AT_FDCWD, filename, NULL, 0, NULL, careadlinkatcwd);
     detects arithmetic overflow earlier, but is not required.  */ 
#define INITIAL_BUF_SIZE 1024 
 
  /* 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().  */ 
  char initial_buf[INITIAL_BUF_SIZE]; 
 
  char *buffer = initial_buf; 
  size_t buf_size = sizeof (initial_buf); 
 
  while (1) 
    { 
      /* Attempt to read the link into the current buffer.  */ 
      ssize_t link_length = readlink (filename, buffer, buf_size); 
 
      /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1 
         with errno == ERANGE if the buffer is too small.  */ 
      if (link_length < 0 && errno != ERANGE) 
        { 
          if (buffer != initial_buf) 
            { 
              int saved_errno = errno; 
              free (buffer); 
              errno = saved_errno; 
            } 
          return NULL; 
        } 
 
      if ((size_t) link_length < buf_size) 
        { 
          buffer[link_length++] = '\0'; 
 
          /* Return it in a chunk of memory as small as possible.  */ 
          if (buffer == initial_buf) 
            { 
              buffer = (char *) malloc (link_length); 
              if (buffer == NULL) 
                /* errno is ENOMEM.  */ 
                return NULL; 
              memcpy (buffer, initial_buf, link_length); 
            } 
          else 
            { 
              /* Shrink buffer before returning it.  */ 
              if ((size_t) link_length < buf_size) 
                { 
                  char *smaller_buffer = (char *) realloc (buffer, link_length); 
 
                  if (smaller_buffer != NULL) 
                    buffer = smaller_buffer; 
                } 
            } 
          return buffer; 
        } 
 
      if (buffer != initial_buf) 
        free (buffer); 
      buf_size *= 2; 
      if (SSIZE_MAX < buf_size || (SIZE_MAX / 2 < SSIZE_MAX && buf_size == 0)) 
        { 
          errno = ENOMEM; 
          return NULL; 
        } 
      buffer = (char *) malloc (buf_size); 
      if (buffer == NULL) 
        /* errno is ENOMEM.  */ 
        return NULL; 
    } 
 }  }
Removed from v.1.1  
changed lines
  Added in v.1.1.1.3

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>