C implement like cat with robustness and efficiency

Question

I want to learn to implement the function like cat, which just take input from a file and print to stdout.

But I am not sure the line of write() is robust in all cases as it may write less than n . But I am not able to create a test case to make this case happen. How to make a test case so that it can result in less than n char be written? Also, how to modify the code accordingly to make the program robust (for this case, but also for other cases that I have not described)?

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>

int main(int argc, char *argv[]) {
    const char *pathname = argv[1];
    int fd;
    if((fd = open(pathname, O_RDONLY)) == -1) {
        perror("open");
        return 1;
    }
#define BUF_SIZE 1024
    char buf[BUF_SIZE];
    ssize_t n;
    while((n = read(fd, &buf, BUF_SIZE)) > 0) {
        if(write(STDOUT_FILENO, &buf, n) == -1) {
            perror("write");
            return 1;
        }
    }
    if(n == -1) {
        perror("read");
        return 1;
    }
    if(close(fd) == -1) {
        perror("close");
        return 1;
    }
    return 0;
}

EDIT: I fixed the write() bug in the previous code based on the pipe-blocking test case mentioned by Armali. Can anybody check whether there are any other bugs?

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>

int main(int argc, char *argv[]) {
    const char *pathname = argv[1];
    int fd;
    if((fd = open(pathname, O_RDONLY)) == -1) {
        perror("open");
        return 1;
    }
#define BUF_SIZE 2*65536
    char buf[BUF_SIZE];
    ssize_t r_n;
    while((r_n = read(fd, &buf, BUF_SIZE)) > 0) {
        ssize_t w_n;
        int i = 0;
        while((w_n = write(STDOUT_FILENO, buf+i, r_n)) < r_n) {
            if(w_n == -1) {
                perror("write");
                return 1;
            }
            r_n -= w_n;
            i += w_n;
        }
    }
    if(r_n == -1) {
        perror("read");
        return 1;
    }
    if(close(fd) == -1) {
        perror("close");
        return 1;
    }
    return 0;
}

Answer 1

How to make a test case so that it can result in less than n char be written?

Depending on the system, this hasn't to be difficult. man 2 write tells:

… partial writes can occur for various reasons; for example, because there was
insufficient space on the disk device to write all of the requested bytes, or because
a blocked write() to a socket, pipe, or similar was interrupted by a signal …

Let's focus on pipe writes, which block if the pipe buffer is full. This example targets Linux; the numbers may well be different on other systems. man 7 pipe tells about the Pipe capacity :

Since Linux 2.6.11, the pipe capacity is 16 pages (i.e., 65,536 bytes in a system with
a page size of 4096 bytes).

To make use of this for the sake of a test case, we have to increase your BUF_SIZE to a greater value, say 1024*128 . Then we can conduct the experiment:

~$ dd count=256 </dev/zero >zeros
256+0 records in
256+0 records out
131072 bytes (131 kB, 128 KiB) copied, 0.00357324 s, 36.7 MB/s
~$ strace -ewrite ./a.out zeros|(sleep 9; dd)
write(1, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"..., 131072^Z
[1]+  Stopped                 strace -ewrite ./a.out zeros | ( sleep 9; dd )
~$ fg
strace -ewrite ./a.out zeros | ( sleep 9; dd )
) = 65536
--- SIGCONT {si_signo=SIGCONT, si_code=SI_USER, si_pid=482, si_uid=2001} ---
+++ exited with 0 +++
128+0 records in
128+0 records out
65536 bytes (66 kB, 64 KiB) copied, 0.00546081 s, 12.0 MB/s

• First we prepare a file of 128 KiB.
• Then we run the program with strace -ewrite to see the write operation; we pipe its output to (sleep 9; dd) to delay the reading. During this delay, we raise a STOP signal by pressing Ctrl-Z.
• Finally, we continue the program with fg . Now we see that the write operation, which has been called with count 131072 , returns only 65536 bytes written.

Also, how to modify the code accordingly to make the program robust (for this case, but also for other cases that I have not described)?

For this case and similar cases, you'd do as David C. Rankin wrote:

There you would just loop until n bytes had been written keeping track of the number written with each call.

I can't say how to make a program robust for undescribed cases other than checking the returned values from all called library functions of which you can't be sure that they succeed.