msgsnd()¶

S'il y a assez de place dans la file, msgsnd() réussit immédiatement. La capacité de la file est régie par le champ msg_qbytes de la structure associée à la file de messages. Durant la création de la file, ce champ est initialisé à MSGMNB octets, mais cette limite peut être modifiée avec msgctl(2). Une file de message est considérée pleine si une de ces conditions est remplie :

• Après l'ajout d'un message à la file, le nombre total d'octets dans la file aurait dépassé la taille maximale de la file (champ msg_qbytes).
• Après l'ajout d'un message à la file, le nombre total de messages dans la file aurait dépassé la taille maximale de la file (champ msg_qbytes).Cette vérification permet d'éviter qu'un nombre illimité de messages de taille nulle soit ajouté à la file. Bien que tels messages ne contiennent pas de données, ils consomment néanmoins de la mémoire du noyau, sujette à un verrou.

S'il n'y a pas assez de place, alors le comportement par défaut de msgsnd() est de bloquer jusqu'à obtenir suffisamment d'espace. En indiquant IPC_NOWAIT dans l'argument msgflg, le message ne sera pas envoyé et l'appel système échouera en retournant EAGAIN dans errno.

Un appel à msgsnd() bloqué peut échouer si :

• la file est supprimée, auquel cas l'appel système échoue avec errno valant EIDRM ; ou
• un signal a été intercepté, auquel cas l'appel système échoue avec errno valant EINTR ; consultez signal(7). (msgsnd() n'est jamais relancé automatiquement après interruption par un gestionnaire de signal, quelle que soit la configuration de SA_RESTART lors de l'installation du gestionnaire.)

Si l'appel système réussit, la structure décrivant la file de messages est mise à jour comme suit.

msg_lspid contient le PID du processus appelant.

msg_qnum est incrémenté de 1.

msg_stime est rempli avec l'heure actuelle.

msgrcv()¶

L'argument msgsz indique la taille maximale en octets du membre mtext de la structure pointée par l'argument msgp. Si le contenu du message est plus long que msgsz octets, le comportement dépend de la présence ou non de MSG_NOERROR dans msgflg. Si MSG_NOERROR est spécifié, alors le message sera tronqué (et la partie tronquée sera perdue) ; si MSG_NOERROR n'est pas spécifié, le message ne sera pas extrait de la file, et l'appel système échouera en renvoyant -1 et en indiquant E2BIG dans errno.

À moins que MSG_COPY ne soit indiqué dans msgflg (voir ci-dessous), l’argument msgtyp indique le type de message désiré.

• Si msgtyp vaut 0, le premier message est lu.
• Si msgtyp est supérieur à 0, alors le premier message de type msgtyp est extrait de la file. Si msgflg contient MSG_EXCEPT l'inverse est effectué, le premier message de type différent de msgtyp est extrait de la file.
• Si msgtyp est inférieur à 0, le premier message de la file avec un type le plus proche inférieur ou égal à la valeur absolue de msgtyp est extrait.

L'argument msgflg est composé d'un OU binaire « | » avec les attributs suivants.

IPC_NOWAIT

S’arrêter immédiatement si aucun message du type désiré n'est présent dans la file. L'appel système échoue et errno est configuré à ENOMSG.

MSG_COPY (depuis Linux 3.8)

Récupérer une copie de façon non destructive du message dans la file à la position ordinale indiquée par msgtyp (les messages sont considérées numérotés à partir de 0).

Cet attribut doit être indiqué en conjonction avec IPC_NOWAIT, de telle sorte que si aucun message n’est disponible à la position donnée, l’appel échoue immédiatement avec l’erreur ENOMSG. Parce qu'ils modifient le sens de msgtyp de manière opposée, MSG_COPY et MSG_EXCEPT ne peuvent être définis simultanément dans msgflg.

L'attribut MSG_COPY a été ajouté pour l’implémentation du point de restauration du noyau et n’est disponible que si le noyau a été compilé avec l’option CONFIG_CHECKPOINT_RESTORE.

MSG_EXCEPT

Utilisé avec msgtyp supérieur à 0 pour lire les messages de type différent de msgtyp.

MSG_NOERROR

Tronquer silencieusement les messages plus longs que msgsz octets.

Si aucun message du type requis n'est disponible et si on n'a pas demandé IPC_NOWAIT dans msgflg, le processus appelant est bloqué jusqu'à l'occurrence d'un des événements suivants:

• Un message du type désiré arrive dans la file.
• La file de messages est supprimée. L'appel système échoue et errno contient EIDRM.
• Le processus appelant intercepte un signal. Dans ce cas l'appel système échoue avec errno valant EINTR. (msgrcv() n'est jamais relancé automatiquement après interruption par un gestionnaire de signal, quelle que soit la configuration de SA_RESTART lors de l'installation du gestionnaire.)

Si l'appel système réussit, la structure décrivant la file de messages est mise à jour comme suit.

msg_lrpid est rempli avec le PID du processus appelant.

msg_qnum est décrémenté de 1.

msg_rtime est rempli avec l'heure actuelle.

Source du programme¶

#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, "Utilisation : %s [options]\n", prog_name);
    fprintf(stderr, "Les options sont :\n");
    fprintf(stderr, "-s        envoyer un message en utilisant msgsnd()\n");
    fprintf(stderr, "-r        lire un message en utilisant msgrcv()\n");
    fprintf(stderr, "-t        type de message (1 par défaut)\n");
    fprintf(stderr, "-k        clé de la file de messages (1234 par défaut)\n");
    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("envoyé : %s\n", 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("Aucun message disponible pour msgrcv()\n");
    } else
        printf("message reçu : %s\n", 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 's':
            mode = 1;
            break;
        case 'r':
            mode = 2;
            break;
        case 't':
            msgtype = atoi(optarg);
            if (msgtype <= 0)
                usage(argv[0], "-t option must be greater than 0\n");
            break;
        case 'k':
            msgkey = atoi(optarg);
            break;
        default:
            usage(argv[0], "Unrecognized option\n");
        }
    }
    if (mode == 0)
        usage(argv[0], "must use either -s or -r option\n");
    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);
}