Objective: Create C programs that run independently and can perform simple IPC using FIFOs$/$named

pipes to pass information back and forth in a client$/$server fashion.

This assignment requires the analysis, implementation, testing and documentation of two small

programs written in C on the Linux box or virtual machine.

A server program and a client program that will be run concurrently.

Server program:

The server program will provide a simple $$Echo&store$$ service to clients that connect with it and send

it requests.

Server program will be an iterative server $($can process ONLY one client at a time$)$ and it needs to do

the following:

$$ Create a well$-$known receive FIFOs where it will read its input$/$requests from the client and

open it in READ$/$WRITE mode.

$$ Then go into an infinite loop to read requests from the clients, each request will be a

$$simulated system call$,$ each request$/$system call should include:

$1.$ Process ID of process sending$/$making the system call

$2.$ System call number $($integer or byte$)$

$3.$ Number $$n$$ of parameters in the system call $($integer or byte$)$

$4.$ Size of the rest of the message that includes

$5.$ Actual value$($s$)$ for the $$n$$ parameters indicated in $3$

As described below:

$$ System Call $1$ would be the first request sent by a new client $($connect system call$)$

$1.$ Process ID

$2.$ System Call Number $=1$

$3.$ Number $$n$$ of parameters $=1$

$4.$ Size of $5$

$5.$ Actual value$($s$)$ for the $1$ parameter $=$ the name of the client$$s specific FIFO which the

server should use to reply to that client. Server should open that client$-$specific FIFO in

WRITE mode, save the file descriptor and the pid of the client for use when replies need

to be sent to that client.

$6.$ No need to return anything.

$$ System Call $2$ Number

$1.$ Process ID

$2.$ System Call Number $=2$

$3.$ Number $$n$$ of parameters $=1$

$4.$ Size of parameter $(4$ bytes for integer$)$

$5.$ Actual value$($s$)$ for the parameter

$6.$ Return the number received

$$ System Call $3$ Text

$1.$ Process ID

$2.$ System Call Number $=3$

$3.$ Number $$n$$ of parameters $=1$

$4.$ Size of parameter

$5.$ Actual value$($s$)$ for the $1$ parameter $($a string of characters$)$

$6.$ Return the string

$$ System Call $4$ Store

$1.$ Process ID

$2.$ System Call Number $=4$

$3.$ Number $$n$$ of parameters $=1$

$7.$ Size of parameter $($integer$)$

$4.$ Actual value$($s$)$ for the $1$ parameter

$5.$ Return stored value

$$ System Call $5$ Recall

$6.$ Process ID

$7.$ System Call Number $=5$

$8.$ Number $$n$$ of parameters $=0$

$9.$ Actual value$($s$)$ for the $1$ parameter $=$ N$/$A

$10.$ Return stored$/$recalled value

$$ System Call $0$ Exit

o Process ID

o System Call Number $=0$

o Number $$n$$ of parameters $=0$

o Actual value$($s$)$ for the parameter $=$ N$/$A

o Return value N$/$A

$$ System Call $-1$ Shutdown

o Process ID

o System Call Number $=-1$

o Number $$n$$ of parameters $=0$

o Actual value$($s$)$ for the parameter $=$ N$/$A

o Return value N$/$A

Server must print to the screen a message indicating the $$system call received$,$ something like:

Client pid: $1$

System Call Requested: $3$ with $2$ parameters which are:

Param$1=$xxxx Param$2=$YYYY Result$=$XXXX

Server must reply back to the client through the client specific fifo with a reply message that should

include a result as appropriate.

If the request is the system call $0$EXIT$,$ the server program must close the client specific fifo and

continue to receive the next system call $($ready for the next client to connect$)$

When the last client terminates, i$.$e$.$ sends system call $-1,$ the server should close the well

known FIFO, delete it and terminate as well.

Client Program:

The client program will $$connect$$ to the server through the well$-$known FIFO and send requests

through it to the server, obtaining information from the user as to what $$system call to make$$ and the

corresponding values for the parameter$($s$),$ more specifically, the client program should:

$$ Acquire from the user $($through the command line or reading from the keyboard$)$ what the

client number this instance of the program will be $($i$.$e$.,$ client $1,$ client $2,$ etc.$)$ or use the actual

processid if you prefer.

$$ Open the well$-$known server$$s fifo in write mode to communicate with the server.

$$ Create the client$-$specific FIFO using an appropriate name $($e$.$g$.,./$ClientNfifo$,$ where N is the

client number and send the initial $$connect system call$$ to the server including Client number

and name of the client$-$specific FIFO.

$$ Open the client$-$specific FIFO in READ mode to be able to read replies from the server. $($This will

block the client until the server opens the client$-$specific FIFO in write mode$).$

After the client specific fifo has been opened $($server connected$),$ the client should go into a

loop where the client will ask the user what to do next? providing three choices:

o $1$ Send request to server, in this case it will ask the user for data:

$$ What sytem call?

$$ How many parameters? $($user enters $0,1,2,3,$ etc.$)$

$2$ EXIT

$3$ SHUTDOWN