Client Server Application - Multi threaded server.

The Server.
It will create...
a semaphore for synchronization
a common request message Q,
a thread that will read the request from request q.
As no client would have sent request... this thread would go on block on read.

when the client sends in the request. the thread will read the request. find the operation (if supported) then invokes the processing client and passes the request onto it.
when the result is available. This thread will send it back to the requesting client.
(meanwhile the server creates another thread for reading from the request q)

                                                    client1.c
###############################################################################################
#include<sys/types.h>
#include<unistd.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<signal.h>
#include<sys/msg.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>

#define BUF_SZ 100
#define KEY 2222
#define KEY1 1234

void signal_handler(int sig)
{
        printf("I got a signal Number:%d\n", sig);
}

int main()
{
    struct msgbuf {
    long mtype;
    int cpid;
    char msgtext[BUF_SZ];
    };

    struct msgbuff {
        long mtype;
        int result;
        };

    struct msgbuf msgbuf1;
    struct msgbuff msgbuff1;

    msgbuf1.mtype = 1;
    msgbuff1.mtype = getpid();
        
        int semid;
        struct sembuf sop;
        union semun {
               int              val;    /* Value for SETVAL */
               struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
               unsigned short  *array;  /* Array for GETALL, SETALL */
               struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                           (Linux-specific) */
           };
        union semun sem1;
        int ret1;
        key_t key = 5678;
    //  sem1.val = 1;
        semid = semget(key, 2, IPC_CREAT|0666);
        if (semid == -1) {
                perror("semget");
                exit(EXIT_FAILURE);
        }        

    int size = sizeof(msgbuf1.msgtext) + sizeof(msgbuf1.cpid);
    int sizep = sizeof(msgbuff1.result);
    int msgid, msgid1, ret;
    char *p;
    signal(2, signal_handler);
    printf("The size of msg to be passed:%d\n", size);
    
    msgbuf1.cpid = getpid();
    printf("The pid of client is:%d\n", msgbuf1.cpid);

    p = fgets(msgbuf1.msgtext, BUF_SZ, stdin);
    if (p == NULL) {
        perror("fgets");
        exit(EXIT_FAILURE);
    }

    msgid = msgget(KEY, IPC_CREAT | 0666);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    sop.sem_num=0;
        sop.sem_op=-1;
        sop.sem_flg=SEM_UNDO;
        semop(semid, &sop, 1);
    
    ret = msgsnd(msgid, &msgbuf1, size, IPC_NOWAIT);
    if (ret == -1) {
        perror("msgsnd");
        exit(EXIT_FAILURE);
    }
    
    sop.sem_num=0;
        sop.sem_op=+1;
        sop.sem_flg=SEM_UNDO;
        semop(semid, &sop, 1);
    
    msgid1 = msgget(KEY1, IPC_CREAT | 0666);
        if (msgid1 == -1) {
                perror("msgget");
                exit(EXIT_FAILURE);
        }

    pause();

    ret = msgrcv(msgid1, &msgbuff1, sizep, msgbuff1.mtype, IPC_NOWAIT);
        if (ret == -1) {
                perror("msgsnd2");
                exit(EXIT_FAILURE);
        }
        printf("The msg is:%d\n", msgbuff1.result);
}
 

################################################################################################
                                                                                 server.c
################################################################################################
#include<sys/types.h>
#include<sys/ipc.h>
#include<errno.h>
#include<sys/msg.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>

#define BUF_SZ 100
#define KEY 2222

    struct msgbuf {
    long mtype;
    int cpid;
    char msgtext[BUF_SZ];
    };
    struct msgbuf msgbuf1;
   
    char arr1[6];
    char arr2[6];
    char *p1 = NULL;
    char *p2 = NULL;

