Implementing shell in C and need help handling input/output redirection

You have way too many file descriptors open after your redirection. Let’s dissect the two paragraphs:

if (in) { //if '<' char was found in string inputted by user
    fd = open(input, O_RDONLY, 0);
    dup2(fd, STDIN_FILENO);
    in = 0;
    current_in = dup(0);  // Fix for symmetry with second paragraph

if (out) { //if '>' was found in string inputted by user
    fd = creat(output, 0644);
    dup2(fd, STDOUT_FILENO);
    out = 0;
    current_out = dup(1);

I’m going to be charitable and ignore the fact that you are ignoring errors. However, you will need to error check your system calls.

In the first paragraph, you open a file and capture the file descriptor (it might well be 3) in the variable fd. You then duplicate the file descriptor over standard input (STDIN_FILENO). Note, though, that file descriptor 3 is still open. Then you do a dup(0) (which, for consistency, should be STDIN_FILENO), getting another file descriptor, perhaps 4. So you have file descriptors 0, 3 and 4 pointing at the same file (and, indeed, the same open file description — noting that an open file description is different from an open file descriptor). If your intention with current_in was to preserve the (parent) shell’s standard input, you have to do that dup() before you do the dup2() that overwrites the output. However, you would be better off not altering the parent shell’s file descriptors; it is less overhead than re-duplicating the file descriptors.

Then you more or less repeat the process in the second paragraph, first overwriting the only record of file descriptor 3 being open with the fd = creat(...) call but obtaining a new descriptor, perhaps 5, then duplicating that over standard output. You then do a dup(1), yielding another file descriptor, perhaps 6.

So, you have stdin and stdout of the main shell redirected to the files (and no way of reinstating those to the original values). Your first problem, therefore, is that you are doing the redirection before you fork(); you should be doing it after the fork() — though when you get to piping between processes, you will need to create pipes before forking.

Your second problem is that you need to close a plethora of file descriptors, one of which you no longer have a reference for.

So, you might need:

if ((pid = fork()) < 0)
else if (pid == 0)
    /* Be childish */
    if (in)
        int fd0 = open(input, O_RDONLY);
        dup2(fd0, STDIN_FILENO);

    if (out)
        int fd1 = creat(output , 0644) ;
        dup2(fd1, STDOUT_FILENO);
    } the child has stdin coming from the input file, 
    ...stdout going to the output file, and no extra files open. is safe to execute the command to be executed.
    execve(cmd[0], cmd, env);   // Or your preferred alternative
    fprintf(stderr, "Failed to exec %s\n", cmd[0]);
    /* Be parental */
    ...wait for child to die, etc...

Before you do any of this, you should ensure that you’ve already flushed the shell’s standard I/O channels, probably by using fflush(0), so that if the forked child writes to standard error because of a problem, there is no extraneous duplicated output.

Also note that the various open() calls should be error-checked.

Leave a Comment