When you open a regular file, the kernel gives you back a file descriptor — a small integer that is local to your process. File descriptors live in a per-process table and have no meaning outside that process.

Message queues work differently. The handle used to refer to a message queue is the IPC identifier returned by msgget(). This identifier is a property of the object itself, not of any particular process. Any process that knows the identifier can use it directly — no need to call msgget() again if you already know the ID.

/* Opening a file — fd is per-process */
int fd = open("/tmp/myfile.txt", O_RDONLY);
/* fd is only meaningful in THIS process */

/* Opening a message queue — msqid is system-wide */
key_t key = ftok("/tmp/myfile.txt", 'A');
int msqid = msgget(key, IPC_CREAT | 0660);
/* msqid can be used by ANY process that knows it */

/* Another process can look up the same queue */
int msqid2 = msgget(key, 0);  /* same key → same msqid */
/* msqid == msqid2 — the same object */

A pipe is a byte stream — data written at one end flows out the other end as a continuous sequence of bytes. The reader can read any number of bytes at a time. There are no boundaries between writes.

A message queue is message-oriented. Each call to msgsnd() writes one complete, self-contained message. Each call to msgrcv() reads exactly one complete message. You cannot read half a message and leave the rest, and you cannot read two messages in one call.

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <stdio.h>

/* Define a message structure — always starts with a long mtype */
struct my_message {
    long mtype;       /* Message type — MUST be first, MUST be > 0 */
    char text[128];   /* Message data payload */
};

/* --- WRITER process --- */
void writer_example(int msqid) {
    struct my_message msg;

    /* Send message type 1 */
    msg.mtype = 1;
    strncpy(msg.text, "Hello from writer!", sizeof(msg.text));
    msgsnd(msqid, &msg, sizeof(msg.text), 0);
    /* One msgsnd() = one complete, atomic message on the queue */

    /* Send another message type 2 */
    msg.mtype = 2;
    strncpy(msg.text, "Data block contents", sizeof(msg.text));
    msgsnd(msqid, &msg, sizeof(msg.text), 0);
}

/* --- READER process --- */
void reader_example(int msqid) {
    struct my_message msg;

    /* Read ANY message (mtype=0 means take the first one in FIFO order) */
    msgrcv(msqid, &msg, sizeof(msg.text), 0, 0);
    printf("Got: [type=%ld] %s\n", msg.mtype, msg.text);
    /*
     * msgrcv() ALWAYS returns exactly one complete message.
     * You cannot read half a message or skip part of it.
     * The message is REMOVED from the queue upon successful read.
     */
}

The most powerful feature distinguishing message queues from pipes is the integer type field. Every message carries a long integer type value (must be > 0). When calling msgrcv(), you can control which message you want:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>

#define MSG_TYPE_REQUEST  1
#define MSG_TYPE_RESPONSE 2
#define MSG_TYPE_ERROR    3

struct mymsg {
    long mtype;
    char data[256];
};

/*
 * Demonstrates all three retrieval modes.
 * Assume msqid is a valid message queue with several messages.
 */
void retrieval_modes(int msqid) {
    struct mymsg msg;
    ssize_t bytes;

    /* Mode 1: FIFO — get whatever came first */
    bytes = msgrcv(msqid, &msg, sizeof(msg.data), 0, 0);
    printf("FIFO mode: got type=%ld, data='%s'\n", msg.mtype, msg.data);

    /* Mode 2: Exact type — only get a response message */
    bytes = msgrcv(msqid, &msg, sizeof(msg.data), MSG_TYPE_RESPONSE, 0);
    printf("Exact type: got response: '%s'\n", msg.data);

    /* Mode 3: Priority — get the lowest-numbered type first */
    /* With mtype=-5, returns first msg with type in {1,2,3,4,5}, lowest first */
    bytes = msgrcv(msqid, &msg, sizeof(msg.data), -5, 0);
    printf("Priority mode: got type=%ld (highest priority)\n", msg.mtype);
}

/*
 * Classic client-server pattern using types:
 *   - Clients send type=1 (request)
 *   - Server replies with type=client_pid (so each client gets its own reply)
 */
