命名管道-MSDN例子

服务器：

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

 #define BUFSIZE 512

 DWORD WINAPI InstanceThread(LPVOID);
 VOID GetAnswerToRequest(LPTSTR, LPTSTR, LPDWORD); 

 int _tmain(VOID)
 {
    BOOL   fConnected = FALSE;
    DWORD  dwThreadId = ;
    HANDLE hPipe = INVALID_HANDLE_VALUE, hThread = NULL;
    LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe"); 

 // The main loop creates an instance of the named pipe and
 // then waits for a client to connect to it. When the client
 // connects, a thread is created to handle communications
 // with that client, and this loop is free to wait for the
 // next client connect request. It is an infinite loop.

    for (;;)
    {
       _tprintf( TEXT("\nPipe Server: Main thread awaiting client connection on %s\n"), lpszPipename);
       hPipe = CreateNamedPipe(
           lpszPipename,             // pipe name
           PIPE_ACCESS_DUPLEX,       // read/write access
           PIPE_TYPE_MESSAGE |       // message type pipe
           PIPE_READMODE_MESSAGE |   // message-read mode
           PIPE_WAIT,                // blocking mode
           PIPE_UNLIMITED_INSTANCES, // max. instances
           BUFSIZE,                  // output buffer size
           BUFSIZE,                  // input buffer size
           ,                        // client time-out
           NULL);                    // default security attribute 

       if (hPipe == INVALID_HANDLE_VALUE)
       {
           _tprintf(TEXT("CreateNamedPipe failed, GLE=%d.\n"), GetLastError());
           return -;
       }

       // Wait for the client to connect; if it succeeds,
       // the function returns a nonzero value. If the function
       // returns zero, GetLastError returns ERROR_PIPE_CONNECTED. 

         //等待客户端接入（目前为阻塞模式）
       fConnected = ConnectNamedPipe(hPipe, NULL) ?
          TRUE : (GetLastError() == ERROR_PIPE_CONNECTED); 

       if (fConnected)
       {
          printf("Client connected, creating a processing thread.\n"); 

          // Create a thread for this client.
          hThread = CreateThread(
             NULL,              // no security attribute
             ,                 // default stack size
             InstanceThread,    // thread proc
             (LPVOID) hPipe,    // thread parameter
             ,                 // not suspended
             &dwThreadId);      // returns thread ID 

          if (hThread == NULL)
          {
             _tprintf(TEXT("CreateThread failed, GLE=%d.\n"), GetLastError());
             return -;
          }
          else CloseHandle(hThread);
        }
       else
         // The client could not connect, so close the pipe.
          CloseHandle(hPipe); 

    } 

    return ;
 } 

 DWORD WINAPI InstanceThread(LPVOID lpvParam)
 // This routine is a thread processing function to read from and reply to a client
 // via the open pipe connection passed from the main loop. Note this allows
 // the main loop to continue executing, potentially creating more threads of
 // of this procedure to run concurrently, depending on the number of incoming
 // client connections.
 {
    HANDLE hHeap      = GetProcessHeap();
    TCHAR* pchRequest = (TCHAR*)HeapAlloc(hHeap, , BUFSIZE*sizeof(TCHAR));
    TCHAR* pchReply   = (TCHAR*)HeapAlloc(hHeap, , BUFSIZE*sizeof(TCHAR));

    DWORD cbBytesRead = , cbReplyBytes = , cbWritten = ;
    BOOL fSuccess = FALSE;
    HANDLE hPipe  = NULL;

    // Do some extra error checking since the app will keep running even if this
    // thread fails.

    if (lpvParam == NULL)
    {
        printf( "\nERROR - Pipe Server Failure:\n");
        printf( "   InstanceThread got an unexpected NULL value in lpvParam.\n");
        printf( "   InstanceThread exitting.\n");
        if (pchReply != NULL) HeapFree(hHeap, , pchReply);
        if (pchRequest != NULL) HeapFree(hHeap, , pchRequest);
        return (DWORD)-;
    }

    if (pchRequest == NULL)
    {
        printf( "\nERROR - Pipe Server Failure:\n");
        printf( "   InstanceThread got an unexpected NULL heap allocation.\n");
        printf( "   InstanceThread exitting.\n");
        if (pchReply != NULL) HeapFree(hHeap, , pchReply);
        return (DWORD)-;
    }

    if (pchReply == NULL)
    {
        printf( "\nERROR - Pipe Server Failure:\n");
        printf( "   InstanceThread got an unexpected NULL heap allocation.\n");
        printf( "   InstanceThread exitting.\n");
        if (pchRequest != NULL) HeapFree(hHeap, , pchRequest);
        return (DWORD)-;
    }

    // Print verbose messages. In production code, this should be for debugging only.
    printf("InstanceThread created, receiving and processing messages.\n");

 // The thread's parameter is a handle to a pipe object instance. 

    hPipe = (HANDLE) lpvParam; 

 // Loop until done reading
    while ()
    {
    // Read client requests from the pipe. This simplistic code only allows messages
    // up to BUFSIZE characters in length.
       fSuccess = ReadFile(
          hPipe,        // handle to pipe
          pchRequest,    // buffer to receive data
          BUFSIZE*sizeof(TCHAR), // size of buffer
          &cbBytesRead, // number of bytes read
          NULL);        // not overlapped I/O 

       if (!fSuccess || cbBytesRead == )
       {
           if (GetLastError() == ERROR_BROKEN_PIPE)
           {
               _tprintf(TEXT("InstanceThread: client disconnected.\n"), GetLastError());
           }
           else
           {
               _tprintf(TEXT("InstanceThread ReadFile failed, GLE=%d.\n"), GetLastError());
           }
           break;
       }

    // Process the incoming message.
       GetAnswerToRequest(pchRequest, pchReply, &cbReplyBytes); 

    // Write the reply to the pipe.
       fSuccess = WriteFile(
          hPipe,        // handle to pipe
          pchReply,     // buffer to write from
          cbReplyBytes, // number of bytes to write
          &cbWritten,   // number of bytes written
          NULL);        // not overlapped I/O 

       if (!fSuccess || cbReplyBytes != cbWritten)
       {
           _tprintf(TEXT("InstanceThread WriteFile failed, GLE=%d.\n"), GetLastError());
           break;
       }
   }

 // Flush the pipe to allow the client to read the pipe's contents
 // before disconnecting. Then disconnect the pipe, and close the
 // handle to this pipe instance. 

    FlushFileBuffers(hPipe);
    DisconnectNamedPipe(hPipe);
    CloseHandle(hPipe); 

    HeapFree(hHeap, , pchRequest);
    HeapFree(hHeap, , pchReply);

    printf("InstanceThread exitting.\n");
    return ;
 }

 VOID GetAnswerToRequest( LPTSTR pchRequest,
                          LPTSTR pchReply,
                          LPDWORD pchBytes )
 // This routine is a simple function to print the client request to the console
 // and populate the reply buffer with a default data string. This is where you
 // would put the actual client request processing code that runs in the context
 // of an instance thread. Keep in mind the main thread will continue to wait for
 // and receive other client connections while the instance thread is working.
 {
     _tprintf( TEXT("Client Request String:\"%S\"\n"), pchRequest );//这里注意大小写的%S，见上一篇随笔

     // Check the outgoing message to make sure it's not too long for the buffer.
     if (FAILED(StringCchCopy( pchReply, BUFSIZE, TEXT("default answer from server") )))
     {
         *pchBytes = ;
         pchReply[] = ;
         printf("StringCchCopy failed, no outgoing message.\n");
         return;
     }
     *pchBytes = (lstrlen(pchReply)+)*sizeof(TCHAR);
 }

