Les files de messages

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 programmation client/serveur: introduction

  yassine bouamar · 12:42 · 22k vues — نقدم لكم الدرس الأول من برمجة المستخدم والخادم باستعمال لغة vb.net وتقنية ado.net دائما على مدونة دروسي:www.dorousy.com

• 🇫🇷 Part 3- Programmation Réseaux et Systèmes Distribuées-Serveur Multi Threads

  Professeur Mohamed YOUSSFI · 40:07 · 14k vues — Cette série de vidéos présente les bases de la programmation réseaux et des systèmes distribués. Elle inclut les éléments suivants :- Concepts de base de la ...

• 🇬🇧 TCP Client Server Implementation in C | Socket Programming in C

  Idiot Developer · 21:09 · 113k vues — This video will implement TCP client-server architecture in the C programming language, where both the client and server can communicate with each other.TCP ...

1. Boîte aux lettres entre processus

Une file de messages (FDM, message queue) est un mécanisme IPC qui implémente le concept de boîte aux lettres : un processus dépose un paquet, un autre vient le chercher — éventuellement plus tard, éventuellement en filtrant par catégorie.

Propriétés

• Données structurées : un type de message + un message de longueur variable.
• Possibilité d'attendre uniquement des messages d'un type donné. Sinon, le processus est bloqué (attente passive).
• L'attente est bloquante par défaut ; on peut la désactiver avec IPC_NOWAIT (renvoie un code d'erreur si rien à lire/écrire).
• Comme les tubes, les files de messages ont des droits d'accès Unix (rwx, rwx, rwx).

2. Vue d'ensemble — la file en image

Une file de messages se laisse imaginer comme une rangée de casiers étiquetés. Les producteurs déposent à droite, les consommateurs piochent à gauche, mais chacun peut filtrer par étiquette (mtype).

3. Tubes vs files de messages

4. Structure d'un message — msgbuf

Le header <sys/msg.h> contient un modèle générique de message :

struct msgbuf {
    long mtype;     /* type of received/sent message (syscall_slong_t mtype;) */
    char mtext[];   /* text of the message */
};

C'est un modèle : on peut définir sa propre structure, pourvu qu'elle contienne :

/* Exemple : message « commande » personnalisé */
struct cmd_msg {
    long mtype;                 /* obligatoirement en premier */
    int  client_id;
    char body[256];
};

5. Obtenir une file — msgget

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

int msgget(key_t key, int msgflg);

Crée (ou récupère) une file de messages. Renvoie son identifiant (rôle analogue à open pour les fichiers) ou -1 en cas d'erreur.

Générer une clé — ftok

key_t ftok(const char *pathname, int proj_id);

• pathname : chemin d'un fichier existant et accessible.
• proj_id : identifiant de projet, entier entre 0 et 255.

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>

int main(void) {
    key_t key;
    /* Générer une clé à partir d'un fichier existant et d'un identifiant de projet */
    key = ftok("/path/to/some/file", 65);  /* le fichier doit exister */
    if (key == -1) {
        perror("ftok");
        exit(1);
    }
    printf("La clé générée est : %d\n", key);
    return 0;
}

6. Contrôler la file — msgctl

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

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

Effectue l'opération cmd sur la file identifiée par msqid. Renvoie 0 en cas de succès, -1 en cas d'échec.

La structure msqid_ds

struct msqid_ds {
    struct ipc_perm msg_perm;   /* Permissions de la file de messages */
    time_t          msg_stime;  /* Temps de la dernière réception de message */
    time_t          msg_rtime;  /* Temps de la dernière lecture de message */
    time_t          msg_ctime;  /* Temps de la dernière modification des métadonnées */
    unsigned long   msg_cbytes; /* Nombre actuel d'octets dans la file */
    unsigned long   msg_qnum;   /* Nombre actuel de messages dans la file */
    unsigned long   msg_qbytes; /* Taille maximale en octets de la file */
    pid_t           msg_lspid;  /* PID du dernier processus ayant envoyé un message */
    pid_t           msg_lrpid;  /* PID du dernier processus ayant lu un message */
};

La structure ipc_perm

Définie dans <sys/ipc.h>. Les champs configurables via IPC_SET sont mis en évidence :

struct ipc_perm {
    key_t          key;   /* Clé IPC */
    uid_t          uid;   /* Identifiant de l'utilisateur propriétaire actuel  [IPC_SET] */
    gid_t          gid;   /* Identifiant du groupe propriétaire                [IPC_SET] */
    uid_t          cuid;  /* Identifiant de l'utilisateur créateur */
    gid_t          cgid;  /* Identifiant du groupe créateur */
    mode_t         mode;  /* Mode d'accès (permissions)                        [IPC_SET] */
    unsigned short seq;   /* Numéro de séquence pour éviter les conflits de clés */
};

Exemple — inspecter une file

