With a single shared message queue, both requests (client → server) and responses (server → client) travel through the same queue. To avoid message mix-ups, the mtype field in each message acts as a routing tag. The rules are:

The client includes its own PID in the message body when sending a request. The server reads this PID, then uses it as the mtype for the response. The client waits for a message with mtype equal to its own PID — this way each client only picks up its own responses.

While simple, the single-queue approach has two significant weaknesses:

Define the message formats used by both client and server:

#include <sys/types.h>
#include <sys/msg.h>
#include <limits.h>

/* ----------------------------------------------------------------
 * All System V messages MUST start with a long mtype field.
 * The mtype controls routing — who reads this message.
 * ---------------------------------------------------------------- */

/* Message sent FROM client TO server */
struct clientRequest {
    long mtype;           /* Always set to 1 (server's well-known type) */
    pid_t clientPid;      /* Client's PID — server uses this as response mtype */
    char  requestData[256]; /* The actual request payload */
};

/* Message sent FROM server TO client */
struct serverResponse {
    long mtype;           /* Set to clientPid — only that client will read it */
    int  statusCode;      /* 0 = success, -1 = error */
    char responseData[256]; /* The actual response payload */
};

/* ----------------------------------------------------------------
 * KEY RULE:
 *   - Client sends with mtype = 1
 *   - Client receives with msgtyp = getpid()
 *   - Server receives with msgtyp = 1
 *   - Server sends with mtype = req.clientPid
 * ---------------------------------------------------------------- */

The server reads requests with mtype=1 and responds using the client’s PID as mtype:

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define SERVER_KEY 0x12345678

struct clientRequest {
    long  mtype;
    pid_t clientPid;
    char  requestData[256];
};

struct serverResponse {
    long mtype;
    int  statusCode;
    char responseData[256];
};

int main(void) {
    int qid;
    struct clientRequest req;
    struct serverResponse resp;

    /* Create the shared message queue (or open if it already exists) */
    qid = msgget(SERVER_KEY, IPC_CREAT | 0666);
    if (qid == -1) { perror("msgget"); exit(1); }

    printf("Server started. Queue ID = %d\n", qid);
    printf("Waiting for requests (mtype=1)...\n");

    while (1) {
        /* Receive ONLY messages with mtype = 1 (client requests) */
        ssize_t n = msgrcv(qid,
                           &req,
                           sizeof(req) - sizeof(long),  /* mtext size */
                           1,                            /* msgtyp = 1 */
                           0);                           /* flags */

        if (n == -1) {
            if (errno == EINTR) continue;  /* Interrupted by signal, retry */
            perror("msgrcv");
            break;
        }

        printf("Request from PID %d: '%s'\n", req.clientPid, req.requestData);

        /* Build and send response back to that specific client */
        resp.mtype      = req.clientPid;  /* Route to the requesting client */
        resp.statusCode = 0;
        snprintf(resp.responseData, sizeof(resp.responseData),
                 "Processed: %s", req.requestData);

        if (msgsnd(qid, &resp, sizeof(resp) - sizeof(long), 0) == -1) {
            perror("msgsnd response");
        }
    }

    /* Cleanup */
    msgctl(qid, IPC_RMID, NULL);
    return 0;
}

The client sends with mtype=1 and waits for a response with mtype=own PID:

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define SERVER_KEY 0x12345678

struct clientRequest {
    long  mtype;
    pid_t clientPid;
    char  requestData[256];
};

struct serverResponse {
    long mtype;
    int  statusCode;
    char responseData[256];
};

int main(int argc, char *argv[]) {
    int qid;
    struct clientRequest  req;
    struct serverResponse resp;

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

    /* Open the existing shared queue (server must create it first) */
    qid = msgget(SERVER_KEY, 0);
    if (qid == -1) { perror("msgget"); exit(1); }

    /* Build the request */
    req.mtype     = 1;           /* All requests use mtype = 1 */
    req.clientPid = getpid();    /* Tell server our PID for routing response */
    strncpy(req.requestData, argv[1], sizeof(req.requestData) - 1);

    /* Send request to server */
    if (msgsnd(qid, &req, sizeof(req) - sizeof(long), 0) == -1) {
        perror("msgsnd");
        exit(1);
    }

    printf("Request sent. Waiting for response (mtype=%d)...\n", (int)getpid());

    /* Wait for response addressed specifically to us (mtype = our PID) */
    if (msgrcv(qid, &resp,
               sizeof(resp) - sizeof(long),
               getpid(),          /* msgtyp = our own PID */
               0) == -1) {
        perror("msgrcv");
        exit(1);
    }

    printf("Response: status=%d, data='%s'\n", resp.statusCode, resp.responseData);
    return 0;
}