1 #include "stdafx.h"
  2 #include <windows.h>
  3 #include <stdio.h>
  4 #include <tchar.h>
  5 #include <strsafe.h>
  6
  7 #define BUFSIZE 512
  8
  9 DWORD WINAPI InstanceThread(LPVOID);
 10 VOID GetAnswerToRequest(LPTSTR, LPTSTR, LPDWORD);
 11
 12 int _tmain(VOID)
 13 {
 14    BOOL   fConnected = FALSE;
 15    DWORD  dwThreadId = 0;
 16    HANDLE hPipe = INVALID_HANDLE_VALUE, hThread = NULL;
 17    LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\mynamedpipe");
 18
 19 // The main loop creates an instance of the named pipe and
 20 // then waits for a client to connect to it. When the client
 21 // connects, a thread is created to handle communications
 22 // with that client, and this loop is free to wait for the
 23 // next client connect request. It is an infinite loop.
 24
 25    for (;;)
 26    {
 27       _tprintf( TEXT("\nPipe Server: Main thread awaiting client connection on %s\n"), lpszPipename);
 28       hPipe = CreateNamedPipe(
 29           lpszPipename,             // pipe name
 30           PIPE_ACCESS_DUPLEX,       // read/write access
 31           PIPE_TYPE_MESSAGE |       // message type pipe
 32           PIPE_READMODE_MESSAGE |   // message-read mode
 33           PIPE_WAIT,                // blocking mode
 34           PIPE_UNLIMITED_INSTANCES, // max. instances
 35           BUFSIZE,                  // output buffer size
 36           BUFSIZE,                  // input buffer size
 37           0,                        // client time-out
 38           NULL);                    // default security attribute
 39
 40       if (hPipe == INVALID_HANDLE_VALUE)
 41       {
 42           _tprintf(TEXT("CreateNamedPipe failed, GLE=%d.\n"), GetLastError());
 43           return -1;
 44       }
 45
 46       // Wait for the client to connect; if it succeeds,
 47       // the function returns a nonzero value. If the function
 48       // returns zero, GetLastError returns ERROR_PIPE_CONNECTED.
 49
 50         //等待客户端接入（目前为阻塞模式）
 51       fConnected = ConnectNamedPipe(hPipe, NULL) ?
 52          TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);
 53
 54       if (fConnected)
 55       {
 56          printf("Client connected, creating a processing thread.\n");
 57
 58          // Create a thread for this client.
 59          hThread = CreateThread(
 60             NULL,              // no security attribute
 61             0,                 // default stack size
 62             InstanceThread,    // thread proc
 63             (LPVOID) hPipe,    // thread parameter
 64             0,                 // not suspended
 65             &dwThreadId);      // returns thread ID
 66
 67          if (hThread == NULL)
 68          {
 69             _tprintf(TEXT("CreateThread failed, GLE=%d.\n"), GetLastError());
 70             return -1;
 71          }
 72          else CloseHandle(hThread);
 73        }
 74       else
 75         // The client could not connect, so close the pipe.
 76          CloseHandle(hPipe);
 77
 78    }
 79
 80    return 0;
 81 }
 82
 83 DWORD WINAPI InstanceThread(LPVOID lpvParam)
 84 // This routine is a thread processing function to read from and reply to a client
 85 // via the open pipe connection passed from the main loop. Note this allows
 86 // the main loop to continue executing, potentially creating more threads of
 87 // of this procedure to run concurrently, depending on the number of incoming
 88 // client connections.
 89 {
 90    HANDLE hHeap      = GetProcessHeap();
 91    TCHAR* pchRequest = (TCHAR*)HeapAlloc(hHeap, 0, BUFSIZE*sizeof(TCHAR));
 92    TCHAR* pchReply   = (TCHAR*)HeapAlloc(hHeap, 0, BUFSIZE*sizeof(TCHAR));
 93
 94    DWORD cbBytesRead = 0, cbReplyBytes = 0, cbWritten = 0;
 95    BOOL fSuccess = FALSE;
 96    HANDLE hPipe  = NULL;
 97
 98    // Do some extra error checking since the app will keep running even if this
 99    // thread fails.
100
101    if (lpvParam == NULL)
102    {
103        printf( "\nERROR - Pipe Server Failure:\n");
104        printf( "   InstanceThread got an unexpected NULL value in lpvParam.\n");
105        printf( "   InstanceThread exitting.\n");
106        if (pchReply != NULL) HeapFree(hHeap, 0, pchReply);
107        if (pchRequest != NULL) HeapFree(hHeap, 0, pchRequest);
108        return (DWORD)-1;
109    }
110
111    if (pchRequest == NULL)
112    {
113        printf( "\nERROR - Pipe Server Failure:\n");
114        printf( "   InstanceThread got an unexpected NULL heap allocation.\n");
115        printf( "   InstanceThread exitting.\n");
116        if (pchReply != NULL) HeapFree(hHeap, 0, pchReply);
117        return (DWORD)-1;
118    }
119
120    if (pchReply == NULL)
121    {
122        printf( "\nERROR - Pipe Server Failure:\n");
123        printf( "   InstanceThread got an unexpected NULL heap allocation.\n");
124        printf( "   InstanceThread exitting.\n");
125        if (pchRequest != NULL) HeapFree(hHeap, 0, pchRequest);
126        return (DWORD)-1;
127    }
128
129    // Print verbose messages. In production code, this should be for debugging only.
130    printf("InstanceThread created, receiving and processing messages.\n");
131
132 // The thread's parameter is a handle to a pipe object instance.
133
134    hPipe = (HANDLE) lpvParam;
135
136 // Loop until done reading
137    while (1)
138    {
139    // Read client requests from the pipe. This simplistic code only allows messages
140    // up to BUFSIZE characters in length.
141       fSuccess = ReadFile(
142          hPipe,        // handle to pipe
143          pchRequest,    // buffer to receive data
144          BUFSIZE*sizeof(TCHAR), // size of buffer
145          &cbBytesRead, // number of bytes read
146          NULL);        // not overlapped I/O
147
148       if (!fSuccess || cbBytesRead == 0)
149       {
150           if (GetLastError() == ERROR_BROKEN_PIPE)
151           {
152               _tprintf(TEXT("InstanceThread: client disconnected.\n"), GetLastError());
153           }
154           else
155           {
156               _tprintf(TEXT("InstanceThread ReadFile failed, GLE=%d.\n"), GetLastError());
157           }
158           break;
159       }
160
161    // Process the incoming message.
162       GetAnswerToRequest(pchRequest, pchReply, &cbReplyBytes);
163
164    // Write the reply to the pipe.
165       fSuccess = WriteFile(
166          hPipe,        // handle to pipe
167          pchReply,     // buffer to write from
168          cbReplyBytes, // number of bytes to write
169          &cbWritten,   // number of bytes written
170          NULL);        // not overlapped I/O
171
172       if (!fSuccess || cbReplyBytes != cbWritten)
173       {
174           _tprintf(TEXT("InstanceThread WriteFile failed, GLE=%d.\n"), GetLastError());
175           break;
176       }
177   }
178
179 // Flush the pipe to allow the client to read the pipe's contents
180 // before disconnecting. Then disconnect the pipe, and close the
181 // handle to this pipe instance.
182
183    FlushFileBuffers(hPipe);
184    DisconnectNamedPipe(hPipe);
185    CloseHandle(hPipe);
186
187    HeapFree(hHeap, 0, pchRequest);
188    HeapFree(hHeap, 0, pchReply);
189
190    printf("InstanceThread exitting.\n");
191    return 1;
192 }
193
194 VOID GetAnswerToRequest( LPTSTR pchRequest,
195                          LPTSTR pchReply,
196                          LPDWORD pchBytes )
197 // This routine is a simple function to print the client request to the console
198 // and populate the reply buffer with a default data string. This is where you
199 // would put the actual client request processing code that runs in the context
200 // of an instance thread. Keep in mind the main thread will continue to wait for
201 // and receive other client connections while the instance thread is working.
202 {
203     _tprintf( TEXT("Client Request String:\"%S\"\n"), pchRequest );//这里注意大小写的%S，见上一篇随笔
204
205     // Check the outgoing message to make sure it's not too long for the buffer.
206     if (FAILED(StringCchCopy( pchReply, BUFSIZE, TEXT("default answer from server") )))
207     {
208         *pchBytes = 0;
209         pchReply[0] = 0;
210         printf("StringCchCopy failed, no outgoing message.\n");
211         return;
212     }
213     *pchBytes = (lstrlen(pchReply)+1)*sizeof(TCHAR);
214 }

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

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>#define BUFSIZE 512int _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 > 1 )lpvMessage = argv[1];// Try to open a named pipe; wait for it, if necessary. while (1) { hPipe = CreateFile( lpszPipename,   // pipe name GENERIC_READ |  // read and write access
         GENERIC_WRITE, 0,              // no sharing NULL,           // default security attributesOPEN_EXISTING,  // opens existing pipe 0,              // 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 -1;}// All pipe instances are busy, so wait for 20 seconds. if ( ! WaitNamedPipe(lpszPipename, 20000)) { printf("Could not open pipe: 20 second wait timed out."); return -1;} } // 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 -1;}// Send a message to the pipe server.
 cbToWrite = (lstrlen(lpvMessage)+1)*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 -1;}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 -1;}printf("\n<End of message, press ENTER to terminate connection and exit>");_getch();CloseHandle(hPipe); return 0;
}