Task: Experiment with the programs svmsg_create.c, svmsg_send.c, and svmsg_receive.c to understand msgget(), msgsnd(), and msgrcv().

What to explore:

• Try sending messages of different types and verify that msgrcv() can selectively read by type.
• Fill the queue and observe that msgsnd() blocks.
• Try IPC_NOWAIT to see EAGAIN instead of blocking.
• Use ipcs -q to view queue state.

/* Minimal experiment: send type-1 and type-2 messages, read only type-2 */
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>

struct msg { long mtype; char text[64]; };

int main(void)
{
    int mqid = msgget(IPC_PRIVATE, 0600);
    struct msg m;

    /* Send type 1 */
    m.mtype = 1; strcpy(m.text, "type-one");
    msgsnd(mqid, &m, sizeof(m.text), 0);

    /* Send type 2 */
    m.mtype = 2; strcpy(m.text, "type-two");
    msgsnd(mqid, &m, sizeof(m.text), 0);

    /* Receive only type 2 — skips type 1 in queue */
    msgrcv(mqid, &m, sizeof(m.text), 2, 0);
    printf("Got mtype=%ld text='%s'\n", m.mtype, m.text);
    /* Output: Got mtype=2 text='type-two' */

    /* Now receive type 1 */
    msgrcv(mqid, &m, sizeof(m.text), 1, 0);
    printf("Got mtype=%ld text='%s'\n", m.mtype, m.text);
    /* Output: Got mtype=1 text='type-one' */

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

Task: Recode the sequence-number client-server application (originally using FIFOs in Section 44.8) to use a single SysV message queue for both client→server and server→client communication, using message types to distinguish them.

Design hint: Use mtype=1 for client requests. For responses, use the client’s PID as the mtype — this ensures only the correct client reads its own response.

/* Key idea: using PID as message type for routing responses */
#include <sys/msg.h>
#include <unistd.h>
#include <stdio.h>

#define REQ_MTYPE  1    /* all client requests use mtype=1 */
#define SERVER_KEY 0xABCD1234

struct request  { long mtype; pid_t pid; int seqlen; };
struct response { long mtype; int   seqnum; };   /* mtype = client's PID */

/* CLIENT side: */
void client_main(void)
{
    int mqid = msgget(SERVER_KEY, 0);
    struct request req;
    struct response resp;

    req.mtype  = REQ_MTYPE;
    req.pid    = getpid();
    req.seqlen = 3;
    msgsnd(mqid, &req, sizeof(req) - sizeof(long), 0);

    /* Wait for response addressed to my PID */
    msgrcv(mqid, &resp, sizeof(resp) - sizeof(long), getpid(), 0);
    printf("Sequence starts at: %d\n", resp.seqnum);
}

/* SERVER side: */
void server_main(void)
{
    int mqid = msgget(SERVER_KEY, IPC_CREAT | 0600);
    struct request req;
    struct response resp;
    int seq = 0;

    for (;;) {
        /* Read any request (mtype=1) */
        msgrcv(mqid, &req, sizeof(req) - sizeof(long), REQ_MTYPE, 0);

        /* Send reply addressed to client's PID */
        resp.mtype  = req.pid;
        resp.seqnum = seq;
        seq += req.seqlen;
        msgsnd(mqid, &resp, sizeof(resp) - sizeof(long), 0);
    }
}

Task: Explain why the client passes its queue identifier in the body of the message rather than in mtype.

Answer:

• mtype must be a positive long integer (the kernel rejects zero or negative values — EINVAL). A queue ID from msgget(IPC_PRIVATE) could theoretically be 0.
• The server uses msgrcv(..., REQ_MT_OPEN, 0) to read all client requests with the same type. If mtype were the clientId, every client would need a unique type and the server couldn’t simply read “all requests of type X”.
• Putting clientId in the body is just data — safe for any integer value, and flexible.

Task: Multiple improvements to the client-server app:

• (a) Use IPC_PRIVATE + write queue ID to a well-known file
• (b) Log errors with syslog()
• (c) Daemonize the server
• (d) Handle SIGTERM/SIGINT cleanly — delete queue before exit
• (e) Add timeout for stale client (client disappeared)

/* Part (a): Server writes its queue ID to a file */
int write_server_id(int mqid)
{
    FILE *fp = fopen("/var/run/svmsg_server.id", "w");
    if (!fp) return -1;
    fprintf(fp, "%d\n", mqid);
    fclose(fp);
    return 0;
}

int read_server_id(void)
{
    int mqid;
    FILE *fp = fopen("/var/run/svmsg_server.id", "r");
    if (!fp) return -1;
    fscanf(fp, "%d", &mqid);
    fclose(fp);
    return mqid;
}

/* Part (d): Signal handler for clean exit */
static int g_serverId = -1;

void sig_handler(int sig)
{
    if (g_serverId != -1)
        msgctl(g_serverId, IPC_RMID, NULL);
    unlink("/var/run/svmsg_server.id");
    signal(sig, SIG_DFL);
    raise(sig);
}

/* Register in main(): */
/*   signal(SIGTERM, sig_handler); */
/*   signal(SIGINT,  sig_handler); */

/* Part (e): Timeout for disappeared client using alarm() */
#include <setjmp.h>
#include <signal.h>

static sigjmp_buf jump_env;

void alarm_handler(int sig) { siglongjmp(jump_env, 1); }

int msgsnd_with_timeout(int mqid, void *msg, size_t sz, int secs)
{
    signal(SIGALRM, alarm_handler);
    if (sigsetjmp(jump_env, 1) != 0) {
        /* alarm fired — client has disappeared */
        return -1;
    }
    alarm(secs);
    int ret = msgsnd(mqid, msg, sz, 0);
    alarm(0);   /* cancel alarm */
    return ret;
}