Here is the official function signature of msgsnd():

#include <sys/types.h>   /* For portability */
#include <sys/msg.h>

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

/* Returns: 0 on success, -1 on error */

Let’s understand every argument one by one:

A message in System V IPC is NOT just raw bytes. It must be structured as a C struct with a specific layout. The kernel requires this structure to carry a message type as the first field.

The standard template defined in <sys/msg.h> is:

struct msgbuf {
    long mtype;    /* Message type — MUST be > 0 */
    char mtext[1]; /* Message body — variable length */
};

In practice, you define your own structure with the same layout but a larger (or differently typed) body:

#define MAX_MTEXT 1024

struct my_msg {
    long mtype;             /* Message type — must be > 0 */
    char mtext[MAX_MTEXT];  /* Message body — your actual data */
};

A message queue has a maximum capacity — measured both in total bytes and total number of messages. These limits are controlled by kernel parameters (MSGMNB for max bytes per queue, MSGMNI for max number of queues system-wide).

When a process calls msgsnd() and the queue is already full (no space for the new message), the behavior depends on the msgflg argument:

When you do not want your process to sleep waiting for queue space, you pass IPC_NOWAIT as the msgflg argument. This makes msgsnd() behave like a non-blocking write.

The name IPC_NOWAIT is analogous to O_NONBLOCK used with pipes and FIFOs, but the error code differs. With pipes, a non-blocking write that cannot proceed returns EAGAIN, and this is also the case with msgsnd() + IPC_NOWAIT.

Sending a message to a queue requires write permission on the queue. Message queue permissions work like file permissions — they have owner, group, and other permission bits.

These permissions are set when the queue is created with msgget() by providing appropriate flags in the msgflg argument of msgget(). For example, 0666 gives read+write permission to owner, group, and others.

When you call write() on a file or pipe, it is possible for the system to write only part of the requested bytes and return the count of bytes written. You must then loop and write the rest.

With msgsnd(), this does NOT happen. A message is always sent as an atomic unit — either the entire message is placed on the queue, or nothing is placed (and an error is returned). This is why msgsnd() returns only 0 on success, not the number of bytes written. There is no need to loop.

This example creates a message queue, sends a simple text message of type 1, and prints the result. This is the minimal working example.

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

/* Define our message structure */
#define MAX_MTEXT 256

struct my_msg {
    long mtype;           /* Message type — must be > 0 */
    char mtext[MAX_MTEXT]; /* Message body */
};

int main(void)
{
    int msqid;
    struct my_msg msg;
    key_t key;

    /* Step 1: Generate a unique key for the queue */
    key = ftok("/tmp", 'A');
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    /* Step 2: Create or open the message queue */
    /* IPC_CREAT | 0666 — create if not exists, rw for all */
    msqid = msgget(key, IPC_CREAT | 0666);
    if (msqid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }
    printf("Message queue created. ID = %d\n", msqid);

    /* Step 3: Build the message */
    msg.mtype = 1;   /* Type must be > 0 */
    strncpy(msg.mtext, "Hello from sender process!", MAX_MTEXT - 1);
    msg.mtext[MAX_MTEXT - 1] = '\0';

    /* Step 4: Send the message */
    /* msgsz = strlen + 1 for null terminator, msgflg = 0 (blocking) */
    if (msgsnd(msqid, &msg, strlen(msg.mtext) + 1, 0) == -1) {
        perror("msgsnd");
        exit(EXIT_FAILURE);
    }

    printf("Message sent successfully: \"%s\" (type=%ld)\n",
           msg.mtext, msg.mtype);

    return 0;
}

/* Compile: gcc -o basic_send basic_send.c
   Run:    ./basic_send
   Check queue: ipcs -q */

This example demonstrates how to use IPC_NOWAIT to avoid blocking when the queue is full. It sends multiple messages and handles the EAGAIN error gracefully.

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

#define MAX_MTEXT 64

struct task_msg {
    long mtype;
    char mtext[MAX_MTEXT];
};

