How to block and open Clients with Semaphore? Semaphore problem

Question

I have a multiclient Server Socket and I want to block the acces for other Clients, when sending "BEG" to the Server. To open the other Clients again, the Client has to send "END" to the Server. While other Clients are blocked off, they only can use "quit" to exit the Server and if they use conditions() they fall asleep.

So other Clients are blocked for the function conditions() if one process used "BEG", but the process himself has still acces to the function.

If I compile my Code, the Server is running, everything is fine but the Mutexe doesn't work. The Code is going into the if statement of "BEG" and the Mutex should be locked, but other Clients aren't blocked off.

If I connect a second Client, the Client gets kicked if I use conditions().

My question is, why does the mutex not work for other Clients or in generell? How to check if the Mutex is working?

Edit: Now my Semaphore doesn't block other processes

Edit 2: I found a way, not the best but one. Now some clients are getting kicked from the Server after using one condition().

main.c:

int state = 0;

int beg() {
    state = 1;
    return 0;
}

int end() {
    state = 0;
    return 0;
}

int main() {
    int pid, t;
    char *eingabe, *inputBuffer[BUFSIZE];
    char delimiter[] = "\n ";
    int rfd = erstelleSocket();
    int cfd;

    semaphor semID1 = semGET();
    semaphor semID2 = semGET2();

    marker[0] = 1;
    t = semctl(semID1, 1, SETALL, marker);
    if (t == -1) {
        fprintf(stderr, "Error with marker\n");
    }

    t = semctl(semID2, 1, SETALL, marker);
    if (t == -1) {
        fprintf(stderr, "Error with marker\n");
    }
    
    
    while(1){
        cfd = accept(rfd, (struct sockaddr *) &client, &client_len);

        if (cfd < 0) {
            close(cfd);
            fprintf(stderr, "connection failed\n");
            break;
        }
        pid = fork();

        if (pid < 0) {
            fprintf(stderr, "Error in new process creation\n");
        }

        if (pid == 0) {
            bzero(input, sizeof(input));
            bytes_read = read(cfd, input, BUFSIZE);
            strncat(input, " ", strlen(" "));
            input[strcspn(input, "\r\n")] = 0;

            while (bytes_read > 0) {
                eingabe = strtok(input, delimiter);
                int i = 0;
                while (eingabe != NULL) {
                    inputBuffer[i++] = eingabe;
                    eingabe = strtok(NULL, delimiter);
                }

                if (strncmp("quit", inputBuffer[0], 4) == 0) {
                    close(cfd);
                    break;
                }
                

                if (state != 1) {
                    down(semID2, 0); //down is a function with semop()
                }

                down(semID1, 0);

                conditions(inputBuffer[0],
                           inputBuffer[1],
                           inputBuffer[2],
                           cfd, semID1, shmID);

                up(semID1, 0);

               if (state != 1) {
                    up(semID2, 0); //up is a function with semop()
                }

                bzero(input, sizeof(input));
                bytes_read = read(cfd, input, BUFSIZE);
                strncat(input, " ", strlen(" "));
                input[strcspn(input, "\r\n")] = 0;


                close(rfd);
            }
        }
        close(cfd);
   }
   close(rfd);
}

my condition function:

void conditions(char *eingabehalter1,
                char *eingabehalter2,
                char *eingabehalter3,
                int cfd, int shmID) {
    if (strncmp("PUT", eingabehalter1, 3) == 0) {
        put(eingabehalter2, eingabehalter3, cfd, shmID);
    } else if (strncmp("GET", eingabehalter1, 3) == 0) {
        get(eingabehalter2, cfd, shmID);
    } else if (strncmp("DEL", eingabehalter1, 3) == 0) {
        del(eingabehalter2, cfd, shmID);
    } else if (strncmp("BEG", eingabehalter1, 3) == 0) {
        beg();
    } else if (strncmp("END", eingabehalter1, 3) == 0) {
        end();
    } else {
        write(cfd, "cmd_nonexistent\n", strlen("cmd_nonexistent\n"));
    }
}

createSocket.c:

    int rfd; // Rendevouz-Descriptor

    rfd = socket(AF_INET, SOCK_STREAM, 0);
    
    int option = 1;
    setsockopt(rfd,SOL_SOCKET, SO_REUSEADDR, (const void *) &option, sizeof(int));

    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(PORT);
    int brt = bind(rfd, (struct sockaddr *) &server, sizeof(server));
    
    int lrt = listen(rfd, 5);
    
    return rfd;
}

main.h:

#include "shmmemory.h"
#include "semaphoren.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>

#include <unistd.h>

#include <netinet/in.h>

#define PORT 5678

struct sockaddr_in server;
struct sockaddr_in client; 
socklen_t client_len; 
char input[BUFSIZE]; 
int bytes_read; 
int erstelleSocket();

void conditions(char *eingabehalter1,
                char *eingabehalter2,
                char *eingabehalter3,
                int cfd, int shmID);

int beg();
int end();

unsigned short marker[2];

Answer 1

Your approach cannot work because you're trying to combine fork with threads. fork creates a copy of the parent's address space for each child process, which means that each child process has its own copy of the mutex object. Process-shared mutexes are possible in POSIX, with special attributes, but I suspect even those don't work with fork; they have to be placed in shared memory.

Have you considered creating threads with pthread_create for the service loop? Or else you can implement this entirely using fork (no pthread material). The children can use POSIX named semaphores (sem_open, et al) or possibly, dare I say it, System V IPC.

Also, don't use strtok in multithreaded code, and clearing memory to zero was standardized in 1989's ANSI C as memset(pointer, 0, size). Since that was 31 years ago, it's okay to lay bzero to rest.

Answer 2

The way you initialize the semaphores is wrong for your use case. From the man page of sem_init():

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned int value);

If pshared has the value 0, then the semaphore is shared between the threads of a process, and should be located at some address that is visible to all threads (e.g., a global variable, or a variable allocated dynamically on the heap).

If pshared is nonzero, then the semaphore is shared between processes, and should be located in a region of shared memory

Based on the above explanations from the man page, the things you need change are:

Semaphore declaration

Since you are using semaphores between processes, you need to declare the variable as shared. You can do that via mmap() to create unnamed UNIX semaphore as follows:

sem_t* sem_var = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0)

if (sem_var == MAP_FAILED)   // Shared memory creation failed.
   goto handle_shm_fail;

Semaphore initialization

Since you are using POSIX semaphores, to make your child use the same semaphores, pshared is set to 1 indicating semaphore is shared between processes.

if (sem_init(sem_var, 1, 1) != 0)   // Semaphore initialization failed. 
   goto handle_sem_fail;

NOTE: In your code sem_var is of type sem_t, now it is a pointer to sem_t. Accordingly, you need to update your code.