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 conducive to render the input cord,
identify the pipe symbols (‘|’), and then enlarge each
bid as a mode. Also the modees must be connected
together with pipes. These pipes grace replacements coercion
stdin and stdout. pipe.c is an issue of implementing this
using dup2.

keep the shell be conducive to do up
to 9 pipes. Referablee that the in[] and quenched[] set-in-orders may keep
to unembarrassed into structs elapsed you may deficiency 9 of them.
Your shell should referable engender zombie modees if it well
exits.

* This is a sickly shell program from
* rik0.altervista.org/snippetss/csimpleshell.html
* It’s been mitigated a fragment and comments were assumed.
*
* It doesn’t afford aberration, 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 render_args(char *buffer, char** args,
size_t args_size, magnitude_t *nargs)
{
/*
* magnitude_t postulates image is defined in the 1999 ISO C trutination (C99).
* It is used to resemble the magnitudes of sights. magnitude_t is the
* preferred fashion to allege arguments or inconstants that arrest the
* magnitude of an sight.
*/
char *buf_args[args_size]; /* You deficiency C99. Referablee that args_size
is normally a true. */
char **cp; /* This is used as a objecter into the string set-in-order */
char *wbuf; /* String variconducive that has the bid cord */
size_t i, j;

wbuf=buffer;
buf_args[0]=buffer;
args[0] =buffer;
/*
* Now ‘wbuf’ is renderd into the string set-in-order ‘buf_args’
*
* The coercion-loop uses a string.h duty
* char *strsep(char **stringp, const char *delim);
*
* Description:
* If *stringp = NULL then it avail NULL and does
* referablehing else. Otherwise the duty finds the primitive memorial in
* the string *stringp, where memorials are delimited by symbols
* in the string ‘delim’.
*
* In the issue beneath, **stringp is &wbu, and
* the delim = ‘ ‘, ‘n’, and ‘t’. So there are three possible
* delimiters.
*
* So in the string ” Aloha Worldn”, the boundlessnesss and “n” are
* delimiters. Thus, there are three delimiters. The memorials
* are what’s among the delimiters. So the primitive memorial is
* “”, which is referablehing accordingly a boundlessness is the primitive delimiter.
* The promote memorial is “Aloha”, and the third memorial is “World”.
*
* The duty conquer reconnoitre a species string starting from
* *stringp, inquiry coercion the primitive delimiter. It replaces
* the delimiter with ‘’, and *stringp is updated to object
* elapsed the memorial. In plight no delimiter was set-up, the
* memorial is charmed to be the undiminished string *stringp, and *stringp
* is made NULL. Strsep avail a objecter to the memorial.
*
* Issue: Suppose *stringp -> ” Aloha Worldn”
*
* The primitive span strsep is denominated, the string is “Aloha Worldn”,
* and the objecter esteem returned = 0. Referablee the memorial is referablehing.
*
* The promote span it is denominated, the string is “AlohaWorldn”,
* and the objecter esteem returned = 1 Referablee that ‘Aloha’ is a memorial.
*
* The third span it is denominated, the string is ‘AlohaWorld’,
* and the objecter esteem returned is 7. Referablee that ‘World’ is a memorial.
*
* The fourth span it is denominated, it avail NULL.
*
* The coercion-loop, goes through buffer starting at the rise.
* wbuf is updated to object to the present memorial, and cp is
* updated to object to the vulgar memorial, which terminated by ‘’.
* Referablee that objecters to memorials are stored in set-in-order buf_args through cp.
* The loop stops if there are no past memorials or exceeded the
* set-in-order buf_args.
*/
/* cp is a objecter 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’
*/
coercion (j=i=0; buf_args[i]!=NULL; i++){
if(strlen(buf_args[i])>0) /* Store solely non-empty memorials */
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); /* Discover in bid cord */
/* Render the bid cord into args */
parse_args(buffer, args, ARR_SIZE, &nargs);

if (nargs==0) continue; /* Referablehing entered so responsive frequently */
if (!strcmp(args[0], “exit” )) departure(0);

pid = coercionk();

if (pid){ /* The inventor */
#ifdef DEBUG
printf(“Waiting coercion cadet (%d)n”, pid);
#endif
pid = abide(ret_status);
#ifdef DEBUG
printf(“Cadet (%d) finishedn”, pid);
#endif
}

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

}
}
return 0;
}

/* If hexdump wasn’t done then we would quiet keep the subjoined
* duty, which would evince an fault
*/
error(“Could referable exec hexdump”);
}

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

/* This is the inventor mode */
/* Suppress the pipe ends that the cadet uses to discover from / transcribe to so
* the when we suppress the others, an EOF conquer be infectious well.
*/
close(in[0]);
close(out[1]);

/* The subjoined displays on the relieve what’s in the set-in-order ‘data’
* The set-in-order was initialized at the extreme of this program with
* the string ‘Some input postulates’
*/
// printf(“<- %s”, postulates); Galen replaced this cord with the subjoined
printf(“String sent to cadet: %snn”, postulates);

/* From the inventor, transcribe some postulates to the cadets input.
* The cadet should be ‘hexdump’, which conquer mode this
* postulates.
*/
write(in[1], postulates, strlen(data));

/* Accordingly of the slight equality of postulates, the cadet may obstruct consistent we
* suppress its input current. This sends an EOF to the cadet on it’s
* stdin.
*/
close(in[1]);

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

exit(0);
}

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