Bonjour voici de la documentation. Elle n'a pas été écrite par moi-même, mais par un de mes professeurs. En espérant que tu trouveras une réponse dans ce texte.

---

Les messages

Les messages sont au coeur de Neutrino. Ils ne sont pas seulement utilisés par les applications, mais aussi par les appels système.

Ils sont basés sur le modèle client-serveur.

Point de vue du client

Établissement de la connexion

#include <sys/neutrino.h>
int ConnectAttach(
   int nd,         // Node Descriptor       (descripteur de noeud)
   pid_t pid,      // Process ID            (identificateur de processus)
   int chid,       // Channel ID            (identificateur de canal)
   unsigned index, // à zéro pour le moment
   int flags       // à zéro pour le moment
);   

Le serveur auquel le cilent veut se connecter peut ainsi être identifié par le trio unique ND-PID-CHID.

Supposons que le client veut se connecter au processus 135, canal 1, sur le noeud (ordinateur) courant. Nous aurons:

int coid = ConnectAttach( 0, 135, 1, 0, 0 );

La variable nommée ici "coid" pour Connection ID, est un petit entier qui identifie de façon unique la connexion et qui pourra être utilisé pour tous les échanges du client avec le serveur.

Envoi d'un message

#include <sys/neutrino.h>
int MsgSend(
   int coid,         // Connection ID
   const void *smsg, // pointeur sur le message envoyé
   int sbytes,       // taille du message envoyé
   void *rmsg,       // pointeur sur la réponse
   int rbytes        // taille de la réponse
);

Envoyons maintenant un message:

#include <sys/neutrino.h>

char *smsg = "Message du client vers le serveur";
char rmsg[ 200 ]; // tampon pour la réponse
int coid;

// établissement de la connexion
coid = ConnectAttach( 0, 135, 1, 0, 0 );
if( coid == -1 )
{
   // traitement de l'erreur
}

// envoi du message
if( MsgSend( coid, smsg, strlen( smsg ) + 1, rmsg, sizeof( rmsg ) ) == -1 )
{
   // traitement de l'erreur
}

if( strlen( rmsg ) > 0 )
{
   printf( "Réponse = %s\n", rmsg );
}

La valeur de retour de MsgSend est décidée par le serveur.

Dans l'exemple, on suppose que la réponse du serveur est une chaîne ASCIIZ.

Point de vue du serveur

Avant que le client puisse se connecter, le serveur doit créer un canal:

#include <sys/neutrino.h>
int ChannelCreate( unsigned flags ); // flags = 0 pour le moment

La valeur retournée par ChannelCreate est l'identificateur de canal (channel ID).

À la toute fin de son exécution, le serveur détruit le canal:

int ChannelDestroy( int chid );

Au niveau du serveur, le traitement des messages se fait en deux étapes: la réception du message (MsgReceive) et l'envoi de la réponse (MsgReply).

#include <sys/neutrino.h>

int MsgReceive(
   int chid,
   void *msg,
   int nbytes,
   struct _msg_info *info
);

int MsgReply(
   int rcvid,
   int status,
   const void *msg,
   int nbytes
);

[ajouter figure de relation entre les paramètres]

La fonction MsgReceive appelée par le serveur, tout comme la fonction MsgSend appelée par le client sont bloquantes.

Le code suivant est un exemple de serveur:

#include <sys/neutrino.h>

void server( void )
{
   int rcvid;           // indique à qui il faut répondre
   int chid;            // le canal
   char message[ 512 ]; // un gros tampon
   
   // création du canal
   chid = ChannelCreate( 0 );
   
   // boucle infinie typique d'un serveur
   while( 1 )
   {
      // obtention du message
	  rcvid = MsgReceive( chid, message, sizeof( message ), NULL );
	  
	  printf( "Reçu message. Le rcvid est %X\n", rcvid );
	  printf( "Le message est: %s\n", message );
	  
	  // on prépare le message (ici on réutilise "message")
	  strcpy( message, "Ceci est la réponse" );
	  MsgReply( rcvid, EOK, message, sizeof( message ) );
   }
}

[donner exemple complet]

Séquence: