This assignment is meant to:

Introduce students to writing basic client$/$server programs in C using the UNIX$/$Linux platform

Provide an opportunity to write code that will become the base for projects similar to that of a simulated operating system component

Objective: Create 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 UHCL Linux server ruby or your own 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 $$convert&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 mode $($will block of course until a client opens the same fifo in 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:

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

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

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

Size of the rest of the message that includes

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$)$

Process ID

System Call Number $=1$

Number $$n$$ of parameters $=1$

Size of $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.

No need to return anything.

System Call $2$ Number to text

Process ID

System Call Number $=2$

Number $$n$$ of parameters $=1$

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

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

Return the number converted to text $(0->$ zero, $1->$ one, $2->$ two, $3->$ three, etc. assume number will be between $0$ and $9)$

System Call $3$ Text to number

Process ID

System Call Number $=3$

Number $$n$$ of parameters $=1$

Size of parameter

Actual value$($s$)$ for the $1$ parameter $($zero$,$ one, two, three, etc.$)$

Return the number $($four $->4,$ five $->5,$ etc$)$

System Call $4$ Store

Process ID

System Call Number $=4$

Number $$n$$ of parameters $=1$

Size of parameter

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

Return stored value

System Call $5$ Recall

Process ID

System Call Number $=5$

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

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

Return stored$/$recalled value

System Call $0$ Exit

Process ID

System Call Number $=0$

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

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

Return value N$/$A

System Call $-1$ Terminate

Process ID

System Call Number $=-1$

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

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

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 $($which will unblock the server from its fifo open call$)$

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 serve