void client_server_pattern(int msqid) {
    struct mymsg msg;

    /* CLIENT: send a request */
    msg.mtype = MSG_TYPE_REQUEST;
    snprintf(msg.data, sizeof(msg.data), "PID=%d: please process this", (int)getpid());
    msgsnd(msqid, &msg, strlen(msg.data) + 1, 0);

    /* CLIENT: wait for a reply addressed specifically to this PID */
    msgrcv(msqid, &msg, sizeof(msg.data), (long)getpid(), 0);
    printf("Client got reply: %s\n", msg.data);

    /* SERVER (in another process):
       reads type=1, processes it, replies with type=sender_pid */
}

The TLPI text explicitly notes that message queues have limitations (covered fully in Section 46.9), and that new applications should prefer FIFOs, POSIX message queues, or sockets where possible. But understanding what message queues do better than pipes is equally important.

/*
 * EXAMPLE: Why message boundaries matter
 *
 * With a PIPE, the writer must encode message length manually.
 * With a message queue, boundaries are automatic.
 */

/* ---- PIPE approach: manual framing ---- */
#include <unistd.h>
#include <stdint.h>
#include <string.h>

void pipe_send(int fd, const char *data, size_t len) {
    /* Must send the length first, then data */
    uint32_t nlen = (uint32_t)len;
    write(fd, &nlen, sizeof(nlen));  /* 4-byte length prefix */
    write(fd, data, len);            /* actual data */
}

void pipe_recv(int fd, char *buf, size_t bufsize) {
    uint32_t nlen;
    read(fd, &nlen, sizeof(nlen));   /* read length first */
    read(fd, buf, nlen);             /* then read exactly that many bytes */
    /* This is fragile — partial reads, blocking, etc. */
}

/* ---- Message Queue approach: automatic framing ---- */
#include <sys/msg.h>

struct packet {
    long mtype;
    char data[256];
};

void mq_send(int msqid, const char *data, long type) {
    struct packet pkt;
    pkt.mtype = type;
    strncpy(pkt.data, data, sizeof(pkt.data));
    msgsnd(msqid, &pkt, strlen(pkt.data) + 1, 0);
    /* No length prefix needed — msgrcv always returns one complete message */
}

void mq_recv(int msqid, char *buf, long type) {
    struct packet pkt;
    msgrcv(msqid, &pkt, sizeof(pkt.data), type, 0);
    strncpy(buf, pkt.data, sizeof(pkt.data));
    /* Automatically got one complete message, nothing more, nothing less */
}

The msgget() system call is the entry point for working with message queues. It either creates a new queue or returns the identifier of an existing one, depending on the key and flags.

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

int msgget(key_t key, int msgflg);
/* Returns: message queue identifier on success, -1 on error */

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

