Help Needed UNIX Shell and History Feature This project cons

Help Needed!

UNIX Shell and History Feature
This project consists of designing a C program to serve as a shell interface
that accepts user commands and then executes each command in a separate
process. This project can be completed on any Linux,
UNIX,orMacOS X system.
A shell interface gives the user a prompt, after which the next command
is entered. The example below illustrates the prompt
osh> and the user’s
next command:
cat prog.c. (This command displays the le prog.c on the
terminal using the
UNIX cat command.)
osh> cat prog.c
One technique for implementing a shell interface is to have the parent process
rst read what the user enters on the command line (in this case,
cat
prog.c), and then create a separate child process that performs the command.
Unless otherwise specied, the parent process waits for the child to exit
before continuing. This is similar in functionality to the new process creation
illustrated in Figure 3.10. However,
UNIX shells typically also allow the child
process to run in the background, or concurrently. To accomplish this, we add
an ampersand (&) at the end of the command. Thus, if we rewrite the above
command as
osh> cat prog.c &
the parent and child processes will run concurrently.
The separate child process is created using the
fork() system call, and the
user’s command is executed using one of the system calls in the
exec() family

A C program that provides the general operations of a command-line shell
is supplied in Figure 3.36. The
main() function presents the prompt osh->
and outlines the steps to be taken after input from the user has been read. The
main() function continually loops as long as should run equals 1; when the
user enters
exit at the prompt, your program will set should run to 0 and
terminate.
This project is organized into two parts: (1) creating the child process and
executing the command in the child, and (2) modifying the shell to allow a
history feature.

#include <stdio.h>
#include <unistd.h>
#define MAXLINE 80 /* The maximum length command */
int main(void)
{
char *args[MAXLINE/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) if command included &, parent will invoke wait()
*/
return 0;
}