void *thread_func1(void *arg)
{
    int cpid1;
    int status, ret = 0;
    printf("In Thread1 routine\n");

    cpid1 = fork();
    if (cpid1 < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    if (cpid1 == 0) {
        ret = execlp("./p", "p", arr1, p1, NULL);
        if (ret == -1) {
            perror("execlp");
            printf("The error number is:%d\n", errno);
            exit(EXIT_FAILURE);
        }
        exit(EXIT_SUCCESS);
    }
    else {
        wait(&status);
    }
}

void *thread_func2 (void *arg)
{
    int cpid1;
    int status, ret = 0;
    printf("In Thread2 routine\n");

    cpid1 = fork();
    if (cpid1 < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    if (cpid1 == 0) {
        ret = execlp("./q", "q", arr2, p2, NULL);
        if (ret == -1) {
            perror("execlp");
            printf("The error number is:%d\n", errno);
            exit(EXIT_FAILURE);
        }
        exit(EXIT_SUCCESS);
    }
    else {
        wait(&status);
    }
}
int main()
{
    struct msqid_ds msqp;
    int thid1, thid2;
    int msgid, ret;
    int *retval;
    pthread_t thread1, thread2;
    int size = sizeof(msgbuf1.msgtext) + sizeof(msgbuf1.cpid);

    msgid = msgget(KEY, IPC_CREAT | 0666);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }


    msgbuf1.mtype = 1;
    ret = msgrcv(msgid, &msgbuf1, size, msgbuf1.mtype, IPC_NOWAIT);
        if (ret == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }

    sprintf(arr1, "%d", msgbuf1.cpid);
    p1 = msgbuf1.msgtext;
    printf("The message from client1 is:%s\n", msgbuf1.msgtext);
    printf("The client1 pid:%d\n", msgbuf1.cpid);
    thid1 = pthread_create(&thread1, NULL, thread_func1, NULL);
    if (thid1 != 0) {
            perror("pthread_create");
                exit(EXIT_FAILURE);
            }   
       

    msgbuf1.mtype = 2;
    ret = msgrcv(msgid, &msgbuf1, size, msgbuf1.mtype, IPC_NOWAIT);
        if (ret == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }
    sprintf(arr2, "%d", msgbuf1.cpid);
    p2 = msgbuf1.msgtext;
    printf("The message from client2 is:%s\n", msgbuf1.msgtext);
    printf("The client2 pid is:%d\n", msgbuf1.cpid);
    thid2 = pthread_create(&thread2, NULL, thread_func2, NULL);
    if (thid2 != 0) {
        perror("pthread_create");
        exit(EXIT_FAILURE);
    }   
/*    ret = msgctl(msgid, IPC_RMID, 0);  // deleting the msg queue.
    if (ret == -1) {
        perror("msgctl");
        exit(EXIT_FAILURE);
    } */
    pthread_join(thread1, (void **)&retval);
    pthread_join(thread2, (void **)&retval);
    return 0;
}
   

##########################################################
                               pclien2.c
###########################################################
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<stdio.h>
#include<stdlib.h>
#include<signal.h>
#include<string.h>

#define KEY1 1234

int main(int argc, char *argv[])
{   
    struct msgbuff {
        long mtype;
          int result;
        };
    struct msgbuff msgbuff1;

    int pid2, sum;
    char *data;
    char *op2;
    char op1[6];
    int i = 0, msgid, ret;
    pid2 = atoi(argv[1]);
    msgbuff1.mtype = pid2;
    int sizep = sizeof(msgbuff1.result);
   
    if (argc < 2) {
        perror("argc");
        exit(EXIT_FAILURE);
    }
    printf("The pid of client2 in processing client program:%d\n", pid2);
    data = argv[2];
    while((*data) !=  ' ') {
        op1[i] = *data;
        data++;
        i++;
    }
    op1[i] = '\0';
    op2 = data;
    sum = atoi(op1) + atoi(op2);
    printf("The value of opr1:%s op2:%s\n", op1, op2);
    printf("The sum in pclient2 is:%d\n", sum);
    msgid = msgget(KEY1, IPC_CREAT | 0666);
        if (msgid == -1) {
                perror("msgget");
                exit(EXIT_FAILURE);
        }
    msgbuff1.result = sum;

    ret = msgsnd(msgid, &msgbuff1, sizep, IPC_NOWAIT);
        if (ret == -1) {
                perror("msgsnd in pclient1");
                exit(EXIT_FAILURE);
        }

    kill(pid2, SIGINT);
    return 0;
}

This will make another attempt to take semaphore if it fails for the first time.
Acquiring semaphores may fail as the semaphore variable works in the atomic mode. If one process is doing test-set operation and the other starts testing then the second process will not be able to acquire the semaphore.

how to use semop in between server and vendor in IPC project

Use thread semaphore, if your main thread is running more than once. And for pid and result, please go through you program one more time. I'm sure you can debug it.

local.h:4:2: error: unknown type name ‘LocalInfra’
    4 |  LocalInfra *linfra;
      |  ^~~~~~~~~~
In file included from server.c:5:
local.h:1:16: error: redefinition of ‘struct total_infra’
    1 | typedef struct total_infra
      |                ^~~~~~~~~~~
In file included from declarations.h:3,
                 from server.c:4:
local.h:1:16: note: originally defined here
    1 | typedef struct total_infra
      |                ^~~~~~~~~~~
In file included from server.c:5:
local.h:5:2: error: conflicting types for ‘Total_infr’
    5 | }Total_infr;
      |  ^~~~~~~~~~
In file included from declarations.h:3,
                 from server.c:4:
local.h:5:2: note: previous declaration of ‘Total_infr’ was here
    5 | }Total_infr;
      |  ^~~~~~~~~~
server.c: In function ‘main’:
server.c:26:2: error: conversion to non-scalar type requested
   26 |  tinfra->linfra = (LocalInfra)(*fptr[2])(0); // create_local_infra()
      |  ^~~~~~
server.c:30:20: error: ‘linfra’ undeclared (first use in this function); did you mean ‘tinfra’?
   30 |   sem_wait(&tinfra-linfra->sem);
      |                    ^~~~~~
      |                    tinfra
server.c:30:20: note: each undeclared identifier is reported only once for each function it appears in
make: *** [makefile:24: server.o] Error 1
make: Leaving directory '/system_programming/client_server_using_ipc/server'
server build failed