Rx3/libmsg
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Première version

Browse Source
This commit is contained in:
smas
2000-07-28 15:34:22 +00:00
commit 961ddc46da
14 changed files with 6065 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

618
lib/libmsg.3 Normal file
View File

@@ -0,0 +1,618 @@
'\" t
.\" @(#)LIBMSG.3 1.0 00/07/04 SMA;
.TH LIBMSG 3 "07 Apr 2000"
.SH NOM
LIBMSG (librairie de communication inter-processus par messages)
.SH SYNOPSIS
.LP
.BI "cc [flag ...] file ... -lver -ldl -lnode -lshmem -ldatastr -lmsg [library ...]"
.LP
.BI "#include <msg.h>"
.LP
.BI "MSGT_Status MSG_Library_Open ( int " Instance ", const char * " Context ", MSGT_Flags " Open_Mode " );"
.LP
.BI "MSGT_Status MSG_Library_IsOpen ( void );"
.LP
.BI "MSGT_Status MSG_Library_Signal ( void );"
.LP
.BI "MSGT_Status MSG_Library_Close ( MSGT_Flags " Close_Mode " );"
.LP
.BI "MSGT_Status MSG_Library_Stderr_Set ( FILE * " Out " );"
.LP
.BI "MSGT_Status MSG_Library_Dump ( FILE * " Out " );"
.LP
.BI "MSGT_Status MSG_Port_Open ( int " Id ", MSGT_Port ** " Port ", MSGT_Flags " Open_Mode " );"
.LP
.BI "MSGT_Status MSG_Port_Lock ( MSGT_Port * " Port ", MSGT_Flags " Mode " );"
.LP
.BI "MSGT_Status MSG_Port_Unlock ( MSGT_Port * " Port ", MSGT_Flags " Mode " );"
.LP
.BI "MSGT_Status MSG_Port_Config ( MSGT_Port * " Port ", MSGT_Config " Tag ", " ... " );"
.LP
.BI "MSGT_Status MSG_Port_Close ( MSGT_Port * " Port ", MSGT_Flags " Close_Mode " );"
.LP
.BI "MSGT_Status MSG_PortList_Open ( MSGT_PortList ** " PortList " );"
.LP
.BI "MSGT_Status MSG_PortList_Port_Add ( MSGT_PortList * " PortList ", MSGT_Port * " Port " );"
.LP
.BI "MSGT_Status MSG_PortList_Port_Remove ( MSGT_PortList * " PortList ", MSGT_Port * " Port " );"
.LP
.BI "MSGT_Status MSG_PortList_Close ( MSGT_PortList * " PortList " );"
.LP
.BI "MSGT_Status MSG_PortList_Listen ( MSGT_PortList * " PortList ", unsigned int " Type ", MSGT_Message ** " Msg ", MSGT_Flags " Flags " );"
.LP
.BI "MSGT_Status MSG_Message_Alloc ( MSGT_Message ** " Msg ", size_t " Size " );"
.LP
.BI "MSGT_Status MSG_Message_Config ( MSGT_Message * " Msg ", MSGT_Config " Tag ", " ... " );"
.LP
.BI "MSGT_Status MSG_Message_Free ( MSGT_Message * " Msg " );"
.LP
.BI "MSGT_Status MSG_Message_Send ( MSGT_Port * " From ", , MSGT_Port * " To ", MSGT_Message * " Msg " );"
.LP
.BI "MSGT_Status MSG_Message_Receive ( MSGT_Port * " Port ", unsigned int " Type ", MSGT_Message ** " Msg ", MSGT_Flags " Flags " );"
.LP
.BI "MSGT_Status MSG_Message_Reply ( MSGT_Message * " Msg " );"
.LP
.BI "MSGT_Status MSG_Message_Return ( MSGT_Message * " Msg " );"
.LP
.SH "CODES RETOUR"
.LP
Toutes les fonctions constituant l'API de la librairie LIBMSG retournent un code de type
.B MSGT_Status
:
.LP
.RS 3
-
.B MSGS_OK
: la fonction s'est correctement executee et a produit un resultat
.LP
-
.B MSGS_KO
: la fonction s'est correctement executee mais n'a pas produit de resultat
.LP
-
.B MSGS_ERRAPI
: la fonction a ete appelee avec des arguments de valeur incorrecte
.LP
-
.B MSGS_ERRMEM
: la fonction ne s'est pas correctement executee pour un probleme d'allocation memoire
.LP
-
.B MSGS_ERRSHM
: la fonction ne s'est pas correctement executee pour un probleme relatif a la memoire partagee
.LP
-
.B MSGS_ERRSEM
: la fonction ne s'est pas correctement executee pour un probleme relatif a l'utilisation des semaphores
.LP
-
.B MSGS_ERRSIG
: une operation sur semaphore a ete interrompue par un signal
.LP
-
.B MSGS_ERRNOWAIT
: une operation sur semaphore n'a pas pu etre realisee et le mode d'operation est sans attente
.LP
-
.B DSS_ERRDLL
: la fonction ne s'est pas correctement executee pour un probleme de chargement dynamique d'objet
.LP
.RS -3
.I NB
: la macro
.B MSG_ERROR()
permet de tester si un code retour correspond a une erreur.
.LP
En cas d'erreur, la variable MSG_Error_Message contient un message du type :
.LP
.RS 3
Error <Nom fonction> : <message d'erreur>
.RS -3
.LP
Pour les fonctions de reception de messages, 3 codes retour supplementaires ont ete definis :
.LP
.RS 3
-
.B MSGS_NO_MSG
si aucun message n'a ete trouve dans le(s) port(s) de messages ecoute(s)
.LP
-
.B MSGS_BAD_TYPE
si des messages sont presents mais qu'aucun ne correspond au type de message demande.
.LP
-
.B MSGS_SIGNAL
si l'ecoute du port a ete interrompue par un signal systeme.
.RS -3
.LP
.SH "FONCTIONS"
.LP
.BI "MSGT_Status MSG_Library_Open ( int " Instance ", const char * " Context ", MSGT_Flags " Open_Mode " );"
.RS 3
.LP
La librairie LIBMSG implemente une base qui reference tous les ports de messages et tous les messages crees.
.LP
Cette fonction permet donc d'acceder a toutes ces ressources pour un contexte et une instance donnes designes par leur nom
.I Context
et
.I Instance
:
.LP
.RS 3
- en ouverture simple si
.I Open_Mode
vaut
.B MSGD_OPEN
.LP
- en creation si
.I Open_Mode
vaut
.B MSGD_CREATE
.RS -3
.LP
.I NB
: l'indicateur d'ouverture
.I Open_Mode
pourra etre combinee avec un mode de debugging (
.B MSGD_DEBUG_NONE
: aucun message d'erreur n'est affiche
.LP
.B MSGD_DEBUG
: les messages d'erreur generes par la librairie LIBMSG sont affiches sur la sortie standard d'erreur
.LP
.B MSGD_DEBUG_ALL
: les messages d'erreur generes par toutes les librairies sous-jacentes a la LIBMSG sont affiches sur la sortie standard d'erreur
.LP
.I NB
: l'ouverture de la librairie en creation est reservee aux administrateurs.
.LP
L'ouverture de la librairie est obligatoire avant d'utiliser toute autre fonction de la librairie LIBMSG.
.LP
.RS -3
.LP
.BI "MSGT_Status MSG_Library_Signal ( void );"
.RS 3
.LP
Cette fonction permet d'informer la librairie LIBMSG de la reception d'un signal systeme.
.LP
.I NB
: cette fonction sera utile a l'utilisateur pour eviter que le processus reste bloque sur une attente de message malgre la reception de signal.
.RS -3
.LP
.BI "MSGT_Status MSG_Library_IsOpen ( void );"
.RS 3
.LP
Cette fonction permet de tester si une instance de la librairie LIBMSG a deja ete ouverte.
.RS -3
.LP
.BI "MSGT_Status MSG_Library_Close ( MSGT_Flags " Close_Mode " );"
.RS 3
.LP
Cette fonction permet de fermer toutes les ressources de l'instance de la librairie ouverte :
.LP
.RS 3
- fermeture simple si
.I Close_Mode
vaut
.B MSGD_CLOSE
.LP
- destruction si
.I Close_Mode
vaut
.B MSGD_DESTROY
.RS -3
.LP
.I NB
: l'utilisation du parametre
.B MSGD_DESTROY
est reservee aux administrateurs.
.LP
.RS -3
.BI "MSGT_Status MSG_Library_Dump ( FILE * " Out " );"
.RS 3
.LP
Cette fonction permet d'afficher toutes les ressources de l'instance de la librairie ouverte.
.LP
L'argument
.I Out
designe le flux de sortie de l'affichage.
.LP
.RS -3
.BI "MSGT_Status MSG_Port_Open ( int " Id ", MSGT_Port ** " Port ", MSGT_Flags " Open_Mode " );"
.LP
.RS 3
Cette fonction permet d'ouvrir un port de messages.
.LP
Elle requiert les arguments suivants :
.RS 3
.LP
* (In)
.I Id
: l'identifiant numerique du port de messages
.LP
* (Out)
.I Port
: l'adresse d'un pointeur sur le port de messages
.LP
* (In)
.I Open_Mode
: le mode d'ouverture du port de messages
.LP
.RS 3
- en ouverture simple si
.I Open_Mode
vaut
.B MSGD_OPEN
.LP
- en creation si
.I Open_Mode
vaut
.B MSGD_CREATE
.RS -3
.RS -3
.LP
.RS -3
.BI "MSGT_Status MSG_Port_Lock ( MSGT_Port * " Port ", MSGT_Flags " Mode " );"
.RS 3
.LP
Cette fonction permet de verrouiller un port de messages.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Port
: un pointeur sur le port de messages a verrouiller
.LP
* (In)
.I Mode
: le mode de verrouillage (
.B MSGD_READ
ou
.B MSGD_WRITE
)
.LP
.RS -3
.LP
.RS -3
.BI "MSGT_Status MSG_Port_Unlock ( MSGT_Port * " Port ", MSGT_Flags " Mode " );"
.RS 3
.LP
Cette fonction permet d'oter le verrou pose sur un port de messages.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Port
: un pointeur sur le port de messages a deverrouiller
.LP
* (In)
.I Mode
: le mode dans lequel le port est verrouille (
.B MSGD_READ
ou
.B MSGD_WRITE
)
.LP
.RS -3
.LP
.RS -3
.BI "MSGT_Status MSG_Port_Config ( MSGT_Port * " Port ", MSGT_Config " Tag ", " ... " );"
.RS 3
.LP
Cette fonction permet de configurer un port de messages.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Port
: un pointeur sur le port de messages a configurer
.LP
* (In)
.I Tag
: le type de configuration (
.B MSGD_CONFIG_SIZE
)
.LP
* (In)
.I ...
: la ou les valeurs utiles (fonction du type de configuration)
.LP
.RS -3
.LP
.RS -3
.BI "MSGT_Status MSG_Port_Close ( MSGT_Port * " Port ", MSGT_Flags " Close_Mode " );"
.RS 3
.LP
Cette fonction permet de fermer un port de messages.
.LP
Elle requiert les arguments suivants :
.RS 3
.LP
* (In)
.I Port
: un pointeur sur le port de messages a fermer
.LP
* (In)
.I Close_Mode
: le mode de fermeture du port de messages
.LP
.RS 3
- fermeture simple si
.I Close_Mode
vaut
.B MSGD_CLOSE
.LP
- destruction si
.I Close_Mode
vaut
.B MSGD_DESTROY
.RS -3
.RS -3
.LP
.RS -3
.BI "MSGT_Status MSG_PortList_Open ( MSGT_PortList ** " PortList " );"
.RS 3
.LP
Cette fonction permet d'ouvrir une liste de ports de messages.
.LP
L'argument
.I PortList
est l'adresse d'un pointeur sur la liste de port a creer.
.LP
.I NB
: une liste de ports permet a un processus d'ecouter plusieurs ports de messages simultanement.
Une liste de ports n'est pas partageable entre les processus.
.LP
.RS -3
.BI "MSGT_Status MSG_PortList_Port_Add ( MSGT_PortList * " PortList ", MSGT_Port * " Port " );"
.RS 3
.LP
Cette fonction permet d'ajouter un port de messages a une liste de ports.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I PortList
: un pointeur sur une liste de ports
.LP
* (In)
.I Port
: un pointeur sur le port de messages a ajouter
.LP
.RS -3
.LP
.RS -3
.BI "MSGT_Status MSG_PortList_Port_Remove ( MSGT_PortList * " PortList ", MSGT_Port * " Port " );"
.RS 3
.LP
Cette fonction permet de retirer un port de messages d'une liste de ports.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I PortList
: un pointeur sur une liste de ports
.LP
* (In)
.I Port
: un pointeur sur le port de messages a retirer
.LP
.RS -3
.LP
.RS -3
.BI "MSGT_Status MSG_PortList_Close ( MSGT_PortList * " PortList " );"
.RS 3
.LP
Cette fonction permet de detruire une liste de ports de messages.
.LP
L'argument
.I PortList
est un pointeur sur la liste de port a supprimer.
.LP
.I NB
: lorsqu'un processus ajoute un port de messages a sa liste de ports, le port de messages memorise le fait que le processus doit etre averti si un message y est ajoute ou retire.
Il est donc important que chaque processus detruise explicitement toutes les listes de ports qu'il a creees lorsque celles-ci ne sont plus utilisees.
.LP
.RS -3
.BI "MSGT_Status MSG_PortList_Listen ( MSGT_PortList * " PortList ", unsigned int " Type ", MSGT_Message ** " Msg ", MSGT_Flags " Flags " );"
.RS 3
.LP
Cette fonction permet de receptionner un message a partir d'une liste de ports.
La notion d'ecoute correspond au fait qu'un processus pourra se mettre en attente jusqu'a ce qu'un message soit envoye sur l'un des ports.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Port
: un pointeur sur la liste de ports
.LP
* (In)
.I Type
: le type du message a receptionner (la valeur
.B MSGD_NO_TYPE
permet de ne specifier aucun type en particulier)
.LP
* (Out)
.I Msg
: l'adresse d'un pointeur sur le message a receptionner.
.LP
* (In)
.I Flags
: le type d'ecoute (avec attente :
.B MSGD_WAIT
, sans attente :
.B MSGD_NOWAIT
)
.LP
.RS -3
.I NB
: pour une ecoute avec attente, un processus sera reveille a chaque fois qu'un message arrive dans l'un des ports de la liste. Il pourra toutefois se remettre en attente si le message a ete receptionne par un autre processus ou bien si son type n'est pas celui demande.
.LP
.I NB
: la recherche des messages dans les differents ports de la liste s'effectue dans l'ordre dans lequel ils ont ete ajoute a la liste.
.LP
.RS -3
.BI "MSGT_Status MSG_Message_Alloc ( MSGT_Message ** " Msg ", size_t " Size " );"
.RS 3
.LP
Cette fonction permet de creer un message et d'allouer de la memoire pour les donnees associees au message.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (Out)
.I Msg
: l'adresse d'un pointeur sur le message a creer
.LP
* (In)
.I Size
: la taille des donnees du message
.RS -3
.LP
.I NB
: l'utilisateur pourra modifier a sa guise la zone de donnees du message pointee par le champ
.B Data
du message.
Il veillera toutefois a ne pas deborder en dehors de cette zone auquel cas le fonctionnement de la librairie pourrait etre corrompue.
.LP
.RS -3
.BI "MSGT_Status MSG_Message_Config ( MSGT_Message * " Msg ", MSGT_Config " Tag ", " ... " );"
.RS 3
.LP
Cette fonction permet de configurer un message.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Msg
: un pointeur sur le message a configurer
.LP
* (In)
.I Tag
: le type de configuration (
.B MSGD_CONFIG_TYPE
,
.B MSGD_CONFIG_PRIORITY
)
.LP
* (In)
.I ...
: la ou les valeurs utiles (fonction du type de configuration)
.RS -3
.LP
.RS -3
.BI "MSGT_Status MSG_Message_Free ( MSGT_Message * " Msg " );"
.RS 3
.LP
Cette fonction permet de supprimer un message de la base de la librairie LIBMSG.
.LP
L'argument
.I Msg
est un pointeur sur le message a supprimer.
.LP
.I NB
: l'utilisateur veillera a ne pas supprimer les messages de maniere inconsideree, ceux-ci pouvant etre en cours d'envoi dans un port de messages.
.LP
Les regles d'usage veulent que ce soit le processus initiateur d'un message qui le supprime.
Dans le cas ou les messages ne sont pas renvoyes au processus initiateur, c'est le processus qui receptionne le message qui le supprimera.
.LP
.RS -3
.BI "MSGT_Status MSG_Message_Send ( MSGT_Port * " From ", , MSGT_Port * " To ", MSGT_Message * " Msg " );"
.RS 3
.LP
Cette fonction permet d'envoyer un message dans un port de messages.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I From
: un pointeur sur le port de l'emetteur du message
.LP
* (In)
.I To
: un pointeur sur le port destinataire du message
.LP
* (In)
.I Msg
: un pointeur sur le message a envoyer
.LP
.RS -3
.I NB
: un message ne pourra pas etre envoye simultanement dans plusieurs ports de messages.
.LP
.RS -3
.BI "MSGT_Status MSG_Message_Receive ( MSGT_Port * " Port ", unsigned int " Type ", MSGT_Message ** " Msg ", MSGT_Flags " Flags " );"
.RS 3
.LP
Cette fonction permet de receptionner un message dans un port de messages.
.LP
Elle requiert les arguments suivants :
.LP
.RS 3
* (In)
.I Port
: un pointeur sur le port de messages a ecouter
.LP
* (In)
.I Type
: le type du message a receptionner (la valeur
.B MSGD_NO_TYPE
permet de ne specifier aucun type en particulier)
.LP
* (Out)
.I Msg
: l'adresse d'un pointeur sur le message a receptionner.
.LP
* (In)
.I Flags
: le type d'ecoute (avec attente :
.B MSGD_WAIT
, sans attente :
.B MSGD_NOWAIT
)
.LP
.RS -3
.I NB
: la reception d'un message ne fait que retirer celui-ci du port de messages.
Le message n'est donc pas supprime et pourra en consequence etre envoye a nouveau dans une autre port de messages.
.LP
Pour une reception avec attente, un processus sera reveille a chaque fois qu'un message arrive dans le port de la liste.
.LP
Independamment du type demande, les messages sont receptionnes selon leur priorite puis selon leur ordre d'envoi.
.LP
.RS -3
.BI "MSGT_Status MSG_Message_Reply ( MSGT_Message * " Msg " );"
.RS 3
.LP
Cette fonction permet de renvoyer un message a son envoyeur.
.LP
.I NB
: l'envoyeur devra alors avoir precise l'identifiant de son port d'ecoute dans le champ
.B From
du message
.I Msg
.
.LP
.RS -3
.BI "MSGT_Status MSG_Message_Return ( MSGT_Message * " Msg " );"
.RS 3
.LP
Cette fonction permet de renvoyer un message au processus initiateur du message (different de l'envoyeur si le message passe entre plusieurs mains.
.LP
.I NB
: l'initiateur du message devra alors avoir precise l'identifiant de son port d'ecoute dans le champ
.B Init
du message
.I Msg
.
.LP
.RS -3

3181
lib/libmsg.c Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
lib/libmsg.doc Normal file
View File

Binary file not shown.

118
lib/libmsg.h Normal file
View File

@@ -0,0 +1,118 @@
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <ver.h>
#include <node.h>
#include <datastr.h>
#include <msg.h>
extern char * strdup (const char *);
int MSG_Signal_Received;
/* Tous les heaps créés via la librairie LIBMSG seront préfixés par le nom suivant */
#define MSG_PREFIX "MSG"
/* Nom du fichier à charger pour accéder aux fonctions manager d'une data structure créée par la LIBMSG */
#define MSG_FILE_MANAGER "libmsg.so"
/*
Heap dans lequel sera stockée la base de la librairie LIBMSG :
Ce heap ne contient que la structure MSGT_Base qui permet de référencer
la liste des ports de messages.
Ce heap ne sera constitué que d'une unique segment très petit.
*/
#define MSG_BASE_HEAP_NAME "BASE"
#define MSG_BASE_HEAP_SEGMENT_SIZE 100
/*
Heap dans lequel sera stockée la liste des ports de messages :
Ce heap ne contient que la structure MSGT_Base qui permet de référencer
la liste des ports de messages.
Ce heap n'a pas besoin besoin d'être très grand.
*/
#define MSG_PORT_LIST_NAME "PORT_REF"
#define MSG_PORT_LIST_SEGMENT_SIZE 10240
/*
Heap sous-jacent à un port de messages :
Un port de messages est une data structure qui ne contient que sa racine, les
noeuds étant stockés par ailleurs. On peut donc se contenter d'un petit segment.
*/
#define MSG_PORT_SEGMENT_SIZE 1024
/*
Heap dans lequel seront alloués les messages :
Ce heap étant amené à grandir rapidemment, il vaut mieux choisir
une taille importante par segment afin de limiter le nombre de segments.
*/
#define MSG_MESSAGE_HEAP_NAME "MSG_REF"
#define MSG_MESSAGE_HEAP_SEGMENT_SIZE 1024000
/* Utilisation des sémaphores pour l'écoute des ports de messages ou des liste de ports */
struct sembuf MSG_SemOp_Listen [2] = { {0, -1, 0}, {0, 1, 0} }; /* Opération d'écoute */
struct sembuf MSG_SemOp_Receive [1] = { {0, -1, IPC_NOWAIT} }; /* Opération de retrait de message */
struct sembuf MSG_SemOp_Add [1] = { {0, 1, IPC_NOWAIT} }; /* Opération d'ajout de message */
/* Utilisation des sémaphores pour verrouiller les ports de messages */
struct sembuf MSG_SemOp_SSL [2] = { {0, -1, SEM_UNDO}, {0, 2, SEM_UNDO} };
struct sembuf MSG_SemOp_RSL [2] = { {0, -2, SEM_UNDO|IPC_NOWAIT}, {0, 1, SEM_UNDO|IPC_NOWAIT} };
struct sembuf MSG_SemOp_SEL [2] = { {0, -1, SEM_UNDO}, {0, 0, SEM_UNDO} };
struct sembuf MSG_SemOp_REL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 1, SEM_UNDO|IPC_NOWAIT} };
/* Compteur d'ouverture de la librairie */
unsigned int MSG_Open_Counter = 0;
/* Flux de sortie des messages d'erreur générés par la librairie */
FILE * MSG_stderr;
typedef union semun {
int val;
struct semid_ds * buf;
unsigned short int * array;
} semun;
NDT_Status MSG_Base_Port_List_Manager (va_list);
NDT_Status MSG_Semaphore_List_Manager (va_list args_ptr);
NDT_Status MSG_PortList_Manager (va_list args_ptr);
NDT_Status MSG_MessageQueue_Manager (va_list);
MSGT_Status MSG_ShareLock_Set (int);
MSGT_Status MSG_ShareLock_Release (int);
MSGT_Status MSG_ExclusiveLock_Set (int);
MSGT_Status MSG_ExclusiveLock_Release (int);
MSGT_Status MSG_Semaphore_Operate (int, struct sembuf *, unsigned int);
void MSG_Error_Print ( void );
static char * MSG_Name_Prefix (const char * Name);
char * MSG_LockStatus_Get (int SemID);

