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  /* Write data pointed by the buffers described by VECTOR, which
      36     is a vector of COUNT 'struct iovec's, to file descriptor FD.
      37     The data is written in the order specified.
      38     Operates just like 'write' (see <unistd.h>) except that the data
      39     are taken from VECTOR instead of a contiguous buffer.  */
      40  ssize_t
      41  __writev (int fd, const struct iovec *vector, int count)
      42  {
      43    /* Find the total number of bytes to be written.  */
      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      /* XXX I don't know whether it is acceptable to try writing
      64         the data in chunks.  Probably not so we just fail here.  */
      65      return -1;
      66    char *buffer = buf.data;
      67  
      68    /* Copy the data into BUFFER.  */
      69    size_t to_copy = bytes;
      70    char *bp = buffer;
      71    for (int i = 0; i < count; ++i)
      72      {
      73        size_t copy = MIN (vector[i].iov_len, to_copy);
      74  
      75        bp = __mempcpy ((void *) bp, (void *) vector[i].iov_base, copy);
      76  
      77        to_copy -= copy;
      78        if (to_copy == 0)
      79  	break;
      80      }
      81  
      82    ssize_t bytes_written = __write (fd, buffer, bytes);
      83  
      84    return bytes_written;
      85  }
      86  libc_hidden_def (__writev)
      87  #ifndef __writev
      88  weak_alias (__writev, writev)
      89  #endif