客户端：

// client.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>

#define BUFSIZE 512

int _tmain(int argc, TCHAR *argv[])
{
   HANDLE hPipe;
   LPTSTR lpvMessage=TEXT("Default message from client.");
   TCHAR  chBuf[BUFSIZE];
   BOOL   fSuccess = FALSE;
   DWORD  cbRead, cbToWrite, cbWritten, dwMode;
   LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe"); 

   if( argc >  )
      lpvMessage = argv[];

// Try to open a named pipe; wait for it, if necessary. 

   while ()
   {
      hPipe = CreateFile(
         lpszPipename,   // pipe name
         GENERIC_READ |  // read and write access
         GENERIC_WRITE,
         ,              // no sharing
         NULL,           // default security attributes
         OPEN_EXISTING,  // opens existing pipe
         ,              // default attributes
         NULL);          // no template file 

   // Break if the pipe handle is valid. 

      if (hPipe != INVALID_HANDLE_VALUE)
         break; 

      // Exit if an error other than ERROR_PIPE_BUSY occurs. 

      if (GetLastError() != ERROR_PIPE_BUSY)
      {
         _tprintf( TEXT("Could not open pipe. GLE=%d\n"), GetLastError() );
         return -;
      }

      // All pipe instances are busy, so wait for 20 seconds. 

      if ( ! WaitNamedPipe(lpszPipename, ))
      {
         printf("Could not open pipe: 20 second wait timed out.");
         return -;
      }
   } 

// The pipe connected; change to message-read mode. 

   dwMode = PIPE_READMODE_MESSAGE;
   fSuccess = SetNamedPipeHandleState(
      hPipe,    // pipe handle
      &dwMode,  // new pipe mode
      NULL,     // don't set maximum bytes
      NULL);    // don't set maximum time
   if ( ! fSuccess)
   {
      _tprintf( TEXT("SetNamedPipeHandleState failed. GLE=%d\n"), GetLastError() );
      return -;
   }

// Send a message to the pipe server. 

   cbToWrite = (lstrlen(lpvMessage)+)*sizeof(TCHAR);
   _tprintf( TEXT("Sending %d byte message: \"%s\"\n"), cbToWrite, lpvMessage); 
//这里的写和读可以用TransactNamedPipe函数来代替，性能更好
   fSuccess = WriteFile(
      hPipe,                  // pipe handle
      lpvMessage,             // message
      cbToWrite,              // message length
      &cbWritten,             // bytes written
      NULL);                  // not overlapped 

   if ( ! fSuccess)
   {
      _tprintf( TEXT("WriteFile to pipe failed. GLE=%d\n"), GetLastError() );
      return -;
   }

   printf("\nMessage sent to server, receiving reply as follows:\n");

   do
   {
   // Read from the pipe. 

      fSuccess = ReadFile(
         hPipe,    // pipe handle
         chBuf,    // buffer to receive reply
         BUFSIZE*sizeof(TCHAR),  // size of buffer
         &cbRead,  // number of bytes read
         NULL);    // not overlapped 

      if ( ! fSuccess && GetLastError() != ERROR_MORE_DATA )
         break; 

      _tprintf( TEXT("\"%S\"\n"), chBuf );
   } while ( ! fSuccess);  // repeat loop if ERROR_MORE_DATA 

   if ( ! fSuccess)
   {
      _tprintf( TEXT("ReadFile from pipe failed. GLE=%d\n"), GetLastError() );
      return -;
   }

   printf("\n<End of message, press ENTER to terminate connection and exit>");
   _getch();

   CloseHandle(hPipe); 

   return ;
}