/* Example: Trying to monitor both a pipe and a SysV MQ simultaneously */

/* This works fine for pipes/sockets/FIFOs: */
struct pollfd fds[2];
fds[0].fd = pipe_fd;      /* pipe read end - OK */
fds[0].events = POLLIN;

/* You CANNOT do this for a SysV message queue: */
/* fds[1].fd = mqid;      <-- mqid is NOT an fd, this is WRONG */

/* The workaround: use a separate thread that blocks on msgrcv() */
/* and signals the main thread via a pipe when a message arrives */

/* Thread approach (complex): */
void *mq_watcher(void *arg) {
    int   mqid   = *(int *)arg;
    int   pipefd = ((int *)arg)[1];   /* write end of notification pipe */
    char  buf[512];
    char  notify = 1;
    /* Block waiting for any message */
    while (msgrcv(mqid, buf, sizeof(buf), 0, 0) != -1) {
        /* Wake up main thread via pipe */
        write(pipefd, &notify, 1);
    }
    return NULL;
}
/* Now main thread can poll() on pipe_fd instead */

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

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

    /* Generate a key from a file path and a project number (1-255) */
    key = ftok("/tmp/myapp_ipc", 'A');
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    printf("Generated key: 0x%x\n", (unsigned)key);

    /* Problem: if /tmp/myapp_ipc is deleted and recreated,
       ftok() returns a DIFFERENT key even for the same path! */

    /* Using IPC_PRIVATE avoids this but requires sharing the ID
       out-of-band (e.g., via a file, environment variable, or
       inheritance through fork): */
    mqid = msgget(IPC_PRIVATE, 0600);
    if (mqid == -1) {
        perror("msgget");
        return 1;
    }
    printf("Private queue ID: %d\n", mqid);
    /* Now you must somehow tell other processes this mqid...
       e.g., write it to a well-known file:             */
    FILE *fp = fopen("/tmp/myapp.mqid", "w");
    fprintf(fp, "%d\n", mqid);
    fclose(fp);

    /* To list all SysV IPC objects: run 'ipcs -q' in shell */
    /* To delete: run 'ipcrm -q <mqid>' or call msgctl()   */
    return 0;
}

#include <sys/msg.h>
#include <signal.h>
#include <stdlib.h>

static int g_mqid = -1;

/* Signal handler to clean up queue on crash/termination */
void cleanup_handler(int sig)
{
    if (g_mqid != -1) {
        msgctl(g_mqid, IPC_RMID, NULL);
        g_mqid = -1;
    }
    /* Re-raise to get default behavior (core dump, etc.) */
    signal(sig, SIG_DFL);
    raise(sig);
}

int main(void)
{
    /* Register cleanup on common termination signals */
    signal(SIGTERM, cleanup_handler);
    signal(SIGINT,  cleanup_handler);
    signal(SIGHUP,  cleanup_handler);
    /* Note: SIGKILL and SIGSTOP cannot be caught — queue may leak */

    g_mqid = msgget(IPC_PRIVATE, 0600);
    if (g_mqid == -1) { perror("msgget"); return 1; }

    /* ... use the queue ... */

    /* Normal exit: clean up manually */
    msgctl(g_mqid, IPC_RMID, NULL);
    return 0;
}

/* To see leaked queues from the shell:
   $ ipcs -q
   To clean up manually:
   $ ipcrm -q <msqid>  */

/* Check current system limits from a program */
#include <stdio.h>

int main(void)
{
    FILE *fp;
    long  val;

    /* Maximum number of queues */
    fp = fopen("/proc/sys/kernel/msgmni", "r");
    fscanf(fp, "%ld", &val);
    fclose(fp);
    printf("Max message queues: %ld\n", val);

    /* Maximum single message size */
    fp = fopen("/proc/sys/kernel/msgmax", "r");
    fscanf(fp, "%ld", &val);
    fclose(fp);
    printf("Max message size  : %ld bytes\n", val);

    /* Maximum total bytes in one queue */
    fp = fopen("/proc/sys/kernel/msgmnb", "r");
    fscanf(fp, "%ld", &val);
    fclose(fp);
    printf("Max queue capacity: %ld bytes\n", val);

    return 0;
}

/* To raise the limit (as root):
   echo 65536 > /proc/sys/kernel/msgmnb
   Or permanently in /etc/sysctl.conf:
   kernel.msgmnb = 65536               */

The book recommends these alternatives when you need message-based IPC:

#include <mqueue.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    mqd_t mq;
    struct mq_attr attr;
    char  buf[256];
    unsigned int prio;

    attr.mq_flags   = 0;
    attr.mq_maxmsg  = 10;
    attr.mq_msgsize = 256;
    attr.mq_curmsgs = 0;

    /* Create/open by name - like a file path */
    mq = mq_open("/myqueue", O_CREAT | O_RDWR, 0600, &attr);
    if (mq == (mqd_t)-1) { perror("mq_open"); return 1; }

    /* Send with a priority (higher number = higher priority) */
    mq_send(mq, "hello", 5, 10);   /* priority 10 */
    mq_send(mq, "urgent", 6, 20);  /* priority 20 - received FIRST */

    /* Receive: always gets highest priority message first */
    mq_receive(mq, buf, 256, &prio);
    printf("Got: '%s' (prio=%u)\n", buf, prio);  /* urgent, 20 */

    mq_close(mq);
    mq_unlink("/myqueue");   /* like rm for FIFOs */
    return 0;
}
/* Compile: gcc prog.c -lrt  */

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <poll.h>
#include <unistd.h>

#define FIFO_NORMAL   "/tmp/fifo_normal"
#define FIFO_PRIORITY "/tmp/fifo_priority"

int main(void)
{
    int fd_normal, fd_prio;
    struct pollfd fds[2];
    char buf[256];
    int  ready;

    /* Create two FIFOs */
    mkfifo(FIFO_NORMAL,   0600);
    mkfifo(FIFO_PRIORITY, 0600);

    /* Open both (non-blocking so open() doesn't block waiting
       for the other end) */
    fd_prio   = open(FIFO_PRIORITY, O_RDONLY | O_NONBLOCK);
    fd_normal = open(FIFO_NORMAL,   O_RDONLY | O_NONBLOCK);

    fds[0].fd = fd_prio;    /* index 0 = priority channel */
    fds[0].events = POLLIN;
    fds[1].fd = fd_normal;  /* index 1 = normal channel   */
    fds[1].events = POLLIN;

    /* Wait for input on either FIFO */
    ready = poll(fds, 2, 5000);  /* 5-second timeout */

    if (ready > 0) {
        /* Always check priority channel first */
        if (fds[0].revents & POLLIN) {
            read(fd_prio, buf, sizeof(buf));
            printf("Priority message: %s\n", buf);
        } else if (fds[1].revents & POLLIN) {
            read(fd_normal, buf, sizeof(buf));
            printf("Normal message: %s\n", buf);
        }
    }

    close(fd_prio); close(fd_normal);
    unlink(FIFO_PRIORITY); unlink(FIFO_NORMAL);
    return 0;
}
/* Advantage: works with select/poll, named by path, reference-counted */