The beginning of the main function can be familiar from the client. The communication endpoint is created on the server side the same way as in the client side.

struct sockaddr_in szerver, kliens;
            memset ((void *) &szerver, 0, sizeof (szerver));
            szerver.sin_family = AF_INET; inet_aton ("127.0.0.1",
            &(szerver.sin_addr)); szerver.sin_port = htons
            (SZERVER_PORT);

The next part of the beginning of the main function is the setting of the POSIX signal handling. Some lines below, we can see that the SIGCHLD signal will be processed by the signal handler function called zombi_elharito.

struct sigaction sa; sa.sa_handler =
            zombi_elharito; sigemptyset (&sa.sa_mask); sa.sa_flags =
            SA_RESTART;

The variable osztott_memoria is used for identifying a shared memory segment that is pointed by the pointer osztott_memoria_terulet. It is interested to note that this pointer will point outside the process's address space and all the processes that attach the shared memory segment will access it.

int osztott_memoria; int
            *osztott_memoria_terulet;

In the remaining part of the beginning of the main function,

int kapu_figyelo, kapcsolat, kliensm,
            sockoptval = 1, s, gyermekem_pid, szemafor; fd_set kapu_figyelok;
            struct timeval timeout;

the kapu_figyelo is the server socket and the kapcsolat is a client socket. The kliensm is a technical variable that contains the size of client's sockaddr_in structure. The sockoptval is also a technical variable that helps to test the server. The calling the function

            setsockopt (kapu_figyelo, SOL_SOCKET, SO_REUSEADDR, NULL, 0);
            

allows us to restart the server immediately without waiting for the freeing of the server socket by the operating system.

 vartam... ^C [norbert@matrica halozati]$ ./szerver
            bind: Address already in use 

The gyermekem_pid variable contains the returned value of the fork system call that returns 0 in the child and returns the child's PID in the parent. The szemafor variable, like in the case of the shered memory, is used for identifying the IPC resource. The kapu_figyelok and timeout variables will be discussed later together with the fork system call.

The socket is created the same way as in the client.

if ((kapu_figyelo = socket (PF_INET,
            SOCK_STREAM, IPPROTO_TCP)) == -1) { perror ("socket"); exit
            (EXIT_FAILURE); }

We connect the socket to the previously specified (127.0.0.1:2012) address using the bind system call.

if (bind (kapu_figyelo, (struct
            sockaddr *) &szerver, sizeof (szerver)) == -1) { perror
            ("bind"); exit (EXIT_FAILURE); }

Then we start to listen for incoming client connect requests

if (listen (kapu_figyelo,
            SZERVER_SOR_MERET) == -1) { perror ("listen"); exit
            (EXIT_FAILURE); }

and in general we can start processing the client's request

if ((kapcsolat = accept
            (kapu_figyelo, (struct sockaddr *) &kliens, (socklen_t *)
            & kliensm)) == -1)

but now we are going to use a more sophisticated approach to handle clients. Because calling the accept will be embedded in the calling select.

We set server socket to non-blocking. First, we read the socket descriptor flags then set it.

fcntl (kapu_figyelo, F_SETFL, fcntl
            (kapu_figyelo, F_GETFL) | O_NONBLOCK);

The semaphore array is created by the semget system call, where the first argument is a key to identify the allocated shared memory segment. It is generated by the ftok library function using the name of actual directory and a magic number 42 (see the man page man 3 ftok).

if ((szemafor = semget (ftok (".",
            42), 1, IPC_CREAT | S_IRUSR | S_IWUSR)) == -1) { perror
            ("semget"); exit (EXIT_FAILURE); }

The second argument of semget is the number of the semaphores in the array to be created and that number is equal to 1 now. It is enough because the mutual exclusion can be achieved using only one semaphore. The third argument sets permissions on the semaphore to be created, these are set in the same way as the ones used in file handling. The properties of the created semaphore can be seen using the command ipcs:

nbatfai@morse:~$ ipcs ------ Shared Memory Segments
            -------- key shmid owner perms bytes nattch status 0x2c0003f5
            32769 nbatfai 600 8 16 ------ Semaphore Arrays -------- key semid
            owner perms nsems 0x2a0003f5 294921 nbatfai 600 1 ------ Message
            Queues -------- key msqid owner perms used-bytes messages

This screen snippet shows that there are 16 serving processes that attach the shared memory segment with size of 8 (2*sizeof(int)) bytes.

We set the first and now the only element of the semaphore array identified by szemafor to 1. This means that the semaphore is open.

if (semctl (szemafor, 0, SETVAL, 1))
            { perror ("semctl"); exit (EXIT_FAILURE); }

Similarly, we create the shared memory. The only one difference is in the second argument of the system call, because in this case it denotes the size of memory segment to be allocated.

