serveRequest() receives a pointer to the requestMsg struct that the parent read from the server queue. From this, it gets two things:

• req->pathname — the file to open and serve
• req->clientId — the message queue ID to send responses to

The function follows this decision tree:

If open() fails (file not found, permission denied, etc.), the server child sends a single RESP_MT_FAILURE message with a short error description in the data field, then calls exit(EXIT_FAILURE).

fd = open(req->pathname, O_RDONLY);
if (fd == -1) {
    resp.mtype = RESP_MT_FAILURE;
    snprintf(resp.data, sizeof(resp.data),
             "%s", "Couldn't open");

    /* Send error text to client.
       Size = strlen(data) + 1 to include the null terminator. */
    msgsnd(req->clientId, &resp,
           strlen(resp.data) + 1, 0);

    exit(EXIT_FAILURE); /* child exits */
}

If the file opens successfully, the server reads it in chunks of RESP_MSG_SIZE bytes. Each chunk is sent as a separate message with mtype = RESP_MT_DATA.

resp.mtype = RESP_MT_DATA;

while ((numRead = read(fd, resp.data, RESP_MSG_SIZE)) > 0)
    if (msgsnd(req->clientId, &resp, numRead, 0) == -1)
        break; /* can't notify client — just stop */

/* Signal end of file with a zero-length mtext message */
resp.mtype = RESP_MT_END;
msgsnd(req->clientId, &resp, 0, 0);

Key points in this loop:

After all data messages are sent, the server sends one final message with mtype = RESP_MT_END and a zero-length data field. This is the signal to the client that the entire file has been transferred.

resp.mtype = RESP_MT_END;
msgsnd(req->clientId, &resp, 0, 0);
/*                            ^
                              zero-length mtext */

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

static void
serveRequest(const struct requestMsg *req)
{
    int fd;
    ssize_t numRead;
    struct responseMsg resp;

    /* Try to open the file the client requested */
    fd = open(req->pathname, O_RDONLY);
    if (fd == -1) {

        /* Tell client we couldn't open it */
        resp.mtype = RESP_MT_FAILURE;
        snprintf(resp.data, sizeof(resp.data),
                 "%s", "Couldn't open");
        msgsnd(req->clientId, &resp,
               strlen(resp.data) + 1, 0);
        exit(EXIT_FAILURE);
    }

    /* File opened OK — stream contents to client */
    resp.mtype = RESP_MT_DATA;
    while ((numRead = read(fd, resp.data, RESP_MSG_SIZE)) > 0)
        if (msgsnd(req->clientId, &resp, numRead, 0) == -1)
            break;

    /* Send end-of-file marker */
    resp.mtype = RESP_MT_END;
    msgsnd(req->clientId, &resp, 0, 0);
}

This is a subtle design decision. Once the server has successfully opened the file and started sending data, if read() or msgsnd() fails:

• The server has no second channel to notify the client that an error occurred mid-transfer.
• The only communication channel is the client’s message queue — and if msgsnd() is failing, that channel itself is broken.
• Adding complex error recovery would require a separate signaling mechanism.

The book acknowledges this limitation and suggests improvements in Exercise 46-4 (server improvements) and Exercise 46-5 (client improvements).

The msgsnd() and msgrcv() size arguments refer only to the data part of the message — the mtype field is never counted:

struct responseMsg {
    long mtype;          /* NOT counted in size argument */
    char data[8192];     /* THIS is what the size refers to */
};

/* Sending actual read bytes (not the full buffer): */
msgsnd(clientId, &resp, numRead, 0);

/* Sending zero-length end marker: */
msgsnd(clientId, &resp, 0, 0);

/* Receiving — use max possible size: */
ssize_t n = msgrcv(clientId, &resp,
                    sizeof(resp.data), 0, 0);
/* n == 0 means RESP_MT_END was received (zero data) */

1. What are the three response message types the server sends and in what situations?
2. Why does msgsnd() use numRead as the size argument instead of RESP_MSG_SIZE?
3. What does a zero-length msgsnd() call signify in this application?
4. The server does not handle read() errors during file transfer. Why? What are the consequences?
5. How does the client know when the file transfer is complete?
6. The mtype field is never included in the size argument to msgsnd(). Why?
7. Why does the server child call exit(EXIT_FAILURE) after sending the failure message?
8. What would happen if the server sent all data in one huge message instead of multiple chunks?
9. In serveRequest(), what determines how many messages are sent for a given file?
10. If the client’s queue is full when the server tries to send a data message, what happens by default?