Overview

[tcpcliserv]

v 1.0.0

Subject

Consider the following client server architecture:

Clients C_i send messages to two servers S₁ and S₂ through a MSQ, created beforehand by S₁.

For each message extracted from the MSQ, the servers fork a process P_i. Process P_i does the requested job, sends the result to client C_i via the MSQ, and kills itself. Client C_i displays the result.

The servers and processes P_i communicate via pipes. If there are several pending messages, the servers fork as many processes P_i as required to do parallel processing.

The messages are made of:

either one number x
or two numbers x and y
or a word in uppercase

The server S₁ extracts the messages made of one or two numbers. Process P_i computes:

x³ if the message contains one number
x² + y² if it contains two numbers

The server S₂ extracts the messages made of words. Process P_i converts the word in lowercase.

To do:

Draw a general outline of the system emphasizing communication and synchronization means.
Provide the source code in C with detailed comments.

Adaptation

As the system used to create this application handles the message queues at the kernel level, it was not possible to fully comply with the subject.

The following changes have been carried out:

Three types of clients send messages to three types of servers through three TCP/IP sockets on three different ports.

The messages are made of one integer, two integers, or a word.

Client1 and server1 deal with all types of requests on port 9877. Client2 and server2 deal with numbers on port 9878. Client3 and server3 deal with words on port 9879.

There can be as many clients as the system supports on each server.

For each message received through the socket, the server forks a new process. The process does the following job:

computes x² + y² if the message contains two numbers
computes x³ if the message contains one number
converts the word to lowercase if the message contains a word.

The results are sent by the child process to the client through the socket. A signal catches the end of the child process. A call to select synchronizes the requests.

An attempt has been made to handle accentuated characters, but it is obviously system-dependent.