The design involves three types of participants:

1. Server’s queue — Created once at startup with a well-known IPC key. All clients know this key and use it to locate the server.
2. Client’s private queue — Each client creates this with IPC_PRIVATE before sending any request. The queue ID is passed to the server inside the request message.
3. Server child process — In a forking server, the main process creates a child for each request. The child handles the work and sends the response to the client’s private queue.

IPC_PRIVATE is a special key value (equal to 0) that instructs msgget() to always create a new, unique queue regardless of any existing queues. It is guaranteed not to match any existing IPC key. The resulting queue ID is unique and can only be used by processes that are told this ID explicitly (e.g., via a message, a pipe, or shared memory).

/* Creating a private queue — IPC_PRIVATE guarantees uniqueness */
int clientQid = msgget(IPC_PRIVATE, S_IRUSR | S_IWUSR);
/*                       ^^^^^^^^^^^
 *  IPC_PRIVATE = 0: always creates a brand new queue,
 *  never fails due to "queue already exists"
 */

if (clientQid == -1) {
    perror("msgget IPC_PRIVATE");
    exit(1);
}

printf("Private queue created: ID = %d\n", clientQid);

/* This ID must be communicated to the server via the request message */

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

#define SERVER_KEY  0x1aaaaaa1  /* Well-known server queue key */
#define RESP_MT_DATA    2
#define RESP_MT_END     3
#define RESP_MT_FAILURE 1

/* Request message format */
struct requestMsg {
    long mtype;          /* Unused by server (set to 1) */
    int  clientId;       /* ID of client's private queue */
    char pathname[256];  /* File or resource requested */
};

/* Response message format */
struct responseMsg {
    long mtype;          /* RESP_MT_DATA, RESP_MT_END, or RESP_MT_FAILURE */
    char data[4096];
};

static int clientQid = -1; /* Global so cleanup handler can access it */

/* Cleanup handler — called on exit and signals */
static void cleanup(void) {
    if (clientQid != -1) {
        msgctl(clientQid, IPC_RMID, NULL);
        printf("Client queue deleted.\n");
    }
}

static void sigHandler(int sig) {
    cleanup();
    _exit(EXIT_FAILURE);
}

int main(int argc, char *argv[]) {
    int serverQid;
    struct requestMsg  req;
    struct responseMsg resp;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <pathname>\n", argv[0]);
        exit(1);
    }

    /* Register cleanup on normal exit and common signals */
    atexit(cleanup);
    signal(SIGINT,  sigHandler);
    signal(SIGTERM, sigHandler);

    /* Step 1: Create private queue for receiving responses */
    clientQid = msgget(IPC_PRIVATE, 0600);
    if (clientQid == -1) {
        perror("msgget IPC_PRIVATE");
        exit(1);
    }
    printf("Client private queue: ID = %d\n", clientQid);

    /* Step 2: Open the server's well-known queue */
    serverQid = msgget(SERVER_KEY, 0);
    if (serverQid == -1) {
        perror("msgget server queue");
        exit(1);
    }

    /* Step 3: Build and send request to server */
    req.mtype    = 1;           /* Convention: all requests use mtype=1 */
    req.clientId = clientQid;   /* Tell server where to send responses */
    strncpy(req.pathname, argv[1], sizeof(req.pathname) - 1);

    if (msgsnd(serverQid, &req, sizeof(req) - sizeof(long), 0) == -1) {
        perror("msgsnd request");
        exit(1);
    }

    /* Step 4: Read responses from our private queue */
    printf("Waiting for response...\n");
    while (1) {
        /* Receive ANY message from our private queue (msgtyp = 0) */
        if (msgrcv(clientQid, &resp,
                   sizeof(resp) - sizeof(long),
                   0,    /* Accept any mtype from this queue */
                   0) == -1) {
            perror("msgrcv response");
            break;
        }

        if (resp.mtype == RESP_MT_DATA) {
            printf("DATA: %s", resp.data);
        } else if (resp.mtype == RESP_MT_END) {
            printf("\n[Transfer complete]\n");
            break;
        } else if (resp.mtype == RESP_MT_FAILURE) {
            fprintf(stderr, "Server error: %s\n", resp.data);
            break;
        }
    }
    /* cleanup() called automatically via atexit() */
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/wait.h>

#define SERVER_KEY  0x1aaaaaa1
#define RESP_BUF    4096
#define RESP_MT_DATA    2
#define RESP_MT_END     3
#define RESP_MT_FAILURE 1

