UNIX for Advanced & Expert Users

Greetings.

Suppose I have a UNIX OS with automatic-restart (by default) of interrupted system calls,
or I use sigaction() with SA_RESTART flag.

If I am in the middle of a read(fd1, buf1, MAXSIZE) or a write(fd2, buf2, MAXSIZE),
and I am interrupted by a signal, then the system will automatically restart my system calls.

The problem is that if the read() succedded with reading n1 bytes, then the file-offset of fd1
will be updated by n1 bytes, but the "offset" in buf1 buffer will not be.

So, when the kernel restarts (automatically) the read() system call, then it is very probable
that my buf1 buffer will be overwritten.

What is the solution to this problem ? (To "save" the content of buf1, before the interrupted
system call is restarted.)

Thank you.

You need a function that handles EINTR only. read() returns when a signal is sent.
You do not need a signal handler. write() behaves that same way.

Code:

#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

ssize_t readfd(int fd, void *buffer, size_t bytes2read)
 {
     ssize_t readbytes = 0;
     ssize_t n=0;
 
     do {
         if ((n = read(fd, 
                       &((char *)buffer)[readbytes], 
                       bytes2read - readbytes)) == -1) 
         {
             if (errno == EINTR)
                 continue;
             else
             {
                 readbytes=-1;
                 break;
             }
         }
         if (!n) break;
             
         readbytes += n;
     } while (readbytes < bytes2read);
     return readbytes;
 }

Use something like readfd in place of a naked read() call.