DESCRIPTION

The msgsnd() and msgrcv() system calls are used to send messages to, and receive messages from, a System V message queue. The calling process must have write permission on the message queue in order to send a message, and read permission to receive a message.

The msgp argument is a pointer to a caller-defined structure of the following general form:

The mtext field is an array (or other structure) whose size is specified by msgsz, a nonnegative integer value. Messages of zero length (i.e., no mtext field) are permitted. The mtype field must have a strictly positive integer value. This value can be used by the receiving process for message selection (see the description of msgrcv() below).

RETURN VALUE

On failure both functions return −1 with errno indicating the error, otherwise msgsnd() returns 0 and msgrcv() returns the number of bytes actually copied into the mtext array.

ERRORS

When msgsnd() fails, errno will be set to one among the following values:

When msgrcv() fails, errno will be set to one among the following values:

CONFORMING TO

POSIX.1-2001, POSIX.1-2008, SVr4.

The MSG_EXCEPT and MSG_COPY flags are Linux-specific; their definitions can be obtained by defining the _GNU_SOURCE feature test macro.

NOTES

The inclusion of <sys/types.h> and <sys/ipc.h> isn_zsingle_quotesz_t required on Linux or by any version of POSIX. However, some old implementations required the inclusion of these header files, and the SVID also documented their inclusion. Applications intended to be portable to such old systems may need to include these header files.

The msgp argument is declared as struct msgbuf * in glibc 2.0 and 2.1. It is declared as void * in glibc 2.2 and later, as required by SUSv2 and SUSv3.

The following limits on message queue resources affect the msgsnd() call:

The implementation has no intrinsic system-wide limits on the number of message headers (MSGTQL) and the number of bytes in the message pool (MSGPOOL).

BUGS

In Linux 3.13 and earlier, if msgrcv() was called with the MSG_COPY flag, but without IPC_NOWAIT, and the message queue contained less than msgtyp messages, then the call would block until the next message is written to the queue. At that point, the call would return a copy of the message, regardless of whether that message was at the ordinal position msgtyp. This bug is fixed in Linux 3.14.

Specifying both MSG_COPY and MSC_EXCEPT in msgflg is a logical error (since these flags impose different interpretations on msgtyp). In Linux 3.13 and earlier, this error was not diagnosed by msgrcv(). This bug is fixed in Linux 3.14.

EXAMPLE

The program below demonstrates the use of msgsnd() and msgrcv().

The example program is first run with the −s option to send a message and then run again with the −r option to receive a message.

The following shell session shows a sample run of the program:

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

struct msgbuf {
    long mtype;
    char mtext[80];
};

static void
usage(char *prog_name, char *msg)
{
    if (msg != NULL)
        fputs(msg, stderr);

    fprintf(stderr, Usage: %s [options]
, prog_name);
    fprintf(stderr, Options are:
);
    fprintf(stderr, −s        send message using msgsnd()
);
    fprintf(stderr, −r        read message using msgrcv()
);
    fprintf(stderr, −t        message type (default is 1)
);
    fprintf(stderr, −k        message queue key (default is 1234)
);
    exit(EXIT_FAILURE);
}

static void
send_msg(int qid, int msgtype)
{
    struct msgbuf msg;
    time_t t;

    msg.mtype = msgtype;

    time(&t);
    snprintf(msg.mtext, sizeof(msg.mtext), a message at %s,
            ctime(&t));

    if (msgsnd(qid, (void *) &msg, sizeof(msg.mtext),
                IPC_NOWAIT) == −1) {
        perror(msgsnd error);
        exit(EXIT_FAILURE);
    }
    printf(sent: %s
, msg.mtext);
}

static void
get_msg(int qid, int msgtype)
{
    struct msgbuf msg;

    if (msgrcv(qid, (void *) &msg, sizeof(msg.mtext), msgtype,
               MSG_NOERROR | IPC_NOWAIT) == −1) {
        if (errno != ENOMSG) {
            perror(msgrcv);
            exit(EXIT_FAILURE);
        }
        printf(No message available for msgrcv()
);
    } else
        printf(message received: %s
, msg.mtext);
}

int
main(int argc, char *argv[])
{
    int qid, opt;
    int mode = 0;               /* 1 = send, 2 = receive */
    int msgtype = 1;
    int msgkey = 1234;

    while ((opt = getopt(argc, argv, srt:k:)) != −1) {
        switch (opt) {
        case _zsingle_quotesz_s_zsingle_quotesz_:
            mode = 1;
            break;
        case _zsingle_quotesz_r_zsingle_quotesz_:
            mode = 2;
            break;
        case _zsingle_quotesz_t_zsingle_quotesz_:
            msgtype = atoi(optarg);
            if (msgtype <= 0)
                usage(argv[0], −t option must be greater than 0
);
            break;
        case _zsingle_quotesz_k_zsingle_quotesz_:
            msgkey = atoi(optarg);
            break;
        default:
            usage(argv[0], Unrecognized option
);
        }
    }

    if (mode == 0)
        usage(argv[0], must use either −s or −r option
);

    qid = msgget(msgkey, IPC_CREAT | 0666);

    if (qid == −1) {
        perror(msgget);
        exit(EXIT_FAILURE);
    }

    if (mode == 2)
        get_msg(qid, msgtype);
    else
        send_msg(qid, msgtype);

    exit(EXIT_SUCCESS);
}

SEE ALSO

msgctl(2), msgget(2), capabilities(7), mq_overview(7), sysvipc(7)