Windows apps
Collapse the table of content
Expand the table of content
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

Named Pipe Server Using Completion Routines

The following example is a single-threaded pipe server that creates a message-type pipe and uses overlapped operations. It uses the extended functions ReadFileEx and WriteFileEx to perform overlapped I/O using a completion routine, which is queued for execution when the operation is finished. The pipe server uses the WaitForSingleObjectEx function, which performs an alertable wait operation that returns when a completion routine is ready to execute. The wait function also returns when an event object is signaled, which in this example indicates that the overlapped ConnectNamedPipe operation has finished (a new client has connected). This pipe server can be used with the pipe client described in Named Pipe Client.

Initially, the pipe server creates a single instance of the pipe and starts an overlapped ConnectNamedPipe operation. When a client connects, the server allocates a structure to provide storage for that pipe instance and then calls the ReadFileEx function to start a sequence of I/O operations to handle communications with the client. Each operation specifies a completion routine that performs the next operation in the sequence. The sequence terminates when the client is disconnected and the pipe instance closed. After starting the sequence of operations for the new client, the server creates another pipe instance and waits for the next client to connect.

The parameters of the ReadFileEx and WriteFileEx functions specify a completion routine and a pointer to an OVERLAPPED structure. This pointer is passed to the completion routine in its lpOverLap parameter. Because the OVERLAPPED structure points to the first member in the structure allocated for each pipe instance, the completion routine can use its lpOverLap parameter to access the structure for the pipe instance.

#include <windows.h> 
#include <stdio.h>
#include <tchar.h>
#include <strsafe.h>

#define PIPE_TIMEOUT 5000
#define BUFSIZE 4096
typedef struct 
   OVERLAPPED oOverlap; 
   HANDLE hPipeInst; 
   TCHAR chRequest[BUFSIZE]; 
   DWORD cbRead;
   TCHAR chReply[BUFSIZE]; 
   DWORD cbToWrite; 
VOID DisconnectAndClose(LPPIPEINST); 
BOOL CreateAndConnectInstance(LPOVERLAPPED); 
VOID GetAnswerToRequest(LPPIPEINST); 

HANDLE hPipe; 
int _tmain(VOID) 
   HANDLE hConnectEvent; 
   OVERLAPPED oConnect; 
   LPPIPEINST lpPipeInst; 
   DWORD dwWait, cbRet; 
   BOOL fSuccess, fPendingIO; 
// Create one event object for the connect operation. 
   hConnectEvent = CreateEvent( 
      NULL,    // default security attribute
      TRUE,    // manual reset event 
      TRUE,    // initial state = signaled 
      NULL);   // unnamed event object 

   if (hConnectEvent == NULL) 
      printf("CreateEvent failed with %d.\n", GetLastError()); 
      return 0;
   oConnect.hEvent = hConnectEvent; 
// Call a subroutine to create one instance, and wait for 
// the client to connect. 
   fPendingIO = CreateAndConnectInstance(&oConnect); 
   while (1) 
   // Wait for a client to connect, or for a read or write 
   // operation to be completed, which causes a completion 
   // routine to be queued for execution. 
      dwWait = WaitForSingleObjectEx( 
         hConnectEvent,  // event object to wait for 
         INFINITE,       // waits indefinitely 
         TRUE);          // alertable wait enabled 
      switch (dwWait) 
      // The wait conditions are satisfied by a completed connect 
      // operation. 
         case 0: 
         // If an operation is pending, get the result of the 
         // connect operation. 
         if (fPendingIO) 
            fSuccess = GetOverlappedResult( 
               hPipe,     // pipe handle 
               &oConnect, // OVERLAPPED structure 
               &cbRet,    // bytes transferred 
               FALSE);    // does not wait 
            if (!fSuccess) 
               printf("ConnectNamedPipe (%d)\n", GetLastError()); 
               return 0;
         // Allocate storage for this instance. 
            lpPipeInst = (LPPIPEINST) GlobalAlloc( 
               GPTR, sizeof(PIPEINST)); 
            if (lpPipeInst == NULL) 
               printf("GlobalAlloc failed (%d)\n", GetLastError()); 
               return 0;
            lpPipeInst->hPipeInst = hPipe; 
         // Start the read operation for this client. 
         // Note that this same routine is later used as a 
         // completion routine after a write operation. 
            lpPipeInst->cbToWrite = 0; 
            CompletedWriteRoutine(0, 0, (LPOVERLAPPED) lpPipeInst); 
         // Create new pipe instance for the next client. 
            fPendingIO = CreateAndConnectInstance( 
      // The wait is satisfied by a completed read or write 
      // operation. This allows the system to execute the 
      // completion routine. 
         case WAIT_IO_COMPLETION: 
      // An error occurred in the wait function. 
            printf("WaitForSingleObjectEx (%d)\n", GetLastError()); 
            return 0;
   return 0; 
// CompletedWriteRoutine(DWORD, DWORD, LPOVERLAPPED) 
// This routine is called as a completion routine after writing to 
// the pipe, or when a new client has connected to a pipe instance.
// It starts another read operation. 
VOID WINAPI CompletedWriteRoutine(DWORD dwErr, DWORD cbWritten, 
   LPPIPEINST lpPipeInst; 
   BOOL fRead = FALSE; 
// lpOverlap points to storage for this instance. 
   lpPipeInst = (LPPIPEINST) lpOverLap; 
// The write operation has finished, so read the next request (if 
// there is no error). 
   if ((dwErr == 0) && (cbWritten == lpPipeInst->cbToWrite)) 
      fRead = ReadFileEx( 
         (LPOVERLAPPED) lpPipeInst, 
         (LPOVERLAPPED_COMPLETION_ROUTINE) CompletedReadRoutine); 
// Disconnect if an error occurred. 
   if (! fRead) 
// CompletedReadRoutine(DWORD, DWORD, LPOVERLAPPED) 
// This routine is called as an I/O completion routine after reading 
// a request from the client. It gets data and writes it to the pipe. 
VOID WINAPI CompletedReadRoutine(DWORD dwErr, DWORD cbBytesRead, 
    LPOVERLAPPED lpOverLap) 
   LPPIPEINST lpPipeInst; 
   BOOL fWrite = FALSE; 
// lpOverlap points to storage for this instance. 
   lpPipeInst = (LPPIPEINST) lpOverLap; 
// The read operation has finished, so write a response (if no 
// error occurred). 
   if ((dwErr == 0) && (cbBytesRead != 0)) 
      fWrite = WriteFileEx( 
         (LPOVERLAPPED) lpPipeInst, 
         (LPOVERLAPPED_COMPLETION_ROUTINE) CompletedWriteRoutine); 
// Disconnect if an error occurred. 
   if (! fWrite) 
// DisconnectAndClose(LPPIPEINST) 
// This routine is called when an error occurs or the client closes 
// its handle to the pipe. 
VOID DisconnectAndClose(LPPIPEINST lpPipeInst) 
// Disconnect the pipe instance. 
   if (! DisconnectNamedPipe(lpPipeInst->hPipeInst) ) 
      printf("DisconnectNamedPipe failed with %d.\n", GetLastError());
// Close the handle to the pipe instance. 
// Release the storage for the pipe instance. 
   if (lpPipeInst != NULL) 
// CreateAndConnectInstance(LPOVERLAPPED) 
// This function creates a pipe instance and connects to the client. 
// It returns TRUE if the connect operation is pending, and FALSE if 
// the connection has been completed. 
BOOL CreateAndConnectInstance(LPOVERLAPPED lpoOverlap) 
   LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe"); 
   hPipe = 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 
      PIPE_UNLIMITED_INSTANCES, // unlimited instances 
      BUFSIZE*sizeof(TCHAR),    // output buffer size 
      BUFSIZE*sizeof(TCHAR),    // input buffer size 
      PIPE_TIMEOUT,             // client time-out 
      NULL);                    // default security attributes
   if (hPipe == INVALID_HANDLE_VALUE) 
      printf("CreateNamedPipe failed with %d.\n", GetLastError()); 
      return 0;
// Call a subroutine to connect to the new client. 
   return ConnectToNewClient(hPipe, lpoOverlap); 

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; 
   // Client is already connected, so signal an event. 
         if (SetEvent(lpo->hEvent)) 
   // If an error occurs during the connect operation... 
         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);

Related topics

Named Pipe Client



© 2017 Microsoft