Part I — Creating a Child Process
The rst task is to modify the
main() function in the above program so that a child
process is forked and executes the command specied by the user. This will
require parsing what the user has entered into separate tokens and storing the
tokens in an array of character strings (
args in the above program. For example, if the
user enters the command
ps -ael at the osh> prompt, the values stored in the
args array are:
args[0] = \"ps\"
args[1] = \"-ael\"
args[2] = NULL
This args array will be passed to the execvp() function, which has the
following prototype:
execvp(char *command, char *params[]);
Here, command represents the command to be performed and params stores the
parameters to this command. For this project, the
execvp() function should be invoked as
execvp(args[0], args). Be sure to check whether the user
included an & to determine whether or not the parent process is to wait for the
child to exit.

Part II —Creating a History Feature
The next task is to modify the shell interface program so that it provides
a history feature that allows the user to access the most recently entered
commands. The user will be able to access up to 10 commands by using the
feature. The commands will be consecutively numbered starting at 1, and
the numbering will continue past 10. For example, if the user has entered 35
commands, the 10 most recent commands will be numbered 26 to 35.
The user will be able to list the command history by entering the command
history
at the osh> prompt. As an example, assume that the history consists of the
commands (from most to least recent):
ps, ls -l, top, cal, who, date
The command history will output:
6ps
5ls-l
4 top
3 cal
2 who
1 date
Your program should support two techniques for retrieving commands
from the command history:
1. When the user enters
!!, the most recent command in the history is
executed.
2. When the user enters a single
! followed by an integer N,the Nth
command in the history is executed.
Continuing our example from above, if the user enters !!,the ps command
will be performed; if the user enters !3, the command cal will be executed.
Any command executed in this fashion should be echoed on the user’s screen.
The command should also be placed in the history buffer as the next command.
The program should also manage basic error handling. If there are
no commands in the history, entering !! should result in a message “No commands in history.
” If there is no command corresponding to the number
entered with the single !, the program should output \"No such command in
history.

Solution

#include<stdio.h>

#include <stdlib.h>

#include <time.h>

#include <string.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <signal.h>

#include <limits.h>

#include <errno.h>

#define CMD_HISTORY_SIZE 10

static char * cmd_history[CMD_HISTORY_SIZE];

static int cmd_history_count = 0;

static void exec_cmd(const char * line)

{

       char * CMD = strdup(line);

       char *params[10];

       int argc = 0;

      

       params[argc++] = strtok(CMD, \" \");

       while(params[argc-1] != NULL){   

              params[argc++] = strtok(NULL, \" \");

       }

       argc--;

       int background = 0;

       if(strcmp(params[argc-1], \"&\") == 0){

              background = 1;

              params[--argc] = NULL;    

       }

       int fd[2] = {-1, -1};     

       while(argc >= 3){

             

              if(strcmp(params[argc-2], \">\") == 0){

                    

                     fd[1] = open(params[argc-1], O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP|S_IWGRP);

                     if(fd[1] == -1){

                           perror(\"open\");

                           free(CMD);

                           return;

                     }

                    

                     params[argc-2] = NULL;

                     argc -= 2;

              }else if(strcmp(params[argc-2], \"<\") == 0){ // input

                     fd[0] = open(params[argc-1], O_RDONLY);

                     if(fd[0] == -1){

                           perror(\"open\");

                           free(CMD);

                           return;

                     }

                     params[argc-2] = NULL;

                     argc -= 2;

              }else{

                     break;

              }

       }

       int status;

       pid_t pid = fork();

       switch(pid){

              case -1:     

                     perror(\"fork\");

                     break;

              case 0:       // child

                     if(fd[0] != -1){    

                           if(dup2(fd[0], STDIN_FILENO) != STDIN_FILENO){

                                  perror(\"dup2\");

                                  exit(1);

                           }

                     }

                     if(fd[1] != -1){    

                           if(dup2(fd[1], STDOUT_FILENO) != STDOUT_FILENO){

                                  perror(\"dup2\");

                                  exit(1);

                           }

                     }

                     execvp(params[0], params);

                     perror(\"execvp\");

                     exit(0);

              default: // parent

                     close(fd[0]);close(fd[1]);

                     if(!background)

                           waitpid(pid, &status, 0);

                     break;

       }

       free(CMD);

}

static void add_to_history(const char * cmd){

       if(cmd_history_count == (CMD_HISTORY_SIZE-1)){

              int i;

              free(cmd_history[0]);     

             

              for(i=1; i < cmd_history_count; i++)

                     cmd_history[i-1] = cmd_history[i];

              cmd_history_count--;

       }

       cmd_history[cmd_history_count++] = strdup(cmd);

}

static void run_from_history(const char * cmd){

       int index = 0;

       if(cmd_history_count == 0){

              printf(\"No commands in history\ \");

              return ;

       }

       if(cmd[1] == \'!\')

              index = cmd_history_count-1;

       else{

              index = atoi(&cmd[1]) - 1;

              if((index < 0) || (index > cmd_history_count)){

                     fprintf(stderr, \"No such command in history.\ \");

                     return;

              }

       }

       printf(\"%s\ \", cmd);

       exec_cmd(cmd_history[index]);    

}

static void list_history(){

       int i;

       for(i=cmd_history_count-1; i >=0 ; i--){

              printf(\"%i %s\ \", i+1, cmd_history[i]);

       }

}

static void signal_handler(const int rc){

       switch(rc){

              case SIGTERM:

              case SIGINT:

                     break;

             

              case SIGCHLD:

             

                    

                     while (waitpid(-1, NULL, WNOHANG) > 0);

                     break;

       }

}

int main(int argc, char *argv[]){

       // sinyalleri yakala

       struct sigaction act, act_old;

       act.sa_handler = signal_handler;

       act.sa_flags = 0;

       sigemptyset(&act.sa_mask);

       if(    (sigaction(SIGINT, &act, &act_old) == -1) ||

              (sigaction(SIGCHLD, &act, &act_old) == -1)){

              perror(\"signal\");

              return 1;

       }

      

       size_t line_size = 100;

       char * line = (char*) malloc(sizeof(char)*line_size);

       if(line == NULL){   

              perror(\"malloc\");

              return 1;    

       }

       int inter = 0;

       while(1){

              if(!inter)

                     printf(\"mysh > \");

              if(getline(&line, &line_size, stdin) == -1){   

                     if(errno == EINTR){

                            clearerr(stdin);

                           inter = 1;   

                           continue;

                     }

                     perror(\"getline\");

                     break;

              }

              inter = 0;

              int line_len = strlen(line);

              if(line_len == 1){  

                     continue;

              }

              line[line_len-1] = \'\\0\';

             

              if(strcmp(line, \"exit\") == 0){

                     break;

              }else if(strcmp(line, \"history\") == 0){

                     list_history();

              }else if(line[0] == \'!\'){

                     run_from_history(line);

              }else{

                     add_to_history(line);

                     exec_cmd(line);

              }

       }

       free(line);

       return 0;

}

#include<stdio.h>
	#include <stdlib.h>
	#include <time.h>
	#include <string.h>
	#include <sys/wait.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <signal.h>
	#include <limits.h>
	#include <errno.h>
	#define CMD_HISTORY_SIZE 10
	static char * cmd_history[CMD_HISTORY_SIZE];
	static int cmd_history_count = 0;
	static void exec_cmd(const char * line)
	{
	char * CMD = strdup(line);
	char *params[10];
	int argc = 0;
	params[argc++] = strtok(CMD, \" \");
	while(params[argc-1] != NULL){
	params[argc++] = strtok(NULL, \" \");
	}
	argc--;
	int background = 0;
	if(strcmp(params[argc-1], \"&\") == 0){
	background = 1;
	params[--argc] = NULL;
	}
	int fd[2] = {-1, -1};
	while(argc >= 3){
	if(strcmp(params[argc-2], \">\") == 0){
	fd[1] = open(params[argc-1], O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP|S_IWGRP);
	if(fd[1] == -1){
	perror(\"open\");
	free(CMD);
	return;
	}
	params[argc-2] = NULL;
	argc -= 2;
	}else if(strcmp(params[argc-2], \"<\") == 0){ // input
	fd[0] = open(params[argc-1], O_RDONLY);
	if(fd[0] == -1){
	perror(\"open\");
	free(CMD);
	return;
	}
	params[argc-2] = NULL;
	argc -= 2;
	}else{
	break;
	}
	}
	int status;
	pid_t pid = fork();
	switch(pid){
	case -1:
	perror(\"fork\");
	break;
	case 0:       // child
	if(fd[0] != -1){
	if(dup2(fd[0], STDIN_FILENO) != STDIN_FILENO){
	perror(\"dup2\");
	exit(1);
	}
	}
	if(fd[1] != -1){
	if(dup2(fd[1], STDOUT_FILENO) != STDOUT_FILENO){
	perror(\"dup2\");
	exit(1);
	}
	}
	execvp(params[0], params);
	perror(\"execvp\");
	exit(0);
	default: // parent
	close(fd[0]);close(fd[1]);
	if(!background)
	waitpid(pid, &status, 0);
	break;
	}
	free(CMD);
	}
	static void add_to_history(const char * cmd){
	if(cmd_history_count == (CMD_HISTORY_SIZE-1)){
	int i;
	free(cmd_history[0]);
	for(i=1; i < cmd_history_count; i++)
	cmd_history[i-1] = cmd_history[i];
	cmd_history_count--;
	}
	cmd_history[cmd_history_count++] = strdup(cmd);
	}
	static void run_from_history(const char * cmd){
	int index = 0;
	if(cmd_history_count == 0){
	printf(\"No commands in history\ \");
	return ;
	}
	if(cmd[1] == \'!\')
	index = cmd_history_count-1;
	else{
	index = atoi(&cmd[1]) - 1;
	if((index < 0) || (index > cmd_history_count)){
	fprintf(stderr, \"No such command in history.\ \");
	return;
	}
	}
	printf(\"%s\ \", cmd);
	exec_cmd(cmd_history[index]);
	}
	static void list_history(){
	int i;
	for(i=cmd_history_count-1; i >=0 ; i--){
	printf(\"%i %s\ \", i+1, cmd_history[i]);
	}
	}
	static void signal_handler(const int rc){
	switch(rc){
	case SIGTERM:
	case SIGINT:
	break;
	case SIGCHLD:
	while (waitpid(-1, NULL, WNOHANG) > 0);
	break;
	}
	}
	int main(int argc, char *argv[]){
	// sinyalleri yakala
	struct sigaction act, act_old;
	act.sa_handler = signal_handler;
	act.sa_flags = 0;
	sigemptyset(&act.sa_mask);
	if(    (sigaction(SIGINT, &act, &act_old) == -1) ||
	(sigaction(SIGCHLD, &act, &act_old) == -1)){
	perror(\"signal\");
	return 1;
	}
	size_t line_size = 100;
	char * line = (char*) malloc(sizeof(char)*line_size);
	if(line == NULL){
	perror(\"malloc\");
	return 1;
	}
	int inter = 0;
	while(1){
	if(!inter)
	printf(\"mysh > \");
	if(getline(&line, &line_size, stdin) == -1){
	if(errno == EINTR){
	clearerr(stdin);
	inter = 1;
	continue;
	}
	perror(\"getline\");
	break;
	}
	inter = 0;
	int line_len = strlen(line);
	if(line_len == 1){
	continue;
	}
	line[line_len-1] = \'\\0\';
	if(strcmp(line, \"exit\") == 0){
	break;
	}else if(strcmp(line, \"history\") == 0){
	list_history();
	}else if(line[0] == \'!\'){
	run_from_history(line);
	}else{
	add_to_history(line);
	exec_cmd(line);
	}
	}
	free(line);
	return 0;
	}