struct requestMsg  { long mtype; int clientId; char pathname[256]; };
struct responseMsg { long mtype; char data[RESP_BUF]; };

/* Child process: serve one client request */
static void serveRequest(const struct requestMsg *req) {
    int fd, numRead;
    struct responseMsg resp;

    /* Try to open the requested file */
    fd = open(req->pathname, O_RDONLY);
    if (fd == -1) {
        /* Send failure notification to client */
        resp.mtype = RESP_MT_FAILURE;
        snprintf(resp.data, RESP_BUF, "Cannot open '%s': %s",
                 req->pathname, strerror(errno));
        msgsnd(req->clientId, &resp, sizeof(resp) - sizeof(long), 0);
        return;
    }

    /* Stream file contents as DATA messages */
    resp.mtype = RESP_MT_DATA;
    while ((numRead = read(fd, resp.data, RESP_BUF)) > 0) {
        if (msgsnd(req->clientId, &resp, numRead, 0) == -1) {
            /* Client queue may be gone (client crashed) */
            if (errno == EINVAL)
                fprintf(stderr, "Client queue gone — client may have crashed\n");
            else
                perror("msgsnd data");
            break;
        }
    }
    close(fd);

    /* Send end-of-transfer marker */
    resp.mtype = RESP_MT_END;
    resp.data[0] = '\0';
    msgsnd(req->clientId, &resp, 1, 0);
}

int main(void) {
    int serverQid;
    struct requestMsg req;
    pid_t pid;

    /* Create server's well-known queue */
    serverQid = msgget(SERVER_KEY, IPC_CREAT | IPC_EXCL | 0600);
    if (serverQid == -1) {
        if (errno == EEXIST) {
            /* Queue already exists from a previous run — reopen it */
            serverQid = msgget(SERVER_KEY, 0600);
        }
        if (serverQid == -1) { perror("msgget server"); exit(1); }
    }

    printf("File server started. Queue ID = %d\n", serverQid);

    /* SIGCHLD: reap children automatically to prevent zombies */
    signal(SIGCHLD, SIG_DFL); /* Or use SA_NOCLDWAIT */

    while (1) {
        /* Block until a client request arrives (mtype = 1) */
        if (msgrcv(serverQid, &req,
                   sizeof(req) - sizeof(long),
                   1, 0) == -1) {
            if (errno == EINTR) continue;
            perror("msgrcv");
            break;
        }

        printf("Handling request from client queue %d: '%s'\n",
               req.clientId, req.pathname);

        /* Fork a child to handle this request */
        pid = fork();
        if (pid == -1) {
            perror("fork");
            continue;
        }

        if (pid == 0) {          /* Child */
            serveRequest(&req);
            exit(0);
        }
        /* Parent continues accepting more requests immediately */
        /* (Children are reaped asynchronously via SIGCHLD) */
    }

    msgctl(serverQid, IPC_RMID, NULL);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/msg.h>

int main(void) {
    /* Method 1: Read from /proc */
    FILE *fp = fopen("/proc/sys/kernel/msgmni", "r");
    if (fp) {
        int limit;
        fscanf(fp, "%d", &limit);
        fclose(fp);
        printf("Current MSGMNI (from /proc): %d\n", limit);
    }

    /* Method 2: Use MSG_INFO via msgctl */
    struct msginfo info;
    if (msgctl(0, MSG_INFO, (struct msqid_ds *)&info) != -1) {
        printf("Current MSGMNI (from MSG_INFO): %d\n", info.msgmni);
    }

    /* Raising the limit requires root — done via sysctl or /proc:
     *
     *   echo 1024 > /proc/sys/kernel/msgmni
     *   sysctl -w kernel.msgmni=1024
     *
     * For permanent change, add to /etc/sysctl.conf:
     *   kernel.msgmni = 1024
     */

    /* Simulate what happens when limit is exceeded */
    printf("\nAttempting to create many queues...\n");
    int ids[100], count = 0;
    while (count < 100) {
        ids[count] = msgget(IPC_PRIVATE, 0600);
        if (ids[count] == -1) {
            perror("msgget (limit reached)");
            printf("Could only create %d queues before hitting limit.\n", count);
            break;
        }
        count++;
    }

    /* Cleanup: delete all created queues */
    for (int i = 0; i < count; i++)
        msgctl(ids[i], IPC_RMID, NULL);

    return 0;
}