516
lib/msg.h Normal file
View File

@@ -0,0 +1,516 @@
#ifndef _LIBMSG
#define _LIBMSG
#ifdef __cplusplus
extern "C" {
#endif
#include <sys/time.h>
#include <ver.h>
#include <node.h>
#include <shmem.h>
#include <datastr.h>
/* Code retour des fonctions constituant l'API */
typedef long MSGT_Status;
#define MSGS_OK DSS_OK /* La fonction s'est correctement exécutée et a produit un résultat */
#define MSGS_KO DSS_KO /* La fonction s'est correctement exécutée mais n'a pas produit de résultat */
#define MSGS_YES MSGS_OK /* Résultat booléen positif */
#define MSGS_NO MSGS_KO /* Résultat booléen négatif */
#define MSGS_ERRMEM DSS_ERRMEM /* Problème d'allocation mémoire */
#define MSGS_ERRAPI DSS_ERRAPI /* Utilisation incorrecte des API */
#define MSGS_ERRSHM DSS_ERRSHM /* Problème relatif aux segments de mémoire partagée */
#define MSGS_ERRSEM DSS_ERRSEM /* Problème relatif à l'utilisation des sémaphores */
#define MSGS_ERRSIG DSS_ERRSIG /* Opération sur sémaphore interrompue par un signal */
#define MSGS_ERRDLL DSS_ERRDLL /* Problème de chargement dynamique de librairie */
#define MSGS_ERRNOWAIT -7 /* Opération sur sémaphore impossible et le mode d'opération est sans attente */
#define MSG_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */
/* Codes retour spécifiques pour la réception de messages */
#define MSGS_NO_MSG 5
#define MSGS_BAD_TYPE 6
/* Indicateurs */
typedef int MSGT_Flags;
/* Flags de debug sur l'ouverture de la librairie */
#define MSGD_DEBUG_NONE SMD_DEBUG_NONE /* pour n'afficher aucun message généré par les diverses librairies */
#define MSGD_DEBUG SMD_DEBUG /* pour afficher les messages générés par la librairie */
#define MSGD_DEBUG_ALL SMD_DEBUG_ALL /* pour afficher les messages générés par toutes les librairies sous-jacentes */
#define MSGD_DEBUG_MSK (MSGD_DEBUG & MSGD_DEBUG_ALL)
/* Flags d'ouverture et de fermeture des différentes ressources de la librairie */
#define MSGD_OPEN SMD_OPEN
#define MSGD_CREATE SMD_CREATE
#define MSGD_MSK_OPEN(a) (MSGD_OPEN & (a))
#define MSGD_MSK_CREATE(a) (MSGD_CREATE & (a))
#define MSGD_CLOSE SMD_CLOSE
#define MSGD_DESTROY SMD_DESTROY
/* Flags de réception de message */
#define MSGD_NO_WAIT 1 /* Réception sans attente si aucun message */
#define MSGD_WAIT 2 /* Réception avec attente */
/* Flags de verrouillage d'un port de messages */
#define MSGD_READ 1 /* verrou partagé */
#define MSGD_WRITE 2 /* verrou exclusif */
#define MSGD_MSK_READ(a) (MSGD_READ & (a))
#define MSGD_MSK_WRITE(a) (MSGD_WRITE & (a))
#define MSGD_UNLIMITED 0
/* Notion de port de messages */
typedef struct {
char Name [50]; /* Nom du port de messages */
size_t Size; /* Taille limite du port en nombre de messages */
int ListenSemID; /* sémaphore permettant l'écoute du port */
int LockSemID; /* sémaphore permettant le verrouillage du port */
NDT_Root * SemList; /* Liste des sémaphores des listes de ports qui sont à l'écoute du port */
NDT_Root * MsgQueue; /* File d'attente des messages */
} MSGT_Port;
/* Quelques ports de message prédéfinis */
#define MSGD_DEFAULT_PORT_NAME "DEFAULT_PORT"
#define MSGD_SYSTEM_PORT_NAME "SYSTEM_PORT"
#define MSGD_SUPERVISOR_PORT_NAME "SUPERVISOR_PORT"
/* Notion de liste de ports de messages */
typedef struct {
NDT_Root * Root; /* Liste de ports de messages */
int ListenSemID; /* Identifiant du sémaphore pour l'écoute de la liste de ports */
} MSGT_PortList;
/* Notion de messages */
typedef struct {
char From [50]; /* Nom du port d'écoute de l'initiateur du message */
char Via [50]; /* Nom du port d'écoute du dernier envoyeur du message */
char To [50]; /* Nom du port du dernier envoi du message */
unsigned int Type; /* Type du message */
int Priority; /* Priorité du message */
size_t Size; /* Taille des données du message */
void * Data; /* Données du message */
char * Swap; /* Nom du fichier de swap dans lequel est stocké le message */
} MSGT_Message;
#define MSGD_NO_TYPE 0
/*
Types de message :
Les types de message vont de 1 à 255 et sont partagés en 2 plages :
- messages systèmes prédéfinis de 1 à 32
- messages utilisateur de 33 à 255
*/
#define MSGD_NO_TYPE 0
#define MSGD_NB_SYSTEM_MESSAGE 32
#define MSGD_IS_SYSTEM(t) ((t) != MSGD_NO_TYPE && (t) < MSGD_NB_SYSTEM_MESSAGE)
#define MSGD_IS_SYSTEM_REQUEST(t) ((t) != MSGD_NO_TYPE && (t) < MSGD_NB_SYSTEM_MESSAGE && (t) % 2 == 1)
#define MSGD_IS_SYSTEM_REPLY(t) ((t) != MSGD_NO_TYPE && (t) < MSGD_NB_SYSTEM_MESSAGE && (t) % 2 == 0)
#define MSGD_SYSTEM_PING_REQUEST 1
#define MSGD_SYSTEM_PING_REPLY 2
#define MSGD_SYSTEM_STOP_REQUEST 3
#define MSGD_SYSTEM_STOP_REPLY 4
#define MSGD_SYSTEM_CONTINUE_REQUEST 5
#define MSGD_SYSTEM_CONT_REPLY 6
#define MSGD_SYSTEM_RESTART_REQUEST 7
#define MSGD_SYSTEM_RESTART_REPLY 8
#define MSGD_SYSTEM_SHUTDOWN_REQUEST 9
#define MSGD_SYSTEM_SHUTDOWN_REPLY 10
#define MSGD_SYSTEM_STATUS_REQUEST 11
#define MSGD_SYSTEM_STATUS_REPLY 12
#define MSGD_SYSTEM_INFO_REQUEST 13
#define MSGD_SYSTEM_INFO_REPLY 14
#define MSGD_SYSTEM_TRACEON_REQUEST 15
#define MSGD_SYSTEM_TRACEON_REPLY 16
#define MSGD_SYSTEM_TRACEOFF_REQUEST 17
#define MSGD_SYSTEM_TRACEOFF_REPLY 18
/* Type de message système générique (utile pour ne réceptionner que les messages système) */
#define MSGD_SYSTEM_GENERIC MSGD_NB_SYSTEM_MESSAGE
/* Quelques types de messages utilisateur prédéfinis */
#define MSGD_USER_TYPE1 MSGD_NB_SYSTEM_MESSAGE + 1
#define MSGD_USER_TYPE2 MSGD_NB_SYSTEM_MESSAGE + 2
#define MSGD_DEFAULT_TYPE MSGD_USER_TYPE1
/*
Priorités des messages :
Les priorités vont de -128 (la plus elevée) à 127 (plus basse) divisées en 2 plages :
- Priorités des messages système : [-128, -65] U [+65, +127]
- Priorités des messages utilisateur : [-64, +64]
*/
#define MSGD_SYSTEM_HIGH_PRIORITY -128
#define MSGD_SYSTEM_LOW_PRIORITY 127
#define MSGD_USER_HIGH_PRIORITY -64
#define MSGD_USER_NORMAL_PRIORITY 0
#define MSGD_USER_LOW_PRIORITY 64
#define MSGD_DEFAULT_PRIORITY MSGD_USER_NORMAL_PRIORITY
/* Types de configuration */
typedef int MSGT_Config;
#define MSGD_CONFIG_SIZE 1 /* Configuration de la taille d'un port de messages */
#define MSGD_CONFIG_MSGQUEUE 2 /* Choix du type de structure pour la queue de message d'un port de messages */
#define MSGD_CONFIG_TYPE 3 /* Configuration du type d'un message */
#define MSGD_CONFIG_PRIORITY 4 /* Configuration de la priorité d'un message */
char MSG_Error_Msg [512];
/* Base de la librairie LIBMSG */
SMT_Heap * MSG_Base_Heap;
SMT_Heap * MSG_Message_Heap;
typedef struct {
NDT_Root * Port_List; /* Liste de tous les ports de messages */
} MSGT_Base;
MSGT_Base * MSG_Base;
/* Contenu d'un message de type PING_REPLY */
typedef struct {
struct timeval Snd1;
struct timeval Rcv1;
struct timeval Snd2;
struct timeval Rcv2;
} MSGT_PingData;
/* Définition des alias de l'API */
#ifndef MSG_MODE
#define MSG_MODE 0
#endif
#if MSG_MODE == 1
/* Utilisation des API sans vérification des arguments */
# define MSG_Library_Open MSG_Library_Open_I
# define MSG_Library_Signal MSG_Library_Signal_I
# define MSG_Library_IsOpen MSG_Library_IsOpen_I
# define MSG_Library_Context_Set MSG_Library_Context_Set_I
# define MSG_Library_Context_Get MSG_Library_Context_Get_I
# define MSG_Library_Close MSG_Library_Close_I
# define MSG_Library_Stderr_Set MSG_Library_Stderr_Set_I
# define MSG_Library_Dump MSG_Library_Dump_I
# define MSG_Port_Exist MSG_Port_Exist_I
# define MSG_Port_Open MSG_Port_Open_I
# define MSG_Port_Config MSG_Port_Config_I
# define MSG_Port_Lock MSG_Port_Lock_I
# define MSG_Port_Unlock MSG_Port_Unlock_I
# define MSG_Port_Close MSG_Port_Close_I
# define MSG_PortList_Open MSG_PortList_Open_I
# define MSG_PortList_Port_Add MSG_PortList_Port_Add_I
# define MSG_PortList_Port_Remove MSG_PortList_Port_Remove_I
# define MSG_PortList_Close MSG_PortList_Close_I
# define MSG_PortList_Listen MSG_PortList_Listen_I
# define MSG_Message_Alloc MSG_Message_Alloc_I
# define MSG_Message_Config MSG_Message_Config_I
# define MSG_Message_Free MSG_Message_Free_I
# define MSG_Message_Send MSG_Message_Send_I
# define MSG_Message_Receive MSG_Message_Receive_I
# define MSG_Message_Reply MSG_Message_Reply_I
# define MSG_Message_Return MSG_Message_Return_I
#else
/* Utilisation avec vérification des arguments */
# define MSG_Library_Open MSG_Library_Open_C
# define MSG_Library_IsOpen MSG_Library_IsOpen_C
# define MSG_Library_Signal MSG_Library_Signal_C
# define MSG_Library_Context_Set MSG_Library_Context_Set_C
# define MSG_Library_Context_Get MSG_Library_Context_Get_C
# define MSG_Library_Close MSG_Library_Close_C
# define MSG_Library_Stderr_Set MSG_Library_Stderr_Set_C
# define MSG_Library_Dump MSG_Library_Dump_C
# define MSG_Port_Exist MSG_Port_Exist_C
# define MSG_Port_Open MSG_Port_Open_C
# define MSG_Port_Config MSG_Port_Config_C
# define MSG_Port_Lock MSG_Port_Lock_C
# define MSG_Port_Unlock MSG_Port_Unlock_C
# define MSG_Port_Close MSG_Port_Close_C
# define MSG_PortList_Open MSG_PortList_Open_C
# define MSG_PortList_Port_Add MSG_PortList_Port_Add_C
# define MSG_PortList_Port_Remove MSG_PortList_Port_Remove_C
# define MSG_PortList_Close MSG_PortList_Close_C
# define MSG_PortList_Listen MSG_PortList_Listen_C
# define MSG_Message_Alloc MSG_Message_Alloc_C
# define MSG_Message_Config MSG_Message_Config_C
# define MSG_Message_Free MSG_Message_Free_C
# define MSG_Message_Send MSG_Message_Send_C
# define MSG_Message_Receive MSG_Message_Receive_C
# define MSG_Message_Reply MSG_Message_Reply_C
# define MSG_Message_Return MSG_Message_Return_C
#endif
/*------------------------------------------------------------------------------*/
/* Permet d'indiquer à la librairie qu'un signal a été reçu. */
/* */
/* NB : cette fonction sera appelée par l'utilisateur pour éviter que le */
/* processus se bloque sur une attente de message malgré la réception de signal */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Library_Signal_I ( void );
MSGT_Status MSG_Library_Signal_C ( void );
/*------------------------------------------------------------------------------*/
/* Ouverture de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Instance : numéro de l'instance de la librairie */
/* (I) Context : contexte d'utilisation de la librairie */
/* (I) Open_Mode : mode d'ouverture de la librairie */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Library_Open_I ( int Instance, const char * Context, MSGT_Flags Open_Mode );
MSGT_Status MSG_Library_Open_C ( int Instance, const char * Context, MSGT_Flags Open_Mode );
/*------------------------------------------------------------------------------*/
/* Teste si la librairie a été ouverte */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Library_IsOpen_I ( void );
MSGT_Status MSG_Library_IsOpen_C ( void );
/*------------------------------------------------------------------------------*/
/* Changement de contexte d'utilisation de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Context : nom du nouveau contexte */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Library_Context_Set_I (const char * Context);
MSGT_Status MSG_Library_Context_Set_C (const char * Context);
/*------------------------------------------------------------------------------*/
/* Récupération du nom du contexte utilisée */
/*------------------------------------------------------------------------------*/
/* (O) Context : adresse du nom du contexte utilisé */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Library_Context_Get_I (char ** Context);
MSGT_Status MSG_Library_Context_Get_C (char ** Context);
/*------------------------------------------------------------------------------*/
/* Fermeture de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Close_Mode : mode de fermeture de la librairie */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Library_Close_I ( MSGT_Flags Close_Mode );
MSGT_Status MSG_Library_Close_C ( MSGT_Flags Close_Mode );
/*------------------------------------------------------------------------------*/
/* Définition de la sortie standard des messages d'erreur de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Out : flux de sortie des messages d'erreur */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Library_Stderr_Set_I ( FILE * Out );
MSGT_Status MSG_Library_Stderr_Set_C ( FILE * Out );
/*------------------------------------------------------------------------------*/
/* Affichage des ressources de la librairie */
/*------------------------------------------------------------------------------*/
/* (I) Out : Flux de sortie de l'affichage */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Library_Dump_I ( FILE * Out );
MSGT_Status MSG_Library_Dump_C ( FILE * Out );
/*------------------------------------------------------------------------------*/
/* Teste l'existence d'un port de messages */
/*------------------------------------------------------------------------------*/
/* (I) Name : nom du port de messages */
/* (O) Port : adresse d'un pointeur sur le port de messages */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Port_Exist_I ( const char *, MSGT_Port ** );
MSGT_Status MSG_Port_Exist_C ( const char *, MSGT_Port ** );
/*------------------------------------------------------------------------------*/
/* Création/ouverture d'un port de messages */
/*------------------------------------------------------------------------------*/
/* (I) Name : nom du port de messages */
/* (O) Port : adresse d'un pointeur sur le port de messages */
/* (I) Open_Mode : mode d'ouverture du port de messages */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Port_Open_I ( const char * Name, MSGT_Port ** Port, MSGT_Flags Open_Mode );
MSGT_Status MSG_Port_Open_C ( const char * Name, MSGT_Port ** Port, MSGT_Flags Open_Mode );
/*------------------------------------------------------------------------------*/
/* Configuration d'un port de messages */
/*------------------------------------------------------------------------------*/
/* (I) Port : pointeur sur le port de messages */
/* (I) Tag : type de configuration */
/* (I) ... : données de configuration */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Port_Config_I ( MSGT_Port * Port, MSGT_Config Tag, ... );
MSGT_Status MSG_Port_Config_C ( MSGT_Port * Port, MSGT_Config Tag, ... );
/*------------------------------------------------------------------------------*/
/* Verrouillage d'un port de messages */
/*------------------------------------------------------------------------------*/
/* (I) Port : pointeur sur le port de messages */
/* (I) Mode : type de verrouillage */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Port_Lock_I ( MSGT_Port * Port, MSGT_Flags Mode );
MSGT_Status MSG_Port_Lock_C ( MSGT_Port * Port, MSGT_Flags Mode );
/*------------------------------------------------------------------------------*/
/* Déverrouillage d'un port de messages */
/*------------------------------------------------------------------------------*/
/* (I) Port : pointeur sur le port de messages */
/* (I) Mode : type de verrou à enlever */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Port_Unlock_I ( MSGT_Port * Port, MSGT_Flags Mode );
MSGT_Status MSG_Port_Unlock_C ( MSGT_Port * Port, MSGT_Flags Mode );
/*------------------------------------------------------------------------------*/
/* Fermeture d'un port de messages */
/*------------------------------------------------------------------------------*/
/* (I) Port : pointeur sur le port de messages */
/* (I) Close_Mode : mode de fermeture du port de messages */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Port_Close_I ( MSGT_Port * Port, MSGT_Flags Close_Mode );
MSGT_Status MSG_Port_Close_C ( MSGT_Port * Port, MSGT_Flags Close_Mode );
/*------------------------------------------------------------------------------*/
/* Création/ouverture d'une liste de ports de messages */
/*------------------------------------------------------------------------------*/
/* (O) PortList : adresse d'un pointeur sur la liste de ports de messages */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_PortList_Open_I ( MSGT_PortList ** PortList );
MSGT_Status MSG_PortList_Open_C ( MSGT_PortList ** PortList );
/*------------------------------------------------------------------------------*/
/* Ajout d'un port de messages à une liste de ports */
/*------------------------------------------------------------------------------*/
/* (I) PortList : pointeur sur la liste de ports de messages */
/* (I) Port : pointeur sur un port de messages */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_PortList_Port_Add_I ( MSGT_PortList * PortList, MSGT_Port * Port );
MSGT_Status MSG_PortList_Port_Add_C ( MSGT_PortList * PortList, MSGT_Port * Port );
/*------------------------------------------------------------------------------*/
/* Retrait d'un port de messages d'une liste de ports */
/*------------------------------------------------------------------------------*/
/* (I) PortList : pointeur sur la liste de ports de messages */
/* (I) Port : pointeur sur un port de messages */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_PortList_Port_Remove_I ( MSGT_PortList * PortList, MSGT_Port * Port );
MSGT_Status MSG_PortList_Port_Remove_C ( MSGT_PortList * PortList, MSGT_Port * Port );
/*------------------------------------------------------------------------------*/
/* Suppressin d'une liste de ports de messages */
/*------------------------------------------------------------------------------*/
/* (I) PortList : pointeur sur la liste de ports de messages */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_PortList_Close_I ( MSGT_PortList * PortList );
MSGT_Status MSG_PortList_Close_C ( MSGT_PortList * PortList );
/*------------------------------------------------------------------------------*/
/* Ecoute d'une liste de ports de messages */
/*------------------------------------------------------------------------------*/
/* (I) PortList : pointeur sur une liste de ports de messages */
/* (I) Type : type du message à récupérer */
/* (O) Msg : adresse d'un pointeur sur le message à recevoir */
/* (I) Flags : paramètres de réception */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_PortList_Listen_I ( MSGT_PortList * PortList, unsigned int Type, MSGT_Message ** Msg, MSGT_Flags Flags);
MSGT_Status MSG_PortList_Listen_C ( MSGT_PortList * PortList, unsigned int Type, MSGT_Message ** Msg, MSGT_Flags Flags);
/*------------------------------------------------------------------------------*/
/* Création d'un message */
/*------------------------------------------------------------------------------*/
/* (O) Msg : adresse d'un pointeur sur le message */
/* (I) Size : taille en octets des données du message */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Message_Alloc_I ( MSGT_Message ** Msg, size_t Size );
MSGT_Status MSG_Message_Alloc_C ( MSGT_Message ** Msg, size_t Size );
/*------------------------------------------------------------------------------*/
/* Configuration d'un message */
/*------------------------------------------------------------------------------*/
/* (I) Msg : pointeur sur un message */
/* (I) Tag : type de configuration */
/* (I) ... : données de configuration */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Message_Config_I ( MSGT_Message * Msg, MSGT_Config Tag, ... );
MSGT_Status MSG_Message_Config_C ( MSGT_Message * Msg, MSGT_Config Tag, ... );
/*------------------------------------------------------------------------------*/
/* Destruction d'un message */
/*------------------------------------------------------------------------------*/
/* (I) Msg : pointeur sur le message */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Message_Free_I ( MSGT_Message * Msg );
MSGT_Status MSG_Message_Free_C ( MSGT_Message * Msg );
/*------------------------------------------------------------------------------*/
/* Envoi d'un message dans un port de messages */
/*------------------------------------------------------------------------------*/
/* (I) From : nom du port de messages de l'envoyeur */
/* (I) To : pointeur sur le port de messages destinataire */
/* (I) Msg : pointeur sur le message */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Message_Send_I ( const char * From, MSGT_Port * To, MSGT_Message * Msg );
MSGT_Status MSG_Message_Send_C ( const char * From, MSGT_Port * To, MSGT_Message * Msg );
/*------------------------------------------------------------------------------*/
/* Réception d'un message dans un port de messages */
/*------------------------------------------------------------------------------*/
/* (I) Port : pointeur sur le port de messages */
/* (I) Type : type du message à récupérer */
/* (O) Msg : adresse d'un pointeur sur le message à recevoir */
/* (I) Flags : paramètres de réception */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Message_Receive_I ( MSGT_Port * Port, unsigned int Type, MSGT_Message ** Msg, MSGT_Flags Flags );
MSGT_Status MSG_Message_Receive_C ( MSGT_Port * Port, unsigned int Type, MSGT_Message ** Msg, MSGT_Flags Flags );
/*------------------------------------------------------------------------------*/
/* Retour à l'envoyeur d'un message */
/*------------------------------------------------------------------------------*/
/* (I) Msg : pointeur sur le message */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Message_Reply_I ( MSGT_Message * Msg );
MSGT_Status MSG_Message_Reply_C ( MSGT_Message * Msg );
/*------------------------------------------------------------------------------*/
/* Retour à l'initiateur d'un message */
/*------------------------------------------------------------------------------*/
/* (I) Msg : pointeur sur le message */
/*------------------------------------------------------------------------------*/
MSGT_Status MSG_Message_Return_I ( MSGT_Message * Msg );
MSGT_Status MSG_Message_Return_C ( MSGT_Message * Msg );
#ifdef __cplusplus
}
#endif
#endif