Serveur de canal nommé utilisant des E/S superposées
Voici un exemple de serveur de canal à thread unique qui utilise des opérations qui se chevauchent pour traiter les connexions simultanées à plusieurs clients de canal. Le serveur de canal crée un nombre fixe d’instances de canal. Chaque instance de canal peut être connecté à un client de canal distinct. Lorsqu’un client de canal a fini d’utiliser son instance de canal, le serveur se déconnecte du client et réutilise le canal instance pour se connecter à un nouveau client. Ce serveur de canal peut être utilisé avec le client de canal décrit dans Client de canal nommé.
La structure CHEVAUCHEMENT EST spécifiée en tant que paramètre dans chaque opération ReadFile, WriteFile et ConnectNamedPipe sur le instance de canal. Bien que l’exemple montre des opérations simultanées sur différentes instances de canal, il évite les opérations simultanées sur un seul canal instance à l’aide de l’objet événement dans la structure CHEVAUCHEMENT. Étant donné que le même objet d’événement est utilisé pour les opérations de lecture, d’écriture et de connexion pour chaque instance, il n’existe aucun moyen de savoir quelle opération d’achèvement a provoqué la définition de l’événement à l’état signalé pour les opérations simultanées utilisant le même instance de canal.
Les handles d’événement pour chaque canal instance sont stockés dans un tableau passé à la fonction WaitForMultipleObjects. Cette fonction attend que l’un des événements soit signalé et retourne l’index de tableau de l’événement qui a provoqué la fin de l’opération d’attente. L’exemple de cette rubrique utilise cet index de tableau pour récupérer une structure contenant des informations pour le instance de canal. Le serveur utilise le membre fPendingIO de la structure pour vérifier si l’opération d’E/S la plus récente sur le instance était en attente, ce qui nécessite un appel à la fonction GetOverlappedResult. Le serveur utilise le membre dwState de la structure pour déterminer l’opération suivante qui doit être effectuée pour le instance de canal.
Les opérations ReadFile, WriteFile et ConnectNamedPipe qui se chevauchent peuvent se terminer au moment où la fonction retourne. Sinon, si l’opération est en attente, l’objet d’événement dans la structure CHEVAUCHEMENT SPÉCIFIÉE est défini sur l’état non signé avant que la fonction ne retourne. Une fois l’opération en attente terminée, le système définit l’état de l’objet événement sur signal. L’état de l’objet d’événement n’est pas modifié si l’opération se termine avant le retour de la fonction.
Étant donné que l’exemple utilise des objets d’événement de réinitialisation manuelle, l’état d’un objet d’événement n’est pas modifié en non-signature par la fonction WaitForMultipleObjects . Cela est important, car l’exemple s’appuie sur les objets d’événement restant à l’état signalé, sauf en cas d’opération en attente.
Si l’opération est déjà terminée lorsque ReadFile, WriteFile ou ConnectNamedPipe retourne, la valeur de retour de la fonction indique le résultat. Pour les opérations de lecture et d’écriture, le nombre d’octets transférés est également retourné. Si l’opération est toujours en attente, la fonction ReadFile, WriteFile ou ConnectNamedPipe retourne zéro et la fonction GetLastError retourne ERROR_IO_PENDING. Dans ce cas, utilisez la fonction GetOverlappedResult pour récupérer les résultats une fois l’opération terminée. GetOverlappedResult retourne uniquement les résultats des opérations en attente. Il ne signale pas les résultats des opérations qui ont été effectuées avant la fonction ReadFile, WriteFile ou ConnectNamedPipe qui se chevauche.
Avant de vous déconnecter d’un client, vous devez attendre qu’un signal indiquant que le client a terminé. (Le vidage des mémoires tampons de fichier contreviendrait à l’objectif des E/S qui se chevauchent, car l’opération de vidage bloquerait l’exécution du thread serveur pendant qu’elle attend que le client vide le canal.) Dans cet exemple, le signal est l’erreur générée en essayant de lire à partir du canal après que le client de canal a fermé son handle.
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <strsafe.h>
#define CONNECTING_STATE 0
#define READING_STATE 1
#define WRITING_STATE 2
#define INSTANCES 4
#define PIPE_TIMEOUT 5000
#define BUFSIZE 4096
typedef struct
{
OVERLAPPED oOverlap;
HANDLE hPipeInst;
TCHAR chRequest[BUFSIZE];
DWORD cbRead;
TCHAR chReply[BUFSIZE];
DWORD cbToWrite;
DWORD dwState;
BOOL fPendingIO;
} PIPEINST, *LPPIPEINST;
VOID DisconnectAndReconnect(DWORD);
BOOL ConnectToNewClient(HANDLE, LPOVERLAPPED);
VOID GetAnswerToRequest(LPPIPEINST);
PIPEINST Pipe[INSTANCES];
HANDLE hEvents[INSTANCES];
int _tmain(VOID)
{
DWORD i, dwWait, cbRet, dwErr;
BOOL fSuccess;
LPCTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe");
// The initial loop creates several instances of a named pipe
// along with an event object for each instance. An
// overlapped ConnectNamedPipe operation is started for
// each instance.
for (i = 0; i < INSTANCES; i++)
{
// Create an event object for this instance.
hEvents[i] = CreateEvent(
NULL, // default security attribute
TRUE, // manual-reset event
TRUE, // initial state = signaled
NULL); // unnamed event object
if (hEvents[i] == NULL)
{
printf("CreateEvent failed with %d.\n", GetLastError());
return 0;
}
Pipe[i].oOverlap.hEvent = hEvents[i];
Pipe[i].oOverlap.Offset = 0;
Pipe[i].oOverlap.OffsetHigh = 0;
Pipe[i].hPipeInst = CreateNamedPipe(
lpszPipename, // pipe name
PIPE_ACCESS_DUPLEX | // read/write access
FILE_FLAG_OVERLAPPED, // overlapped mode
PIPE_TYPE_MESSAGE | // message-type pipe
PIPE_READMODE_MESSAGE | // message-read mode
PIPE_WAIT, // blocking mode
INSTANCES, // number of instances
BUFSIZE*sizeof(TCHAR), // output buffer size
BUFSIZE*sizeof(TCHAR), // input buffer size
PIPE_TIMEOUT, // client time-out
NULL); // default security attributes
if (Pipe[i].hPipeInst == INVALID_HANDLE_VALUE)
{
printf("CreateNamedPipe failed with %d.\n", GetLastError());
return 0;
}
// Call the subroutine to connect to the new client
Pipe[i].fPendingIO = ConnectToNewClient(
Pipe[i].hPipeInst,
&Pipe[i].oOverlap);
Pipe[i].dwState = Pipe[i].fPendingIO ?
CONNECTING_STATE : // still connecting
READING_STATE; // ready to read
}
while (1)
{
// Wait for the event object to be signaled, indicating
// completion of an overlapped read, write, or
// connect operation.
dwWait = WaitForMultipleObjects(
INSTANCES, // number of event objects
hEvents, // array of event objects
FALSE, // does not wait for all
INFINITE); // waits indefinitely
// dwWait shows which pipe completed the operation.
i = dwWait - WAIT_OBJECT_0; // determines which pipe
if (i < 0 || i > (INSTANCES - 1))
{
printf("Index out of range.\n");
return 0;
}
// Get the result if the operation was pending.
if (Pipe[i].fPendingIO)
{
fSuccess = GetOverlappedResult(
Pipe[i].hPipeInst, // handle to pipe
&Pipe[i].oOverlap, // OVERLAPPED structure
&cbRet, // bytes transferred
FALSE); // do not wait
switch (Pipe[i].dwState)
{
// Pending connect operation
case CONNECTING_STATE:
if (! fSuccess)
{
printf("Error %d.\n", GetLastError());
return 0;
}
Pipe[i].dwState = READING_STATE;
break;
// Pending read operation
case READING_STATE:
if (! fSuccess || cbRet == 0)
{
DisconnectAndReconnect(i);
continue;
}
Pipe[i].cbRead = cbRet;
Pipe[i].dwState = WRITING_STATE;
break;
// Pending write operation
case WRITING_STATE:
if (! fSuccess || cbRet != Pipe[i].cbToWrite)
{
DisconnectAndReconnect(i);
continue;
}
Pipe[i].dwState = READING_STATE;
break;
default:
{
printf("Invalid pipe state.\n");
return 0;
}
}
}
// The pipe state determines which operation to do next.
switch (Pipe[i].dwState)
{
// READING_STATE:
// The pipe instance is connected to the client
// and is ready to read a request from the client.
case READING_STATE:
fSuccess = ReadFile(
Pipe[i].hPipeInst,
Pipe[i].chRequest,
BUFSIZE*sizeof(TCHAR),
&Pipe[i].cbRead,
&Pipe[i].oOverlap);
// The read operation completed successfully.
if (fSuccess && Pipe[i].cbRead != 0)
{
Pipe[i].fPendingIO = FALSE;
Pipe[i].dwState = WRITING_STATE;
continue;
}
// The read operation is still pending.
dwErr = GetLastError();
if (! fSuccess && (dwErr == ERROR_IO_PENDING))
{
Pipe[i].fPendingIO = TRUE;
continue;
}
// An error occurred; disconnect from the client.
DisconnectAndReconnect(i);
break;
// WRITING_STATE:
// The request was successfully read from the client.
// Get the reply data and write it to the client.
case WRITING_STATE:
GetAnswerToRequest(&Pipe[i]);
fSuccess = WriteFile(
Pipe[i].hPipeInst,
Pipe[i].chReply,
Pipe[i].cbToWrite,
&cbRet,
&Pipe[i].oOverlap);
// The write operation completed successfully.
if (fSuccess && cbRet == Pipe[i].cbToWrite)
{
Pipe[i].fPendingIO = FALSE;
Pipe[i].dwState = READING_STATE;
continue;
}
// The write operation is still pending.
dwErr = GetLastError();
if (! fSuccess && (dwErr == ERROR_IO_PENDING))
{
Pipe[i].fPendingIO = TRUE;
continue;
}
// An error occurred; disconnect from the client.
DisconnectAndReconnect(i);
break;
default:
{
printf("Invalid pipe state.\n");
return 0;
}
}
}
return 0;
}
// DisconnectAndReconnect(DWORD)
// This function is called when an error occurs or when the client
// closes its handle to the pipe. Disconnect from this client, then
// call ConnectNamedPipe to wait for another client to connect.
VOID DisconnectAndReconnect(DWORD i)
{
// Disconnect the pipe instance.
if (! DisconnectNamedPipe(Pipe[i].hPipeInst) )
{
printf("DisconnectNamedPipe failed with %d.\n", GetLastError());
}
// Call a subroutine to connect to the new client.
Pipe[i].fPendingIO = ConnectToNewClient(
Pipe[i].hPipeInst,
&Pipe[i].oOverlap);
Pipe[i].dwState = Pipe[i].fPendingIO ?
CONNECTING_STATE : // still connecting
READING_STATE; // ready to read
}
// ConnectToNewClient(HANDLE, LPOVERLAPPED)
// This function is called to start an overlapped connect operation.
// It returns TRUE if an operation is pending or FALSE if the
// connection has been completed.
BOOL ConnectToNewClient(HANDLE hPipe, LPOVERLAPPED lpo)
{
BOOL fConnected, fPendingIO = FALSE;
// Start an overlapped connection for this pipe instance.
fConnected = ConnectNamedPipe(hPipe, lpo);
// Overlapped ConnectNamedPipe should return zero.
if (fConnected)
{
printf("ConnectNamedPipe failed with %d.\n", GetLastError());
return 0;
}
switch (GetLastError())
{
// The overlapped connection in progress.
case ERROR_IO_PENDING:
fPendingIO = TRUE;
break;
// Client is already connected, so signal an event.
case ERROR_PIPE_CONNECTED:
if (SetEvent(lpo->hEvent))
break;
// If an error occurs during the connect operation...
default:
{
printf("ConnectNamedPipe failed with %d.\n", GetLastError());
return 0;
}
}
return fPendingIO;
}
VOID GetAnswerToRequest(LPPIPEINST pipe)
{
_tprintf( TEXT("[%d] %s\n"), pipe->hPipeInst, pipe->chRequest);
StringCchCopy( pipe->chReply, BUFSIZE, TEXT("Default answer from server") );
pipe->cbToWrite = (lstrlen(pipe->chReply)+1)*sizeof(TCHAR);
}
Rubriques connexes