Message Queues

Chapter 1: ftok() — Generating Keys

Every System V IPC object (message queue, semaphore, shared memory) is identified by a key — a system-wide unique number. Two processes that want to use the same queue must agree on the same key.

You could just hardcode a number, but what if another unrelated program uses the same number? The solution is ftok():

c
#include <sys/ipc.h>

key_t key;
key = ftok("/home/beej/somefile", 'b');

ftok() takes two arguments: a path to an existing file that the process can read, and an arbitrary id character. It combines information about the file (like its inode number) with the id to generate a probably-unique key.

Chapter 2: msgget() — Creating or Connecting

Once you have a key, you create (or connect to) a message queue with msgget():

c
#include <sys/msg.h>

int msqid;
key_t key;

key = ftok("/home/beej/somefile", 'b');
msqid = msgget(key, 0666 | IPC_CREAT);

msgget() returns a message queue ID on success, or -1 on failure. The arguments:

The 0666 sets rw-rw-rw- permissions. The IPC_CREAT flag means "create the queue if it doesn't exist; if it does, just connect to it." The receiver typically connects without IPC_CREAT, relying on the sender to create it first.

Chapter 3: struct msgbuf — Message Format

Every message has the same structure: a long type field followed by the actual data. The template is in <sys/msg.h>:

c
struct msgbuf {
    long mtype;     /* message type, must be > 0 */
    char mtext[1];  /* message data */
};

But you're not stuck with a one-byte payload! You can define your own struct, as long as the first field is a long:

c
struct my_msgbuf {
    long mtype;            /* must be first, must be positive */
    char mtext[200];       /* the actual message data */
};

/* Or get fancy: */
struct pirate_msgbuf {
    long mtype;
    struct pirate_info {
        char name[30];
        char ship_type;
        int notoriety;
        int cruelty;
        int booty_value;
    } info;
};

Chapter 4: msgsnd() — Sending Messages

To put a message onto the queue, you use msgsnd():

c
int msgsnd(int msqid, const void *msgp,
          size_t msgsz, int msgflg);

The tricky part is msgsz. It's the size of the data only — you subtract the size of the long mtype field:

c
struct my_msgbuf buf;
buf.mtype = 1;
strcpy(buf.mtext, "Hello, queue!");

/* size = total struct - sizeof(long) */
msgsnd(msqid, &buf,
       sizeof(struct my_msgbuf) - sizeof(long), 0);

Chapter 5: msgrcv() — Receiving Messages

The real magic happens on the receiving end. msgrcv() can pull messages selectively by type:

c
int msgrcv(int msqid, void *msgp, size_t msgsz,
           long msgtyp, int msgflg);

The msgtyp argument is the key to selective retrieval. Its behavior depends on its value:

c
struct my_msgbuf buf;

/* Get the next type-2 message */
msgrcv(msqid, &buf,
       sizeof(buf.mtext), 2, 0);

/* Get ANY next message (type 0 = any) */
msgrcv(msqid, &buf,
       sizeof(buf.mtext), 0, 0);

Chapter 6: Destroying a Message Queue

Message queues don't disappear when processes exit. You must explicitly destroy them. There are two ways:

c
#include <sys/msg.h>

/* Destroy the message queue */
msgctl(msqid, IPC_RMID, NULL);

The msgctl() function does many things, but IPC_RMID is the most common use: it removes the message queue immediately. Any blocked msgrcv() calls on other processes will return with an error.

Chapter 7: kirk.c & spock.c — The Full Example

Beej's classic example uses two programs: kirk (the sender) adds messages to the queue, and spock (the receiver) pulls them out.

kirk.c (sender)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

struct my_msgbuf {
    long mtype;
    char mtext[200];
};

int main(void) {
    struct my_msgbuf buf;
    int msqid;
    key_t key;

    key = ftok("kirk.c", 'B');
    msqid = msgget(key, 0644 | IPC_CREAT);

    printf("Enter lines of text, ^D to quit:\n");
    buf.mtype = 1;

    while (fgets(buf.mtext, sizeof buf.mtext, stdin) != NULL) {
        int len = strlen(buf.mtext);
        if (buf.mtext[len-1] == '\n')
            buf.mtext[len-1] = '\0';
        msgsnd(msqid, &buf, len+1, 0);
    }

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

spock.c (receiver)
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

struct my_msgbuf {
    long mtype;
    char mtext[200];
};

int main(void) {
    struct my_msgbuf buf;
    int msqid;
    key_t key;

    key = ftok("kirk.c", 'B');   /* same key as kirk */
    msqid = msgget(key, 0644);   /* no IPC_CREAT */

    printf("spock: ready to receive messages, captain.\n");
    for(;;) {
        msgrcv(msqid, &buf,
               sizeof(buf.mtext), 0, 0);
        printf("spock: \"%s\"\n", buf.mtext);
    }
    return 0;
}

Chapter 8: Message Queue Simulator

Watch typed messages flow through a System V message queue. Send messages with different types, then retrieve them — either in FIFO order (type 0) or selectively by type.

Chapter 9: Beyond Message Queues

Message queues are powerful but have some quirks:

• Persistence: Queues survive process death. Forgotten queues leak kernel resources.
• Size limits: The system has limits on message size and total queue size. Check with sysctl.
• System V heritage: These are "old-school" IPC. POSIX message queues (mq_open, etc.) are a more modern alternative with similar functionality.

"spock: ready to receive messages, captain." — Beej