The first thing the client does is create its own message queue using IPC_PRIVATE. Unlike the server’s well-known queue (identified by SERVER_KEY), this queue has no fixed name — only the client knows its ID.

/* Look up the server's queue by its well-known key */
serverId = msgget(SERVER_KEY, S_IWUSR);
if (serverId == -1)
    errExit("msgget - server message queue");

/* Create our own private reply queue — no other process knows it */
clientId = msgget(IPC_PRIVATE, S_IRUSR | S_IWUSR | S_IWGRP);
if (clientId == -1)
    errExit("msgget - client message queue");

atexit() registers a function that the C runtime calls automatically when the process exits — whether via return from main(), a call to exit(), or even abnormal termination through some signal handlers.

static int clientId; /* global so atexit handler can see it */

static void
removeQueue(void)
{
    if (msgctl(clientId, IPC_RMID, NULL) == -1)
        errExit("msgctl");
}

/* In main(), after creating clientId: */
if (atexit(removeQueue) != 0)
    errExit("atexit");

Why is this necessary? System V message queues persist in the kernel until explicitly deleted — they are not closed like file descriptors. If the client exits without deleting its queue:

• The queue remains in the kernel’s IPC namespace.
• It occupies a slot in the system’s message queue table (limited by MSGMNI).
• Pending messages in it waste kernel memory.
• You can see leftover queues with ipcs -q and delete them with ipcrm -q <id>.

The client builds a requestMsg and sends it to the server’s queue.

struct requestMsg req;

req.mtype    = 1;         /* Any positive value — server reads all types */
req.clientId = clientId;  /* Tell server where to send the reply */

/* Copy pathname safely — prevent buffer overflow */
strncpy(req.pathname, argv[1], sizeof(req.pathname) - 1);
req.pathname[sizeof(req.pathname) - 1] = '\0'; /* ensure null termination */

/* Send request to server's queue */
if (msgsnd(serverId, &req, REQ_MSG_SIZE, 0) == -1)
    errExit("msgsnd");

After sending the request, the client waits for responses on its private queue. The first message it receives determines what happens next:

struct responseMsg resp;
ssize_t msgLen, totBytes;

/* Receive the FIRST response — might be failure or first data chunk */
msgLen = msgrcv(clientId, &resp, sizeof(resp.data), 0, 0);
if (msgLen == -1)
    errExit("msgrcv");

/* Check if server reported failure */
if (resp.mtype == RESP_MT_FAILURE) {
    fprintf(stderr, "%s\n", resp.data); /* print error from server */
    exit(EXIT_FAILURE);
}

/* File opened OK — loop receiving data chunks until RESP_MT_END */
totBytes = msgLen;
for (;;) {
    if (resp.mtype == RESP_MT_END)
        break;                  /* transfer complete */

    write(STDOUT_FILENO, resp.data, msgLen); /* print chunk to stdout */

    msgLen = msgrcv(clientId, &resp,
                     sizeof(resp.data), 0, 0);
    if (msgLen == -1)
        errExit("msgrcv");
    totBytes += msgLen;
}

The book explicitly notes this client does not handle several real-world failure scenarios:

#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include "svmsg_file.h"

static int clientId;

static void
removeQueue(void)
{
    msgctl(clientId, IPC_RMID, NULL);
}

int
main(int argc, char *argv[])
{
    struct requestMsg  req;
    struct responseMsg resp;
    int    serverId;
    ssize_t msgLen, totBytes;

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

    /* === SETUP === */
    serverId = msgget(SERVER_KEY, S_IWUSR);
    if (serverId == -1) exit(EXIT_FAILURE);

    clientId = msgget(IPC_PRIVATE,
                       S_IRUSR | S_IWUSR | S_IWGRP);
    if (clientId == -1) exit(EXIT_FAILURE);

    atexit(removeQueue); /* ensure queue deleted on exit */

    /* === SEND REQUEST === */
    req.mtype    = 1;
    req.clientId = clientId;
    strncpy(req.pathname, argv[1], sizeof(req.pathname) - 1);
    req.pathname[sizeof(req.pathname) - 1] = '\0';

    msgsnd(serverId, &req, REQ_MSG_SIZE, 0);

    /* === RECEIVE FIRST RESPONSE === */
    msgLen = msgrcv(clientId, &resp,
                     sizeof(resp.data), 0, 0);

    if (resp.mtype == RESP_MT_FAILURE) {
        fprintf(stderr, "Server error: %s\n", resp.data);
        exit(EXIT_FAILURE);
    }

    /* === LOOP RECEIVING DATA === */
    totBytes = 0;
    for (;;) {
        if (resp.mtype == RESP_MT_END) break;
        write(STDOUT_FILENO, resp.data, msgLen);
        totBytes += msgLen;
        msgLen = msgrcv(clientId, &resp,
                         sizeof(resp.data), 0, 0);
        if (msgLen == -1) exit(EXIT_FAILURE);
    }

    fprintf(stderr, "Received %ld bytes\n", (long)totBytes);
    exit(EXIT_SUCCESS);
}

1. Why does the client create its queue with IPC_PRIVATE instead of a fixed key?
2. What does atexit() do and why is it necessary for the client’s private queue?
3. In what situations will the atexit() handler NOT run?
4. Why does the client include clientId in the request message instead of using a fixed agreed-upon reply queue?
5. Why does the client check mtype == RESP_MT_FAILURE on the very first received message before starting the data loop?
6. What happens if the client tries to receive but the server has already deleted the queue?
7. Why is the clientId variable declared as static global instead of local to main()?
8. What is the permission S_IWGRP for on the client’s message queue?
9. The client uses strncpy and manually sets the last byte to '\0'. Why is both necessary?
10. How would you add a timeout to the client’s msgrcv() call to prevent blocking forever?
11. If two instances of this client run simultaneously requesting the same file, is there any conflict? Explain.
12. What does msgrcv(clientId, &resp, sizeof(resp.data), 0, 0) receive — all message types or a specific one?