if ((osztott_memoria = shmget (ftok
            (".", 44), 2*sizeof(int), IPC_CREAT | S_IRUSR | S_IWUSR)) == -1) {
            perror ("shmget"); exit (EXIT_FAILURE); }

We attach the shared memory segment

if ((osztott_memoria_terulet = (int
            *)shmat (osztott_memoria, NULL, 0)) < 0) { perror ("shmat");
            exit (EXIT_FAILURE); } *osztott_memoria_terulet = 42;
            *(osztott_memoria_terulet+1) = 0;

it is necessary because the forked child processes will inherit the attached shared memory segment as we can see it in the manual page man 2 shmat:

After a fork(2) the child inherits the attached shared
            memory segments. After an execve(2) all attached shared memory
            segments are detached from the process. Upon _exit(2) all attached
            shared memory segments are detached from the process.

Finally, the next line assigns the previously created sigaction sa structure to the handling of the SIGCHLD signal.

sigaction (SIGCHLD, &sa,
            NULL);

[norbert@matrica halozati]$ ps -p `echo $(pgrep -u
              norbert szerver)`|tee zombik| wc 30 178 1388 [norbert@matrica
              halozati]$ more zombik PID TTY STAT TIME COMMAND 12885 pts/2 S+
              0:00 ./szerver 12892 pts/2 Z+ 0:00 [szerver] <defunct>
              12893 pts/2 Z+ 0:00 [szerver] <defunct> 12894 pts/2 Z+
              0:00 [szerver] <defunct> 12895 pts/2 Z+ 0:00 [szerver]
              <defunct> 12897 pts/2 Z+ 0:00 [szerver] <defunct>
              12899 pts/2 Z+ 0:00 [szerver] <defunct>

Let's see now the multiplexing in the code. During multiplexing we usually use sets of file descriptors. Now first, we clear the set kapu_figyelok then add the server socket to it using the FD_SET macro.