int main(void) {
    key_t key;
    int msqid;
    struct msqid_ds buf;

    key = ftok("/path/to/some/file", 65);

    /* Créer une file de messages avec des permissions spécifiques */
    msqid = msgget(key, 0666 | IPC_CREAT);  /* lecture/écriture pour tout le monde */
    if (msqid == -1) { perror("msgget"); exit(1); }

    /* Récupérer les informations sur la file de messages */
    if (msgctl(msqid, IPC_STAT, &buf) == -1) { perror("msgctl"); exit(1); }

    /* Afficher les permissions (mode) */
    printf("Permissions de la file de messages : %o\n", buf.msg_perm.mode);
    printf("Propriétaire : %d, Groupe : %d\n", buf.msg_perm.uid, buf.msg_perm.gid);

    return 0;
}

7. Émettre & recevoir — msgsnd / msgrcv

Émission — msgsnd

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

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

Dépose un message dans la file. Renvoie 0 en cas de succès, -1 en cas d'erreur.

Réception — msgrcv

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

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

Extrait (supprime) un message de la file et le copie dans *msgp. Renvoie la taille en octets du message extrait, ou -1 en cas d'échec.

msgflg = IPC_NOWAIT rend l'appel non bloquant : si aucun message du type attendu n'est présent, msgrcv revient immédiatement avec une erreur.

Producteur — envoie un message

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

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

int main(void) {
    key_t key = ftok("/path/to/some/file", 65);
    int msqid = msgget(key, 0664 | IPC_CREAT);
    if (msqid == -1) { perror("msgget"); exit(1); }

    struct msgbuf msg;
    msg.mtype = 2;                              /* étiquette de catégorie */
    strncpy(msg.mtext, "Bonjour file !", sizeof msg.mtext);

    if (msgsnd(msqid, &msg, strlen(msg.mtext) + 1, 0) == -1) {
        perror("msgsnd");
        exit(1);
    }
    printf("Message de type %ld envoyé.\n", msg.mtype);
    return 0;
}

Consommateur — filtre par mtype

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

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

int main(void) {
    key_t key = ftok("/path/to/some/file", 65);
    int msqid = msgget(key, 0664);              /* la file doit exister */
    if (msqid == -1) { perror("msgget"); exit(1); }

    struct msgbuf msg;
    /* On ne s'intéresse qu'aux messages de type 2 : sélection par mtype */
    ssize_t n = msgrcv(msqid, &msg, sizeof msg.mtext, 2, 0);
    if (n == -1) { perror("msgrcv"); exit(1); }

    printf("Reçu (type %ld, %zd o) : %s\n", msg.mtype, n, msg.mtext);
    return 0;
}

8. Commandes shell — ipcs & ipcrm

Deux commandes essentielles administrent les IPC Système V :

9. Les files de messages POSIX

Les POSIX MQ ont été introduites pour standardiser les MQ Système V de AT&T. Contrairement aux tubes et aux sockets, elles utilisent les modules « temps réel » du noyau — d'où leur usage industriel pour des informations importantes asynchrones mais réactives.

Principes

• Les MQ fonctionnent comme un service de gestion de files : messages à priorités variables, les plus prioritaires et les plus anciens sont lus en premier.
• Files approvisionnées par un ou plusieurs processus, lues par un ou plusieurs processus.
• Des propriétés sont locales à la file (ex. nombre max de messages) ou globales au système (ex. priorité max).
• Messages de longueur maximale fixe → implémentation simplifiée (buffer ou chaîne de taille fixe).
• Le nom d'une MQ doit commencer par /, suivi de caractères alphanumériques.
• Servent à transférer des messages courts entre plusieurs processus. Un processus peut lire ses propres messages.
• Lecture destructrice : un message lu est retiré de la file.
• La file extrait automatiquement le message le plus prioritaire le plus anciennement déposé. La priorité est fixée à l'écriture.
• POSIX impose au minimum 32 niveaux de priorité ; convention : 0 pour les messages normaux, supérieurs pour les urgents.

Les 5 prototypes principaux

mqd_t   mq_open   (const char *, int, ...);
ssize_t mq_receive(mqd_t, char *, size_t, unsigned *);
int     mq_send   (mqd_t, const char *, size_t, unsigned);
int     mq_close  (mqd_t);
int     mq_unlink (const char *);

★ Réviser le chapitre

❓ Q/R — vérifier ta compréhension

🃏 Flashcards éclair

Clique pour retourner. Tout retourner

<sys/msg.h>
struct msgbuf {
  long mtype;
  char mtext[];
};

int msgget(key_t key,
           int msgflg);

int msgsnd(int msqid,
   const void *msgp,
   size_t msgsz, int msgflg);
/* 0 ok, -1 err */

ssize_t msgrcv(int msqid,
   void *msgp, size_t msgsz,
   long msgtyp, int msgflg);
/* taille ok, -1 err */

mq_open, mq_send,
mq_receive,
mq_close, mq_unlink

✎ Quiz éclair

📌 À retenir