1  /* Copyright (C) 1991-2023 Free Software Foundation, Inc.
       2     This file is part of the GNU C Library.
       3  
       4     The GNU C Library is free software; you can redistribute it and/or
       5     modify it under the terms of the GNU Lesser General Public
       6     License as published by the Free Software Foundation; either
       7     version 2.1 of the License, or (at your option) any later version.
       8  
       9     The GNU C Library is distributed in the hope that it will be useful,
      10     but WITHOUT ANY WARRANTY; without even the implied warranty of
      11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12     Lesser General Public License for more details.
      13  
      14     You should have received a copy of the GNU Lesser General Public
      15     License along with the GNU C Library; if not, see
      16     <https://www.gnu.org/licenses/>.  */
      17  
      18  #include <stdlib.h>
      19  #include <unistd.h>
      20  #include <string.h>
      21  #include <limits.h>
      22  #include <scratch_buffer.h>
      23  #include <stdbool.h>
      24  #include <sys/param.h>
      25  #include <sys/uio.h>
      26  #include <errno.h>
      27  
      28  
      29  static void
      30  ifree (struct scratch_buffer *sbuf)
      31  {
      32    scratch_buffer_free (sbuf);
      33  }
      34  
      35  /* Read data from file descriptor FD, and put the result in the
      36     buffers described by VECTOR, which is a vector of COUNT 'struct iovec's.
      37     The buffers are filled in the order specified.
      38     Operates just like 'read' (see <unistd.h>) except that data are
      39     put in VECTOR instead of a contiguous buffer.  */
      40  ssize_t
      41  __readv (int fd, const struct iovec *vector, int count)
      42  {
      43    /* Find the total number of bytes to be read.  */
      44    size_t bytes = 0;
      45    for (int i = 0; i < count; ++i)
      46      {
      47        /* Check for ssize_t overflow.  */
      48        if (SSIZE_MAX - bytes < vector[i].iov_len)
      49  	{
      50  	  __set_errno (EINVAL);
      51  	  return -1;
      52  	}
      53        bytes += vector[i].iov_len;
      54      }
      55  
      56    /* Allocate a temporary buffer to hold the data.  Use a scratch_buffer
      57       since it's faster for small buffer sizes but can handle larger
      58       allocations as well.  */
      59  
      60    struct scratch_buffer __attribute__ ((__cleanup__ (ifree))) buf;
      61    scratch_buffer_init (&buf);
      62    if (!scratch_buffer_set_array_size (&buf, 1, bytes))
      63      return -1;
      64    char *buffer = buf.data;
      65  
      66    /* Read the data.  */
      67    ssize_t bytes_read = __read (fd, buffer, bytes);
      68    if (bytes_read < 0)
      69      return -1;
      70  
      71    /* Copy the data from BUFFER into the memory specified by VECTOR.  */
      72    bytes = bytes_read;
      73    for (int i = 0; i < count; ++i)
      74      {
      75        size_t copy = MIN (vector[i].iov_len, bytes);
      76  
      77        (void) memcpy ((void *) vector[i].iov_base, (void *) buffer, copy);
      78  
      79        buffer += copy;
      80        bytes -= copy;
      81        if (bytes == 0)
      82  	break;
      83      }
      84  
      85    return bytes_read;
      86  }
      87  libc_hidden_def (__readv)
      88  weak_alias (__readv, readv)