Writing a full buffer using write() system call

Question

I want to write a buffer filled with BUFF_SIZE bytes over a TCP socket using the write system call:

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);

The documentation states that

write() writes up to count bytes from the buffer pointed buf to the file referred to by the file descriptor fd.

Of course, the number of actual bytes written can be detected by the return value. However, if I want to ensure that my whole buffer of bytes gets sent over the connection, what would be a good way to do this? So far, I was thinking:

while ( (ch = fgetc(pipe) ) != EOF )
{
    buff[ 0 ] = ch;
    bytes_in_buff++;

    // fill a buffer's worth of data from the pipe
    for (int i = 1; i < BUFF_SIZE; ++i, ++bytes_in_buff)
    {
        if ( (ch = fgetc(pipe) ) == EOF)
            break;

        buff[ i ] = ch;
    }

    // write that buffer to the pipe
    int bytes_sent = 0;
    while (bytes_sent < BUFF_SIZE)
    {
        bytes_sent = write(fd, buff, bytes_in_buff);
    }
}

But of course, some redundant bytes will be sent if I continue to send the entire buffer each time bytes_sent < BUFF_SIZE .

score 2 · Answer 1 · edited Dec 14 '18 at 11:38

2

If write() returns less than BUFF_SIZE your suggested loop will never terminate; and you need to check for errors.

You need something like this:

while (bytes_in_buff > 0)
{
    bytes_sent = write(fd, buff, bytes_in_buff);
    if (bytes_sent < 0)
    {
        perror("write");  // or whatever
        break;
    }
    buff += bytes_sent;
    bytes_in_buff -= bytes_sent;
}

However this issue was discussed in extenso on news:comp.protocols.tcp-ip some years ago, which is the place where TCP/IP implementators hang out, and it was agreed there that, in blocking mode, both write() and send() must send the entire buffer before returning.

edited Dec 14 '18 at 11:38

meowgoesthedog

14,670
4
27
40

answered Jun 17 '14 at 09:30

user207421

305,947
44
307
483

Is your last paragraph true when the system call is blocked and then interrupted? Will the implementation of the system call always automatically restart the I/O if interrupted? – jxh Jun 18 '14 at 02:52
@jxh I'm sorry I cannot recall the discussion in that level of detail, but it seems to me that it shouldn't restart. How it advises both an interrupt and the number of bytes transferred before the interrupt has always been a mystery to me. – user207421 Nov 17 '17 at 02:30

alk · Answer 2 · 2014-06-17T09:55:56.450

Have a look at the following function which loops around write() until s bytes from b had been written or a fatal error had occurred:

int writen(const int sd, const char * b, const size_t s, const int retry_on_interrupt)
{
  size_t n = s;
  while (0 < n)
  {
    ssize_t result = write(sd, b, n);
    if (-1 == result)
    {
      if ((retry_on_interrupt && (errno == EINTR)) || (errno == EWOULDBLOCK) || (errno == EAGAIN))
      {
        continue;
      }
      else
      {
        break;
      }
    }

    n -= result;
    b += result;
  }

  return (0 < n) ?-1 :0;
}

Call it like this:

int retry_on_interrupt = ... /* {0|1} depending on wether a signal reception shall abort the write operation or not. */
int result = writen(fd, buff, sizeof(buf), retry_on_interrupt)
if (-1 == result)
{
  perror("writen()");
}

Would converting to `FILE*` with `fdopen` and then using `fwrite` be enough? — Ciro Santilli OurBigBook.com, Feb 08 '18 at 21:43
@CiroSantilli华涌低端人口六四事件法轮功: This would very well be worth a separate question. — alk, Feb 09 '18 at 11:48

score 1 · Answer 3 · answered Jun 17 '14 at 09:17

You need to edit the parameters you give to write to account for the data you've already sent. So something like this:

int bytes_sent = 0;
int remaining = BUFF_SIZE;
while (remaining) 
{
  bytes_sent = write(fd, buff, remaining);
  remaining -= bytes_sent;
  buff += bytes_sent;
}

Writing a full buffer using write() system call

3 Answers3

Linked