how to distinguish the following two cases in C

Question

I am currently working on a cat program and have to distinguish the following cases:

./cat 

and

  ./cat  < file1 > file2.txt

This is the code

  while((fileFD=read(STDIN_FILENO,str,1000))!=0)// If we just execute the command cat, it will receive input from the stdin and put it in the stdout.
   {
     write(STDOUT_FILENO,str,fileFD);// Write it to the standard output
     if(fileFD==-1)
     {
     perror("error");
     exit(1);
     }
   }
     break;    

I use the parameters argv and argc to keep track of the arguments. In both cases argc =1 because anything on the right of < is not taken into account. How would you do this?

Answer 1

Given two file descriptors, one for input, one for output, the following function copies the data from the input to the output reasonably reliably.

#include <unistd.h>

/* Copy file from input file descriptor ifd to output file descriptor ofd */
extern int copy_file(int ifd, int ofd);

int copy_file(int ifd, int ofd)
{
    char buffer[65536];   // Resize to suit your requirements
    ssize_t i_bytes;
    while ((i_bytes = read(ifd, buffer, sizeof(buffer))) > 0)
    {
        ssize_t bytes_left = i_bytes;
        char *posn = buffer;
        ssize_t o_bytes;
        while ((o_bytes = write(ofd, posn, bytes_left)) > 0)
        {
            bytes_left -= o_bytes;
            posn += o_bytes;
        }
        if (o_bytes < 0)
            return -1;
    }
    if (i_bytes < 0)
        return -1;
    return 0;
}

A bare minimal test program might be:

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

…declaration or definition of file_copy()…

int main(void)
{
    int rc = EXIT_SUCCESS;
    if (copy_file(STDIN_FILENO, STDOUT_FILENO) != 0)
    {
        int errnum = errno;
        rc = EXIT_FAILURE;
        fprintf(stderr, "copy_file failed: (%d) %s\n", errnum, strerror(errnum));
    }
    return rc;
}

This correctly copies files from standard input to standard output. I've not definitively tested a 'short write'. It's a pretty rare scenario, and the most likely context is when the output file descriptor is a socket. Testing the error paths is harder, too. I called the program cf89. One test was:

$ (trap '' 13; ./cf89 < /dev/zero) | (sleep 1)
copy_file failed: (32) Broken pipe
$

The trap ignores SIGPIPE (13), so the writing blocks because nothing is reading the pipe. When the sleep exits, the writing process gets an error from the write() — because the signal is ignored — and it generates the error message.

As an aside, there are those who argue against reporting both the error number and the error message on security grounds — it tells the attacker too much about the system if they manage to trigger an error. I'm not in that camp; the attacker already knows the system type by the time they get to attacking a program such as this. It might be relevant in other contexts, such as perhaps a web server.

Answer 2

this command line:

cat < file1 > file2.txt

is simply redirecting stdin and stdout and the program needs to do nothing special.

However, if the command line were:

cat file1

Then the code needs to reopen() stdin to the file

and there may be a message to stderr if the reopen() fails

in either set of command line parameters,, all I/O would be from stdin and to stdout

Answer 3

You forgot other cases. What about pipelines, like

date | ./cat | wc

perhaps you want to test if stdin is a pseudo tty (or not). Read the tty demystified first (with termios(3)...). Then consider using isatty(3) as isatty(STDIN_FILENO) to test that. But you should provide some option to override the test. See L. Serrni's deleted answer.

BTW, you might need to use poll(2). Read Advanced Linux Programming.

The question looks like some XY problem.