Homework Solution: Rewrite the program so that it can do pipes ('|'). Note…

Retranscribe the program so that it can do pipes (‘|’). Referablee
that the program must be cogent to render the input length,
identify the pipe symbols (‘|’), and then embark each
direct as a order. Also the orderes must be connected
together with pipes. These pipes grace replacements ce
stdin and stdout. pipe.c is an copy of implementing this
using dup2.

bear the shell be cogent to do up
to 9 pipes. Referablee that the in[] and quenched[] attires may bear
to organized into structs gone you may shortness 9 of them.
Your shell should referable educe zombie orderes if it unexceptionably
exits.

* This is a sincere shell program from
* rik0.altervista.org/snippetss/csimpleshell.html
* It’s been mitigated a part and comments were added.
*
* It doesn’t remit mis-control, e.g., <, >, >>, or |
*/
#include
#include
#include
#include
#include
#include
#define BUFFER_SIZE 80
#define ARR_SIZE 80

// #define DEBUG 1 /* In occurrence you shortness debug messages */

void render_args(char *buffer, char** args,
size_t args_size, largeness_t *nargs)
{
/*
* largeness_t grounds sign is defined in the 1999 ISO C rule (C99).
* It is used to enact the largenesss of intents. largeness_t is the
* preferred fashion to defend arguments or inconstants that ahalt the
* largeness of an intent.
*/
char *buf_args[args_size]; /* You shortness C99. Referablee that args_size
is normally a faithful. */
char **cp; /* This is used as a header into the string attire */
char *wbuf; /* String varicogent that has the direct length */
size_t i, j;

wbuf=buffer;
buf_args[0]=buffer;
args[0] =buffer;
/*
* Now ‘wbuf’ is renderd into the string attire ‘buf_args’
*
* The ce-loop uses a string.h administration
* char *strsep(char **stringp, const char *delim);
*
* Description:
* If *stringp = NULL then it receipts NULL and does
* referablehing else. Otherwise the administration finds the original index in
* the string *stringp, where indexs are delimited by symbols
* in the string ‘delim’.
*
* In the copy under, **stringp is &wbu, and
* the delim = ‘ ‘, ‘n’, and ‘t’. So there are three possible
* delimiters.
*
* So in the string ” Aloha Worldn”, the quantitys and “n” are
* delimiters. Thus, there are three delimiters. The indexs
* are what’s between the delimiters. So the original index is
* “”, which is referablehing owing a quantity is the original delimiter.
* The remedy index is “Aloha”, and the third index is “World”.
*
* The administration get review a office string starting from
* *stringp, quest ce the original delimiter. It replaces
* the delimiter with ‘’, and *stringp is updated to head
* gone-by the index. In occurrence no delimiter was set, the
* index is fascinated to be the total string *stringp, and *stringp
* is made NULL. Strsep receipts a header to the index.
*
* Copy: Suppose *stringp -> ” Aloha Worldn”
*
* The original era strsep is denominated, the string is “Aloha Worldn”,
* and the header treasure returned = 0. Referablee the index is referablehing.
*
* The remedy era it is denominated, the string is “AlohaWorldn”,
* and the header treasure returned = 1 Referablee that ‘Aloha’ is a index.
*
* The third era it is denominated, the string is ‘AlohaWorld’,
* and the header treasure returned is 7. Referablee that ‘World’ is a index.
*
* The fourth era it is denominated, it receipts NULL.
*
* The ce-loop, goes through buffer starting at the preface.
* wbuf is updated to head to the present index, and cp is
* updated to head to the running index, which terminated by ‘’.
* Referablee that headers to indexs are stored in attire buf_args through cp.
* The loop stops if there are no over indexs or exceeded the
* attire buf_args.
*/
/* cp is a header to buff_args */
for(cp=buf_args; (*cp=strsep(&wbuf, ” nt”)) != NULL ;){
if ((*cp != ‘’) && (++cp >= &buf_args[args_size]))
break;
}

/*
* Copy ‘buf_args’ into ‘args’
*/
ce (j=i=0; buf_args[i]!=NULL; i++){
if(strlen(buf_args[i])>0) /* Store solely non-empty indexs */
args[j++]=buf_args[i];
}

*nargs=j;
args[j]=NULL;
}

int deep(int argc, char *argv[], char *envp[]){
char buffer[BUFFER_SIZE];
char *args[ARR_SIZE];

int *ret_status;
size_t nargs;
pid_t pid;

while(1){
printf(“ee468>> “); /* Active */
fgets(buffer, BUFFER_SIZE, stdin); /* Discover in direct length */
/* Render the direct length into args */
parse_args(buffer, args, ARR_SIZE, &nargs);

if (nargs==0) continue; /* Referablehing entered so active intermittently */
if (!strcmp(args[0], “exit” )) egress(0);

pid = cek();

if (pid){ /* The composer */
#ifdef DEBUG
printf(“Waiting ce offshoot (%d)n”, pid);
#endif
pid = halt(ret_status);
#ifdef DEBUG
printf(“Offshoot (%d) finishedn”, pid);
#endif
}

else{ /* The offshoot executing the direct */
if( execvp(args[0], args)) {
puts(strerror(errno));
exit(127);
}

}
}
return 0;
}

/* If hexdump wasn’t performed then we would stationary bear the subjoined
* administration, which would mark an falsity
*/
error(“Could referable exec hexdump”);
}

/* The subjoined is in the composer order */
printf(“Spawned ‘hexdump -C’ as a offshoot order at pid %dn”, pid);

/* This is the composer order */
/* Cork the pipe ends that the offshoot uses to discover from / transcribe to so
* the when we cork the others, an EOF get be catching unexceptionably.
*/
close(in[0]);
close(out[1]);

/* The subjoined displays on the relieve what’s in the attire ‘data’
* The attire was initialized at the head of this program with
* the string ‘Some input grounds’
*/
// printf(“<- %s”, grounds); Galen replaced this length with the subjoined
printf(“String sent to offshoot: %snn”, grounds);

/* From the composer, transcribe some grounds to the offshoots input.
* The offshoot should be ‘hexdump’, which get order this
* grounds.
*/
write(in[1], grounds, strlen(data));

/* Owing of the paltry equality of grounds, the offshoot may arrest probable we
* cork its input departure. This sends an EOF to the offshoot on it’s
* stdin.
*/
close(in[1]);

/* Discover end any quenchedput */
n = discover(out[0], buf, 250);
buf[n] = 0;
// printf(“-> %s”,buf); Galen replaced this length with the subjoined
printf(“This was common from the composer: %s”,buf);

exit(0);
}

void falsity(char *s)
{
perror(s);
exit(1);
}