FD_ZERO (&kapu_figyelok); for
            (;;) { FD_SET (kapu_figyelo, &kapu_figyelok);

The members of the structure called timeval may already be known from the manual page man 2 select:

The timeout The time structures involved are defined in
            <sys/time.h> and look like struct timeval { long tv_sec; /*
            seconds */ long tv_usec; /* microseconds */ };

According to these settings, the timeout is equal to 3 seconds and 0 microseconds, The select system call will return periodically after this timeout has expired.

timeout.tv_sec = 3; timeout.tv_usec =
            0; if ((s = select (kapu_figyelo + 1, &kapu_figyelok, NULL,
            NULL, &timeout)) == -1)

We can also see the arguments of the select in the manual page man 2 select:

int select(int nfds, fd_set *readfds, fd_set *writefds,
            fd_set *exceptfds, struct timeval *timeout);

from where only the first file descriptor set will be used effectively because we want to multiplex the incoming client connections only and all the clients' requests will be handled by separate processes. In accordance with this, we assign the kapu_figyelok actual parameter for the readfds formal parameter. As described in the manual page for select the value of nfds must be set to maximum file descriptor plus one.

The select may return errors for several reasons. Errors are indicated by returning -1, to get the exact error we have to check the value of errno.

If the select returns 0 it means that nothing important had happened before the timeout expired.

if ((s = select (kapu_figyelo + 1,
            &kapu_figyelok, NULL, NULL, &timeout)) == -1) { // perror
            ("select"); // Interrupted system call/ EINTR - SIGCHLD // exit
            (EXIT_FAILURE); } else if (!s) { printf ("vartam...\n"); fflush
            (stdout); }

A non-negative and non-zero value are more interesting values, because this value is the number of file descriptors that are ready to be read from or written to. In our case, to be more precise, to read from the server socket. But as a defensive programming technique we check that whether the server socket is listed in the readfds set using the FD_ISSET macro:

else { if (FD_ISSET (kapu_figyelo,
            &kapu_figyelok)) {

Here, we are already sure that accept will not be blocked.

if ((kapcsolat = accept
            (kapu_figyelo, (struct sockaddr *) &kliens, (socklen_t *)
            & kliensm)) == -1) { perror ("accept"); exit (EXIT_FAILURE);
            }

then after printing some debug messages we fork a child process

printf (" <-> %s:%d\n",
            inet_ntoa (kliens.sin_addr), ntohs (kliens.sin_port)); if
            ((gyermekem_pid = fork ()) == 0) {

The child process

if ((gyermekem_pid = fork ()) == 0) {
            close (kapu_figyelo); if (kiszolgal (kapcsolat, szemafor,
            osztott_memoria_terulet) == -1) { perror ("kiszolgal"); } close
            (kapcsolat); exit (EXIT_SUCCESS); }

closes the server socket and starts to serve the client through the client socket. Finally, after the client's request has been served by the kiszolgal handler function the child process closes the client socket as well and exits.

The parent process

else if (gyermekem_pid > 0) { //
            wait(&statusz); e miatt kezeljuk a SIGCHLD jelet, // l. a
            Zombik fejezetet (PP)! // http://www.inf.unideb.hu/~nbatfai/#pp
            close (kapcsolat); }

closes the client socket and goes back immediately to wait for the next client connection requests.

The client handler function kiszolgal gets three arguments. These are the file descriptor of client socket, the identifier of the semaphore array and a pointer to the attached memory segment.

int kiszolgal (int kliens, int
            szemafor, int *osztott_memoria_terulet) {

The other variables are technical, for example the buffer is an internal puffer used by the reentrant function like ctime_r.

char buffer[CTIME_BUFFER_MERET] = "";
            time_t t = time (NULL); char *ts = ctime_r (&t, buffer); char
            buffer2[256] = ""; int ertek, nkliens;

It is much more interesting to create the two sembuf data structures that will control the semaphore operations.

struct sembuf zar, nyit; zar.sem_num
            = 0; zar.sem_op = -1; zar.sem_flg= SEM_UNDO; nyit.sem_num = 0;
            nyit.sem_op = 1; nyit.sem_flg= SEM_UNDO;

The detailed description of semaphore handling of this example can be found in the book Párhuzamos programozás GNU/Linux környezetben: SysV IPC, P-szálak, OpenMP http://www.inf.unideb.hu/~nbatfai/konyvek/PARP/parp.book.xml.pdf, [PARP].

As mentioned in the previous section about the parent process, the semaphore was set to signaled because its value was set to 1 by the parent process.

We read the first 10 bytes of what the client sent to us and we write back it to the client.

int olvasott = read (kliens, buffer2,
            10); write (kliens, buffer2, olvasott);

We count how many clients worked on the int variable stored in the shared memory segment. The counter is the second variable on the shared memory area and it is pointed by osztott_memoria_terulet+1.

++*(osztott_memoria_terulet+1);

If client sends a plus sign, the following code snippet will increment the first variable that is stored in the shared memory segment. Otherwise, the shared variable will be decreased:

if (buffer2[0] == '+')
            ++*osztott_memoria_terulet; else
            --*osztott_memoria_terulet;

The above last two code snippets are part of the critical section. We would like to achieve that only one process may enter the critical section at the same time in order that variables should not go wrong. Therefore, here we apply mutual exclusion to achieve this goal: only one process can enter the critical section at a time. If a process can acquire the semaphore, all the other processes will be blocked until the semaphore is nonsignaled. The next snippet sets the semaphore to nonsignaled

if (semop (szemafor, &zar, 1) ==
            -1) { perror ("semop zar"); exit (EXIT_FAILURE);
            }

or this one sets the semaphore to signaled after the process exits from the critical section.

if (semop (szemafor, &nyit, 1) ==
            -1) { perror ("semop nyit"); exit (EXIT_FAILURE);
            }

In the critical section we create copies of the two shared variables.

ertek = *osztott_memoria_terulet;
            nkliens = *(osztott_memoria_terulet+1);

These copied values and the system time will be sent back to the client.

olvasott = snprintf(buffer2, 50,
            "Ertek=%d Kliensek=%d\n", ertek, nkliens); write (kliens, buffer2,
            olvasott); return write (kliens, ts, strlen (ts));
            }

The following changes have to be applied in the source codes of the client and the server. In the code of the server,

//inet_aton ("127.0.0.1",
            &(szerver.sin_addr)); szerver.sin_addr.s_addr =
            htonl(INADDR_ANY);

and we use the wildcard address instead of localhost and accordingly with this we apply the server's IP address in the code of the client:

//inet_aton ("127.0.0.1",
            &(szerver.sin_addr)); inet_aton ("193.6.135.21",
            &(szerver.sin_addr));

nbatfai@morse:~$ gcc szerver2.c -o szerver szerver2.c:
              In function ‘main’: szerver2.c:158: error: ‘S_IRUSR’ undeclared
              (first use in this function) szerver2.c:158: error: (Each
              undeclared identifier is reported only once szerver2.c:158:
              error: for each function it appears in.) szerver2.c:158: error:
              ‘S_IWUSR’ undeclared (first use in this function)

[norbert@matrica halozati]$ telnet morse 2012Trying
              193.6.135.21... Connected to morse. Escape character is '^]'. +
              + Ertek=43 Kliensek=541 Sat Aug 4 17:30:00 2012 Connection
              closed by foreign host.

Testing on a virtualized machine

Figure 4.1. Compiling the client and the server.

Figure 4.2. Running the client and the server.

Figure 4.3. Checking the results.

We have used and recommend the following books: [UNP] and [LINUXPROG]. If the reader wants to get a deeper and overall understanding on network programming, we recommend the former one.