Part $1$: Creating the Child Process and Executing the Command

Initialize the Shell

Print the shell prompt $($osh$>)$ to the user.

Read the user input from the command line.

Parse User Input

Tokenize the input command into an array of arguments $($args$).$

Handle edge cases where the command is empty or malformed.

Fork a Child Process

Use fork$()$ to create a new child process.

Check if fork$()$ returns a negative value $($indicating an error$),$ zero $($indicating the child process$),$ or a positive value $($indicating the parent process$).$

Execute Command in Child Process

In the child process $($pid $==0)$:

Use execvp$()$ to replace the child process image with the new command.

Handle errors in execvp$()$ by printing an error message and terminating the child process.

Wait for Child Process to Complete

In the parent process $($pid $>0)$:

Use wait$()$ to wait for the child process to complete, unless the command ends with an ampersand $($&$),$ indicating it should run in the background.

Part $2$: Providing a History Feature

Store Executed Commands

Maintain a history buffer to store the most recently executed command.

Update the history buffer each time a new command is executed.

Implement History Execution

Allow the user to execute the most recent command by entering $!!.$

If $!!$ is entered and there is no command in history, print a message indicating $"$No commands in history."

Error Handling for History

Ensure that entering $!!$ without any previous commands does not cause the shell to crash.

Part $3$: Adding Support for Input and Output Redirection

Handle Output Redirection $(>)$

Parse the command to check for the presence of the $>$ operator.

Redirect the output of the command to the specified file using dup$2().$

Handle Input Redirection $(<)$

Parse the command to check for the presence of the $<$ operator.

Redirect the input of the command from the specified file using dup$2().$

Combine Redirections

Ensure the shell can handle cases where both input and output redirections are specified.

Part $4$: Allowing Parent and Child Processes to Communicate via a Pipe

Create a Pipe

Use the pipe$()$ system call to create a pipe.

Redirect Standard Input$/$Output to Pipe

Redirect the standard output of the first command to the write end of the pipe.

Redirect the standard input of the second command to the read end of the pipe.

Execute Commands with Pipe

Ensure both commands run as separate processes and communicate through the pipe.

Additional Notes

Ensure proper error handling throughout the program to manage invalid commands, failed system calls, and edge cases.

Modularize the code by creating functions for reading input, parsing commands, handling redirections, and managing processes.

Test the shell thoroughly with various commands and scenarios to ensure robustness and reliability.

Here is the source code:

#include

#include

#define MAX$\_$LINE $80/*$ The maximum length command $*/$

int main$($void$)$

$\{$

char $*$args$[$MAX$\_$LINE$/2+1]$; $/*$ command line arguments $*/$

int should$\_$run $=1$; $/*$ flag to determine when to exit program $*/$

while $($should$\_$run$)\{$

printf$("$osh$>")$;

fflush$($stdout$)$;

$/**$

$*$ After reading user input, the steps are:

$*(1)$ fork a child process using fork$()$

$*(2)$ the child process will invoke execvp$()$

$*(3)$ parent will invoke wait$()$ unless command included &

$*/$

$\}$

return $0$;

$\}$