Dans votre carrière de développeur, vous serez (si ce n'est pas déjà le cas) confronté à un moment ou un autre au besoin de faire communiquer des applications entre elles. Il existe de nombreuses techniques sous Windows vous permettant de réaliser cette opération. Ces techniques sont souvent réunies sous le nom de Communication InterProcessus (ou IPC en anglais pour Interprocess Communication). Leur but est de faire transiter une certaine quantité d'informations d'un processus à un autre (le plus souvent des applications).

Les principales techniques disponibles sous Windows sont :

• le presse-papier ;
• COM ;
• les messages Windows (et en particulier le message WM_COPYDATA) ;
• DDE ;
• les fichiers mappés (file mapping) ;
• les mailslots ;
• les pipes (anonymes ou nommés) ;
• RPC ;
• les sockets Windows.

Il existe d'autres moyens d'arriver à nos fins, comme l'utilisation de fichiers temporaires ou de la base de registre, mais ce ne sont pas à proprement parler des techniques IPC.

Nous allons nous intéresser aux mailslots. Il s'agit d'une technique très simple d'emploi, mais qui peut rendre de nombreux services.
Pour vous faire une idée plus précise de ce que sont les mailslots, imaginez juste une boîte aux lettres dont seul le propriétaire a la clé. Toutes les personnes connaissant l'adresse de la boîte peuvent y déposer des messages, mais seul le propriétaire peut les lire. C'est tout simplement comme ça que fonctionnent les mailslots.
Nous appellerons le propriétaire de la boîte le processus serveur, et les personnes déposant des messages les processus clients.
Les mailslots sont unidirectionnels, c'est-à-dire que la communication ne s'effectue que dans un seul sens : du client vers le serveur. Ceci dit, rien ne vous empêche d'utiliser dans la même application un mailslot pour l'envoi et un autre pour la réception.
Les mailslots sont asynchrones, c'est-à-dire que le client dépose son message et que le serveur le lit quand il le désire ou quand il en a le temps. Il n'y a donc aucun moyen de savoir si un message a été lu ou non.
Un message ne peut dépasser la taille de 64 Ko (ou 425 octets en broadcast, voir plus loin). Si vous voulez faire transiter des masses de données plus importantes, tournez-vous vers une autre technique.
Si vous trouvez que c'est un mauvais début, attendez un peu…

Les mailslots présentent certains avantages :

• ils ne nécessitent qu'un jeu de fonctions très réduit et simple à utiliser ;
• ils permettent de faire communiquer simplement des processus s'exécutant sur différents ordinateurs à travers un réseau ;
• ils intègrent également un mécanisme de diffusion qui permet à un client d'envoyer un message à tous les serveurs d'un domaine en un seul appel.

Vous trouvez que cela redevient intéressant ? Alors, continuons.

Avant de découvrir en détail l'utilisation des mailslots, penchons-nous un moment sur la syntaxe des adresses.
Les adresses des mailslots doivent être construites en suivant certaines règles simples. Ces règles sont communes au client et au serveur, mais vous n'emploierez pas toujours la même forme pour un client que pour un serveur. La forme générale d'une adresse de mailslot est la suivante :

Les parties apparaissant en bleu sont obligatoires et ne peuvent être modifiées. La partie apparaissant en vert est facultative. Le reste est à votre disposition.
Décomposons cette adresse pour la comprendre :

• une adresse de mailslot commence toujours par un double antislash '\\' ;

• vient ensuite le nom de l'emplacement du mailslot. Cet emplacement peut représenter :

  • un ordinateur : nous utiliserons le nom de l'ordinateur dans le réseau,
  • tous les ordinateurs d'un domaine : nous utiliserons le nom du domaine (ou du groupe de travail),
  • tous les ordinateurs du domaine principal : nous utiliserons le caractère étoile '*',
  • l'ordinateur sur lequel le processus s'exécute : nous utiliserons le caractère point '.'.
    Attention : seuls les messages de moins de 425 octets peuvent être envoyés à plusieurs ordinateurs en même temps (broadcast) ;
• l'emplacement est toujours suivi de la chaîne '\mailslot\' qui indique qu'il ne s'agit pas d'un « vrai » fichier, mais bien d'un mailslot ;
• la dernière section est constituée d'un certain nombre de répertoires séparés par des antislashs '\' et du nom du mailslot. Cette section est donc construite comme un chemin de fichier classique. Vous pouvez donc classer les mailslots par répertoires si vous en utilisez beaucoup en même temps ou si vous voulez être rigoureux.

Les clients et le serveur devront utiliser la même adresse pour communiquer à une exception près : l'emplacement de création du mailslot par le serveur est toujours l'ordinateur local, donc le point '.'.

Un petit exemple
Imaginons que le serveur s'exécute sur un ordinateur appelé 'SERVEUR' situé sur un domaine appelé 'DOMAINE' et que le mailslot porte le nom de 'TEST'.

• Le mailslot sera créé par le processus serveur avec l'adresse : '\\.\mailslot\TEST'.
• Le mailslot sera ouvert par un client s'exécutant sur la même machine avec l'adresse '\\.\mailslot\TEST'.
• Le mailslot sera ouvert par un client s'exécutant sur une autre machine avec l'adresse '\\SERVEUR\mailslot\TEST'.
• Le mailslot sera ouvert par un client désirant envoyer un message à tous les serveurs du domaine 'DOMAINE' avec l'adresse '\\DOMAINE\mailslot\TEST'.
• Enfin, le mailslot sera ouvert par un client désirant envoyer un message à tous les serveurs du domaine principal avec l'adresse '\\*\mailslot\TEST'.

Sachez enfin que les adresses de mailslots ne sont pas sensibles à la casse. Les adresses '\\.\mailslot\test' et '\\.\MAILSLOT\TEST' sont donc équivalentes.

Les mailslots sont implémentés comme des pseudofichiers. En clair, cela signifie que les fonctions permettant d'envoyer ou de lire des messages sont les mêmes que celles habituellement utilisées pour les fichiers. Seules trois fonctions leur sont spécifiques.

III-A. CreateMailslot▲

          function CreateMailslot(lpName: PChar; nMaxMessageSize: DWORD;
            lReadTimeout: DWORD; lpSecurityAttributes: PSecurityAttributes): THandle; stdcall;

          h:= CreateMailslot('\\.\mailslot\MonMailslot', 0, MAILSLOT_WAIT_FOREVER, nil);

III-B. GetMailslotInfo▲

          function GetMailslotInfo(hMailslot: THandle; lpMaxMessageSize: Pointer;
            var lpNextSize: DWORD; lpMessageCount, lpReadTimeout: Pointer): BOOL; stdcall;

III-C. SetMailslotInfo▲

          function SetMailslotInfo(hMailslot: THandle; lReadTimeout: DWORD): BOOL; stdcall;

Maintenant que nous savons comment les mailslots fonctionnent, voyons comment les utiliser en Delphi.

IV-A. Un exemple simple▲

        FHandle: THandle;

      FHandle:= CreateMailslot('\\.\mailslot\ExempleSimple', 0,
        MAILSLOT_WAIT_FOREVER, nil);

      CloseHandle(FHandle);

    var
      lpNextSize, lpMessageCount, lpNumberOfBytesRead: Cardinal;
      buffer: string;
    begin
      if GetMailslotInfo(FHandle, nil, lpNextSize, @lpMessagecount, nil) and
        (lpMessageCount > 0) then
      begin
        SetLength(buffer, lpNextSize);
        if ReadFile(FHandle, buffer[1], lpNextSize, lpNumberOfBytesRead, nil) then
          mmMessages.Lines.Add(buffer);
      end;
    end;

    unit ServeurFrm;

    interface

    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
      Dialogs, StdCtrls;

    type
      TForm1 = class(TForm)
        mmMessages: TMemo;
        btnLire: TButton;
        procedure FormCreate(Sender: TObject);
        procedure FormDestroy(Sender: TObject);
        procedure btnLireClick(Sender: TObject);
      private
        { Private declarations }
        FHandle: THandle;
      public
        { Public declarations }
      end;
    
    var
      Form1: TForm1;
    
    implementation
    
    {$R *.dfm}
    
    procedure TForm1.FormCreate(Sender: TObject);
    begin
      FHandle:= CreateMailslot('\\.\mailslot\ExempleSimple', 0,
        MAILSLOT_WAIT_FOREVER, nil);
    end;
    
    procedure TForm1.FormDestroy(Sender: TObject);
    begin
      CloseHandle(FHandle);
    end;

    procedure TForm1.btnLireClick(Sender: TObject);
    var
      lpNextSize, lpMessageCount, lpNumberOfBytesRead: Cardinal;
      buffer: string;
    begin
      if GetMailslotInfo(FHandle, nil, lpNextSize, @lpMessagecount, nil) and
        (lpMessageCount > 0) then
      begin
        SetLength(buffer, lpNextSize);
        if ReadFile(FHandle, buffer[1], lpNextSize, lpNumberOfBytesRead, nil) then
          mmMessages.Lines.Add(buffer);
      end;
    end;
    
    end.

var
  FHandle: THandle;
  buffer: PChar;
  lpNumberOfBytesWritten: Cardinal;
begin
  FHandle:= CreateFile('\\.\mailslot\ExempleSimple', GENERIC_WRITE,
    FILE_SHARE_READ, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
  if FHandle = INVALID_HANDLE_VALUE then
    raise Exception.Create(SysErrorMessage(GetLastError))
  else
  begin
    buffer:= PChar(mmMessage.Lines.Text);
    WriteFile(FHandle, buffer^, Length(buffer),
      lpNumberOfBytesWritten, nil);
    CloseHandle(FHandle);
  end;
end;

IV-B. Allons plus loin▲

unit Mailslots;

interface
uses
  Classes, Windows;

type
  TMailslotCommon = class
  private
    FMailslotName: string;
    procedure SetMailslotName(const Value: string);
    function GetConnected: boolean;
    procedure SetConnected(const Value: boolean);
    procedure SetLocation(const Value: string);
  protected
    FMSHandle: THandle;
    FLocation: string;

    procedure RaiseError(Msg: string = '');

    property Location: string read FLocation write SetLocation;
  public
    constructor Create; virtual;
    destructor Destroy; override;

    function Connect: boolean; virtual; abstract;
    procedure Disconnect; virtual;
    function GetMailslotAddress: string;

    property Connected: boolean read GetConnected write SetConnected;
    property MailslotName: string read FMailslotName write SetMailslotName;
  end;

  TMailslotServer = class(TMailslotCommon)
  public
    function Connect: boolean; override;
    function MessageCount: Cardinal;
    function NextMessageSize: Cardinal;
    procedure ReadBuffer(var Buffer; BufferSize: Cardinal);
    procedure ReadStream(AStream: TStream);
    function ReadString: string;
  end;

  TMailslotClient = class(TMailslotCommon)
  public
    function Connect: boolean; override;
    procedure WriteBuffer(const Buffer; BufferSize: Cardinal);
    procedure WriteStream(AStream: TStream);
    procedure WriteString(AString: string);

    property Location; // rendu accessible pour le client uniquement
  end;

• Voici un lien vers la description des mailslots disponible sur le site Microsoft Developer Network (MSDN) : Platform SDK: Interprocess Communications : Mailslots
• Le projet de démonstration incluant l'unité mailslots.pas (Delphi 7) : DelphiMailslots.zip