lib/write.c

   1 /* POSIX compatible write() function.
   2    Copyright (C) 2008-2017 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2008.
   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 3 of the License, or
   8    (at your option) 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.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include <config.h>
  19
  20 /* Specification.  */
  21 #include <unistd.h>
  22
  23 /* On native Windows platforms, SIGPIPE does not exist.  When write() is
  24    called on a pipe with no readers, WriteFile() fails with error
  25    GetLastError() = ERROR_NO_DATA, and write() in consequence fails with
  26    error EINVAL.  */
  27
  28 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
  29
  30 # include <errno.h>
  31 # include <signal.h>
  32 # include <io.h>
  33
  34 # define WIN32_LEAN_AND_MEAN  /* avoid including junk */
  35 # include <windows.h>
  36
  37 # if HAVE_MSVC_INVALID_PARAMETER_HANDLER
  38 #  include "msvc-inval.h"
  39 # endif
  40 # if GNULIB_MSVC_NOTHROW
  41 #  include "msvc-nothrow.h"
  42 # else
  43 #  include <io.h>
  44 # endif
  45
  46 # undef write
  47
  48 # if HAVE_MSVC_INVALID_PARAMETER_HANDLER
  49 static ssize_t
  50 write_nothrow (int fd, const void *buf, size_t count)
  51 {
  52   ssize_t result;
  53
  54   TRY_MSVC_INVAL
  55     {
  56       result = write (fd, buf, count);
  57     }
  58   CATCH_MSVC_INVAL
  59     {
  60       result = -1;
  61       errno = EBADF;
  62     }
  63   DONE_MSVC_INVAL;
  64
  65   return result;
  66 }
  67 # else
  68 #  define write_nothrow write
  69 # endif
  70
  71 ssize_t
  72 rpl_write (int fd, const void *buf, size_t count)
  73 {
  74   for (;;)
  75     {
  76       ssize_t ret = write_nothrow (fd, buf, count);
  77
  78       if (ret < 0)
  79         {
  80 # if GNULIB_NONBLOCKING
  81           if (errno == ENOSPC)
  82             {
  83               HANDLE h = (HANDLE) _get_osfhandle (fd);
  84               if (GetFileType (h) == FILE_TYPE_PIPE)
  85                 {
  86                   /* h is a pipe or socket.  */
  87                   DWORD state;
  88                   if (GetNamedPipeHandleState (h, &state, NULL, NULL, NULL,
  89                                                NULL, 0)
  90                       && (state & PIPE_NOWAIT) != 0)
  91                     {
  92                       /* h is a pipe in non-blocking mode.
  93                          We can get here in four situations:
  94                            1. When the pipe buffer is full.
  95                            2. When count <= pipe_buf_size and the number of
  96                               free bytes in the pipe buffer is < count.
  97                            3. When count > pipe_buf_size and the number of free
  98                               bytes in the pipe buffer is > 0, < pipe_buf_size.
  99                            4. When count > pipe_buf_size and the pipe buffer is
 100                               entirely empty.
 101                          The cases 1 and 2 are POSIX compliant.  In cases 3 and
 102                          4 POSIX specifies that write() must split the request
 103                          and succeed with a partial write.  We fix case 4.
 104                          We don't fix case 3 because it is not essential for
 105                          programs.  */
 106                       DWORD out_size; /* size of the buffer for outgoing data */
 107                       DWORD in_size;  /* size of the buffer for incoming data */
 108                       if (GetNamedPipeInfo (h, NULL, &out_size, &in_size, NULL))
 109                         {
 110                           size_t reduced_count = count;
 111                           /* In theory we need only one of out_size, in_size.
 112                              But I don't know which of the two.  The description
 113                              is ambiguous.  */
 114                           if (out_size != 0 && out_size < reduced_count)
 115                             reduced_count = out_size;
 116                           if (in_size != 0 && in_size < reduced_count)
 117                             reduced_count = in_size;
 118                           if (reduced_count < count)
 119                             {
 120                               /* Attempt to write only the first part.  */
 121                               count = reduced_count;
 122                               continue;
 123                             }
 124                         }
 125                       /* Change errno from ENOSPC to EAGAIN.  */
 126                       errno = EAGAIN;
 127                     }
 128                 }
 129             }
 130           else
 131 # endif
 132             {
 133 # if GNULIB_SIGPIPE
 134               if (GetLastError () == ERROR_NO_DATA
 135                   && GetFileType ((HANDLE) _get_osfhandle (fd))
 136                      == FILE_TYPE_PIPE)
 137                 {
 138                   /* Try to raise signal SIGPIPE.  */
 139                   raise (SIGPIPE);
 140                   /* If it is currently blocked or ignored, change errno from
 141                      EINVAL to EPIPE.  */
 142                   errno = EPIPE;
 143                 }
 144 # endif
 145             }
 146         }
 147       return ret;
 148     }
 149 }
 150
 151 #endif