C Shell打开文件并返回命令提示符

Question

I'm trying to implement the UNIX cat ">" command, to perform file1.txt > foo.txt from within my UNIX shell.

I want to take normal UNIX commands from user input and execute them via execvp (which I'm currently doing just fine).

I want to add ">" into my shell flow , but am having issues with closing the file after writing to it AND giving delegation back to the command line for continual user input. Can someone explain to me where I'm doing something silly?

I realize that in order to write to a file, I have to close standard in, open a new standard out, write the file, and then somehow close the file's stdout and re-enable the keyboard's stdout to be able to accept user commands again..

My main function, just to give you an idea:

int main(int argc, char **argv)
{           
    printf("[MYSHELL] $ ");

    while (TRUE) {
        user_input = getchar();
        switch (user_input) {
            case EOF:
                exit(-1);

            case '\n':
                printf("[MYSHELL] $ ");
                break;

            default:
                // parse input into cmd_argv - store # commands in cmd_argc
                handle_user_input();

                //determine input and execute foreground/background process
                execute_command();
        }
        background = 0;
    }
    printf("\n[MYSHELL] $ ");
    return 0;    
}

This is the basic of my function getting user input. If it finds a ">" in the cmd_argv array, it sets the output flag = 1 and removes it from the desired executable command:

// get command line input
    while ((user_input != '\n') && (buffer_characters < 50)) {
        buffer[buffer_characters++] = user_input;
        user_input = getchar();
    }

    // clear buffer
    buffer[buffer_characters] = 0x00;

    // populate cmd_argv - array of commands
    char *buffer_pointer;
    buffer_pointer = strtok(buffer, " ");

    while (buffer_pointer != NULL) { 
        cmd_argv[cmd_argc] = buffer_pointer;
        buffer_pointer = strtok(NULL, " ");

        if(strcmp(cmd_argv[cmd_argc], ">") == 0){
            cmd_argv[cmd_argc] = strtok(NULL, " ");
            output = 1;
        }

        cmd_argc++;

        if(output){
            filename = buffer_pointer; //name of file that we're going to write to.
            return;
        }        
    }

The code from execute_command driving the output functionality NOTICE THE I GOT HERE MSG. This seems to be where it's dying :

   if (output == 1){
            close(1);
            file = fopen(filename, "w");
            create_process();
            output = 0;
            printf("IT GOT HERE!!!\n");
            fclose(file);
            fopen("/dev/null", "r"); // open a new stdin that is always empty
            return 1;
        }else{
        create_process();
        return;
    }

And create_process to handle foreground and background processes

void create_process()
{
    status = 0;
    int pid = fork();
    background = 0;

    if (pid == 0) {
        // child process
        if(background) {
            printf("no background");
            fclose(stdin); // close child's stdin
            fopen("/dev/null", "r"); // open a new stdin that is always empty
            execvp(*cmd_argv,cmd_argv);

            // If an error occurs, print error and exit
            fprintf (stderr, "unknown command: %s\n", cmd_argv[0]);
            exit(1);

        }else if(output == 1){
            execvp(*cmd_argv,cmd_argv);
        } 
        else {
            execvp(*cmd_argv,cmd_argv);
            // If an error occurs, print error and exit
            fprintf (stderr, "unknown command: %s\n", cmd_argv[0]);
            exit(1);
        }
    } else {
        // parent process, waiting on child process
        if (background) {
            printf("starting background job %d\n", pid);
            jobs_list[jobs_list_size] = pid;
            jobs_list_size++;

        } else { 
            waitpid(pid, &status, 0);
        } 

        if (status != 0)
            fprintf  (stderr, "error: %s exited with status code %d\n", cmd_argv[0], status);

        return;
    }
}

Answer 1

You're approaching it wrong. You don't want to mess with the parent process's file descriptors at all , and you don't want to use C's stdio - you should be using the low-level file-descriptor based calls for this work.

After the fork() , in the child process, you should execute:

int output_fd = open(filename, O_RDONLY);
if (output_fd > -1) {
    dup2(output_fd, STDOUT_FILENO);
    close(output_fd);
} else {
    perror("open");
}

There's no need for any cleanup in the parent, since the parent's open files are left alone.