int main(void) {
    key_t key;
    int msqid;

    /* Step 1: Generate a key from an existing file */
    key = ftok("/tmp", 'M');
    if (key == -1) { perror("ftok"); exit(EXIT_FAILURE); }

    /* Step 2: Create a new message queue */
    /* S_IRUSR | S_IWUSR = owner can read and write (0600) */
    msqid = msgget(key, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
    if (msqid == -1) {
        if (errno == EEXIST) {
            printf("Queue already exists. Opening existing queue...\n");
            /* Open existing queue (no IPC_CREAT, no IPC_EXCL) */
            msqid = msgget(key, 0);
            if (msqid == -1) { perror("msgget open"); exit(EXIT_FAILURE); }
        } else {
            perror("msgget create");
            exit(EXIT_FAILURE);
        }
    }

    printf("Message queue ID: %d\n", msqid);

    /*
     * Verify with shell:
     *   ipcs -q
     * Should show a new entry with the msqid above.
     *
     * Delete the queue when done:
     *   ipcrm -q 
     */

    return 0;
}

The following end-to-end example shows a parent creating a queue, a child sending messages of different types, and the parent receiving them selectively by type — demonstrating the core message queue workflow.

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <wait.h>

#define MSG_TYPE_PING  1
#define MSG_TYPE_DATA  2
#define MSG_TYPE_DONE  3

struct msg_buf {
    long mtype;
    char text[128];
};

int main(void) {
    int msqid;
    struct msg_buf msg;
    pid_t pid;

    /* Create a private message queue (IPC_PRIVATE = always new, unique) */
    msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0600);
    if (msqid == -1) { perror("msgget"); exit(1); }
    printf("Created queue, msqid = %d\n", msqid);

    pid = fork();
    if (pid == -1) { perror("fork"); exit(1); }

    if (pid == 0) {
        /* ===== CHILD: sends messages ===== */

        msg.mtype = MSG_TYPE_PING;
        strcpy(msg.text, "Are you alive?");
        msgsnd(msqid, &msg, strlen(msg.text)+1, 0);

        msg.mtype = MSG_TYPE_DATA;
        strcpy(msg.text, "Temperature=36.5");
        msgsnd(msqid, &msg, strlen(msg.text)+1, 0);

        msg.mtype = MSG_TYPE_DATA;
        strcpy(msg.text, "Humidity=72%");
        msgsnd(msqid, &msg, strlen(msg.text)+1, 0);

        msg.mtype = MSG_TYPE_DONE;
        strcpy(msg.text, "All done.");
        msgsnd(msqid, &msg, strlen(msg.text)+1, 0);

        printf("Child: sent 4 messages\n");
        exit(0);
    }

    /* ===== PARENT: receives messages selectively ===== */
    wait(NULL);  /* wait for child to finish sending */

    /* Read only DATA messages first */
    printf("\n--- Receiving DATA messages ---\n");
    while (msgrcv(msqid, &msg, sizeof(msg.text), MSG_TYPE_DATA, IPC_NOWAIT) != -1)
        printf("DATA: %s\n", msg.text);

    /* Now read the PING */
    printf("\n--- Receiving PING ---\n");
    if (msgrcv(msqid, &msg, sizeof(msg.text), MSG_TYPE_PING, 0) != -1)
        printf("PING: %s\n", msg.text);

    /* Read the DONE signal */
    printf("\n--- Receiving DONE ---\n");
    if (msgrcv(msqid, &msg, sizeof(msg.text), MSG_TYPE_DONE, 0) != -1)
        printf("DONE: %s\n", msg.text);

    /* Delete the queue */
    if (msgctl(msqid, IPC_RMID, NULL) == -1)
        perror("msgctl IPC_RMID");
    else
        printf("\nQueue deleted.\n");

    /*
     * Expected output:
     * Created queue, msqid = 
     * Child: sent 4 messages
     *
     * --- Receiving DATA messages ---
     * DATA: Temperature=36.5
     * DATA: Humidity=72%
     *
     * --- Receiving PING ---
     * PING: Are you alive?
     *
     * --- Receiving DONE ---
     * DONE: All done.
     *
     * Queue deleted.
     *
     * Notice: DATA messages were read BEFORE PING even though PING
     * was sent first — that is type-based selective retrieval.
     */
    return 0;
}

TLPI (Section 46.9, previewed here) lists several reasons why System V message queues are considered a legacy mechanism:

/*
 * POSIX message queue (modern alternative) — for comparison
 * Compile with: gcc -o posix_mq posix_mq.c -lrt
 */
#include <mqueue.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>

int main(void) {
    mqd_t mq;
    char buf[256];

    /* Create or open a POSIX message queue */
    mq = mq_open("/my_queue", O_CREAT | O_RDWR, 0600, NULL);
    /* mq is a file-descriptor-like handle — works with poll/select! */

    /* Send a message (no struct, no mtype boilerplate) */
    mq_send(mq, "hello world", 11, 1 /* priority */);

    /* Receive a message */
    unsigned prio;
    mq_receive(mq, buf, sizeof(buf), &prio);
    printf("Got: %s (priority %u)\n", buf, prio);

    mq_close(mq);
    mq_unlink("/my_queue");  /* Remove from filesystem — auto-cleanup */
    return 0;
}
/*
 * Key differences from System V:
 *   - Named by path (/my_queue) not by integer key
 *   - mq_unlink() removes it like a file (no lingering IPC objects)
 *   - mqd_t works with poll()/select() for event-driven I/O
 *   - Priority replaces type — always highest priority first
 */