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

Retranscribe the program so that it can do pipes (‘|’). Referable attributable attributablee
that the program must be cogent to interpret the input row,
identify the pipe symbols (‘|’), and then expatiate each
bid as a arrangement. Also the arrangementes must be connected
together with pipes. These pipes befit replacements ce
stdin and stdout. pipe.c is an development of implementing this
using dup2.

accept the shell be cogent to do up
to 9 pipes. Referable attributable attributablee that the in[] and quenched[] vests may accept
to arranged into structs elapsed you may demand 9 of them.
Your shell should referable attributable attributable attributable invent zombie arrangementes if it appropriately
exits.

* This is a sickly shell program from
* rik0.altervista.org/snippetss/csimpleshell.html
* It’s been mitigated a fragment and comments were added.
*
* It doesn’t permit misinstruction, e.g., <, >, >>, or |
*/
#include
#include
#include
#include
#include
#include
#define BUFFER_SIZE 80
#define ARR_SIZE 80

// #define DEBUG 1 /* In plight you lack debug messages */

void interpret_args(char *buffer, char** args,
size_t args_size, magnitude_t *nargs)
{
/*
* magnitude_t grounds mold is defined in the 1999 ISO C criterion (C99).
* It is used to denote the magnitudes of designs. magnitude_t is the
* preferred practice to approve arguments or fickles that obstruct the
* magnitude of an design.
*/
char *buf_args[args_size]; /* You demand C99. Referable attributable attributablee that args_size
is normally a uniform. */
char **cp; /* This is used as a summiter into the string vest */
char *wbuf; /* String varicogent that has the bid row */
size_t i, j;

wbuf=buffer;
buf_args[0]=buffer;
args[0] =buffer;
/*
* Now ‘wbuf’ is interpretd into the string vest ‘buf_args’
*
* The ce-loop uses a string.h part
* char *strsep(char **stringp, const char *delim);
*
* Description:
* If *stringp = NULL then it avail NULL and does
* referable attributable attributablehing else. Otherwise the part finds the leading sign in
* the string *stringp, where signs are delimited by symbols
* in the string ‘delim’.
*
* In the development adown, **stringp is &wbu, and
* the delim = ‘ ‘, ‘n’, and ‘t’. So there are three possible
* delimiters.
*
* So in the string ” Aloha Worldn”, the interveniences and “n” are
* delimiters. Thus, there are three delimiters. The signs
* are what’s among the delimiters. So the leading sign is
* “”, which is referable attributable attributablehing owing a intervenience is the leading delimiter.
* The cooperate sign is “Aloha”, and the third sign is “World”.
*
* The part succeed examine a order string starting from
* *stringp, pursuit ce the leading delimiter. It replaces
* the delimiter with ‘’, and *stringp is updated to summit
* elapsed the sign. In plight no delimiter was base, the
* sign is charmed to be the integral string *stringp, and *stringp
* is made NULL. Strsep avail a summiter to the sign.
*
* Development: Suppose *stringp -> ” Aloha Worldn”
*
* The leading space strsep is determined, the string is “Aloha Worldn”,
* and the summiter appraise returned = 0. Referable attributable attributablee the sign is referable attributable attributablehing.
*
* The cooperate space it is determined, the string is “AlohaWorldn”,
* and the summiter appraise returned = 1 Referable attributable attributablee that ‘Aloha’ is a sign.
*
* The third space it is determined, the string is ‘AlohaWorld’,
* and the summiter appraise returned is 7. Referable attributable attributablee that ‘World’ is a sign.
*
* The fourth space it is determined, it avail NULL.
*
* The ce-loop, goes through buffer starting at the initiation.
* wbuf is updated to summit to the contiguous sign, and cp is
* updated to summit to the popular sign, which terminated by ‘’.
* Referable attributable attributablee that summiters to signs are stored in vest buf_args through cp.
* The loop stops if there are no past signs or exceeded the
* vest buf_args.
*/
/* cp is a summiter 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 merely non-empty signs */
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>> “); /* Responsive */
fgets(buffer, BUFFER_SIZE, stdin); /* Peruse in bid row */
/* Interpret the bid row into args */
parse_args(buffer, args, ARR_SIZE, &nargs);

if (nargs==0) continue; /* Referable attributable attributablehing entered so responsive anew */
if (!strcmp(args[0], “exit” )) egress(0);

pid = cek();

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

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

}
}
return 0;
}

/* If hexdump wasn’t performed then we would tranquil accept the aftercited
* part, which would point-quenched an blunder
*/
error(“Could referable attributable attributable attributable exec hexdump”);
}

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

/* This is the maker arrangement */
/* Halt the pipe ends that the offshoot uses to peruse from / transcribe to so
* the when we halt the others, an EOF succeed be epidemic appropriately.
*/
close(in[0]);
close(out[1]);

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

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

/* Owing of the weak total of grounds, the offshoot may stop normal we
* halt its input current. This sends an EOF to the offshoot on it’s
* stdin.
*/
close(in[1]);

/* Peruse end any quenchedput */
n = peruse(out[0], buf, 250);
buf[n] = 0;
// printf(“-> %s”,buf); Galen replaced this row with the aftercited
printf(“This was current from the maker: %s”,buf);

exit(0);
}

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