int main(void)
{
    int msqid;
    struct task_msg msg;
    key_t key;
    int i, sent = 0, failed = 0;

    key = ftok("/tmp", 'B');
    if (key == -1) { perror("ftok"); exit(EXIT_FAILURE); }

    msqid = msgget(key, IPC_CREAT | 0666);
    if (msqid == -1) { perror("msgget"); exit(EXIT_FAILURE); }

    printf("Queue ID: %d\n", msqid);
    printf("Sending messages with IPC_NOWAIT...\n");

    for (i = 1; i <= 20; i++) {
        msg.mtype = (i % 3) + 1;  /* Types 1, 2, 3 in rotation */
        snprintf(msg.mtext, MAX_MTEXT, "Task-%d", i);

        if (msgsnd(msqid, &msg, strlen(msg.mtext) + 1, IPC_NOWAIT) == -1) {
            if (errno == EAGAIN) {
                /* Queue is full — don't block, just skip */
                printf("  [SKIP] Queue full, cannot send Task-%d (EAGAIN)\n", i);
                failed++;
            } else {
                perror("msgsnd");
                break;
            }
        } else {
            printf("  [OK]   Sent Task-%d (type=%ld)\n", i, msg.mtype);
            sent++;
        }
    }

    printf("\nSummary: %d sent, %d skipped due to full queue\n", sent, failed);

    /* Clean up the queue */
    if (msgctl(msqid, IPC_RMID, NULL) == -1)
        perror("msgctl IPC_RMID");

    return 0;
}

/* Compile: gcc -o nowait_send nowait_send.c
   Run:    ./nowait_send */

Since msgsnd() is never automatically restarted after a signal, we must manually retry on EINTR. This example shows a robust wrapper function that does exactly that.

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

#define MAX_MTEXT 128

struct my_msg {
    long mtype;
    char mtext[MAX_MTEXT];
};

/* Signal handler — just sets a flag */
static volatile sig_atomic_t got_signal = 0;

void sig_handler(int sig)
{
    got_signal = 1;
    printf("\n[Signal received: %d]\n", sig);
}

/*
 * msgsnd_robust() — wraps msgsnd() with EINTR retry logic.
 * msgsnd() is NOT auto-restarted even with SA_RESTART set.
 * So we must retry manually when interrupted by a signal.
 */
int msgsnd_robust(int msqid, const void *msgp, size_t msgsz, int msgflg)
{
    int ret;
    while (1) {
        ret = msgsnd(msqid, msgp, msgsz, msgflg);
        if (ret == -1 && errno == EINTR) {
            /* Signal interrupted us — check our flag and retry */
            printf("[msgsnd_robust] Interrupted by signal, retrying...\n");
            if (got_signal) {
                printf("[msgsnd_robust] Signal was handled, continuing\n");
                got_signal = 0;
            }
            /* Loop again to retry */
            continue;
        }
        break; /* Success or a real error */
    }
    return ret;
}

int main(void)
{
    int msqid;
    struct my_msg msg;
    key_t key;
    struct sigaction sa;

    /* Install signal handler for SIGINT (Ctrl+C) */
    sa.sa_handler = sig_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0; /* No SA_RESTART — msgsnd won't restart anyway */
    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction");
        exit(EXIT_FAILURE);
    }

    key = ftok("/tmp", 'C');
    if (key == -1) { perror("ftok"); exit(EXIT_FAILURE); }

    msqid = msgget(key, IPC_CREAT | 0666);
    if (msqid == -1) { perror("msgget"); exit(EXIT_FAILURE); }

    msg.mtype = 5;
    strncpy(msg.mtext, "Important message — retry on EINTR", MAX_MTEXT - 1);

    printf("Sending message (try Ctrl+C to send SIGINT)...\n");

    /* Use our robust wrapper */
    if (msgsnd_robust(msqid, &msg, strlen(msg.mtext) + 1, 0) == -1) {
        perror("msgsnd_robust");
    } else {
        printf("Message sent successfully!\n");
    }

    /* Cleanup */
    msgctl(msqid, IPC_RMID, NULL);
    return 0;
}

/* Compile: gcc -o eintr_send eintr_send.c
   Run:    ./eintr_send
   Press Ctrl+C quickly after starting to test EINTR handling */

The msgsz argument is a critical parameter and many programmers get it wrong. Here is the exact rule:

msgsz = number of bytes in the mtext field ONLY

It does NOT include the size of the mtype field (which is a long).

However, if your mtext is a fixed-size struct (not a string), you use sizeof(msg.mtext):

struct sensor_data {
    long mtype;
    struct {
        int temperature;
        int pressure;
        float voltage;
    } mtext;
};

struct sensor_data m;
m.mtype = 2;
m.mtext.temperature = 35;
m.mtext.pressure = 1013;
m.mtext.voltage = 3.3f;

/* msgsz = sizeof the mtext struct, NOT sizeof the whole message */
msgsnd(msqid, &m, sizeof(m.mtext), 0);

These are common interview and exam questions for Linux system programming roles.