E D R , A S I H C RSS

Named Pipe

1. def

MSDN

A named pipe is a named, one-way or duplex pipe for communication between the pipe server and one or more pipe clients. All instances of a
named pipe share the same pipe name, but each instance has its own buffers and handles, and provides a separate conduit for client-server communication. The use of instances enables multiple pipe clients to use the same named pipe simultaneously.

Any process can access named pipes, subject to security checks, making named pipes an easy form of communication between related or unrelated processes. Named pipes can be used to provide communication between processes on the same computer or between processes on different computers across a network.

Any process can act as both a server and a client, making peer-to-peer communication possible. As used here, the term pipe server refers to a process that creates a named pipe, and the term pipe client refers to a process that connects to an instance of a named pipe.

Pipež€ ‘ ํ”„กœ„Šค„˜ ํ†ต‹ „ œ„ํ•ด งŒ“ค–ด„ ฒƒœกœ Named PipeŠ” ง ทธŒ€กœ ด„ด žˆŠ” ํŒŒดํ”„Š” ฒƒด‹ค. ดŠ” ‹คฅธ ปดํ“จํ„™€„ „คํŠธ›Œํฌ
ํ†ตํ•ด Server / Client ํ†ต‹ ด €Šฅํ•˜ฒŒ งŒ“ค–ด Š” —ญํ• „ ํ•œ‹ค.

2. using

Server
~cpp 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <windows.h> 
 
VOID InstanceThread(LPVOID); // “ฐ ˆ“œ ํ•จˆ˜
VOID GetAnswerToRequest(LPTSTR, LPTSTR, LPDWORD); // Šค ˆ“œ 
 
int xx = 0; 
 
DWORD main(VOID) 
{ 
   BOOL fConnected; 
   DWORD dwThreadId; 
   HANDLE hPipe, hThread; // “ฐ ˆ“œ ํ•ธ“ค
   LPTSTR lpszPipename = "\\.\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 the loop is repeated. 
 
   for (;;) 
   { 
       // “ฐž˜“œ ํ•จˆ˜ ƒ„ํ•œ‹ค.
      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 
          PIPE_TIMEOUT,             // client time-out 
          NULL);                    // no security attribute 

      if (hPipe == INVALID_HANDLE_VALUE) 
          MyErrExit("CreatePipe"); 
 
      // Wait for the client to connect; if it succeeds, // ํดด–ธํŠธ —ฐฒฐ„ ธฐ‹คฆฐ‹ค.
      // the function returns a nonzero value. If the function returns //  ‘†ด   ฒฝšฐ 0 •„‹Œ ฐ’ด ฆฌํ„˜ฉฐ 
      // zero, GetLastError returns ERROR_PIPE_CONNECTED. // งŒ•ฝ 0 ฐ’ด ฆฌํ„ด   ฒฝšฐ ERROR_PIPE_CONNECTED ฆฌํ„ดํ•œ‹ค.
 
      fConnected = ConnectNamedPipe(hPipe, NULL) ? 
         TRUE : (GetLastError() == ERROR_PIPE_CONNECTED); 
       // —ฐฒฐด ˜„œ fConnectedฐ’ด TRUE€ ˜—ˆœ€กœ 
      if (fConnected) 
      { 
      // Create a thread for this client. // —ฐฒฐœ ํดด–ธํŠธ œ„ํ•œ “ฐ ˆ“œ ƒ„‹œํ‚จ‹ค.
         hThread = CreateThread( 
            NULL,              // no security attribute 
            0,                 // default stack size 
            (LPTHREAD_START_ROUTINE) InstanceThread, // InstanceThread ƒ„‹œํ‚จ‹ค.
            (LPVOID) hPipe,    // thread parameter // “ฐ ˆ“œ Parameterกœ hPipe ํ•ธ“คฐ’ด “ค–ด„‹ค.
            0,                 // not suspended 
            &dwThreadId);      // returns thread ID 
       // “ฐ ˆ“œ€ ƒ„ด ˜ฉด hThread ฐ’ด NULL ดณ  ทธ ‡€ •Šœฉด —ด–ด †“€ Handleฐ’„ ‹ซ•„€‹ค.
         if (hThread == NULL) 
            MyErrExit("CreateThread"); 
         else
            CloseHandle(hThread); 
 
      } 
      else 
        // The client could not connect, so close the pipe. 
         CloseHandle(hPipe); 
   } 
   return 1; 
} 
 
VOID InstanceThread(LPVOID lpvParam) 
{ 
   CHAR chRequest[BUFSIZE]; // ˆ˜‹  „ํ
   CHAR chReply[BUFSIZE]; //  †ก‹  „ํ
   DWORD cbBytesRead, cbReplyBytes, cbWritten; 
   BOOL fSuccess; 
   HANDLE hPipe; 
 
// The thread's parameter is a handle to a pipe instance. 
 
   hPipe = (HANDLE) lpvParam; 
 
   while (1) 
   { 
   // Read client requests from the pipe. 
   // hPipe ํ•ธ“ค—„œ chRequst— BUFSIZEงŒํ ฝ–ด “ค—ฌ˜จ‹ค.
      fSuccess = ReadFile( 
         hPipe,        // handle to pipe 
         chRequest,    // buffer to receive data 
         BUFSIZE,      // size of buffer 
         &cbBytesRead, // number of bytes read 
         NULL);        // not overlapped I/O 

      if (! fSuccess || cbBytesRead == 0) 
         break; 
   // Request — Œ€ํ•œ Œ€‹ต„ chReply „ํ— „–ด€‹ค.
      GetAnswerToRequest(chRequest, chReply, &cbReplyBytes); 
   // chReply Œ€‹ตํ•œ‹ค.
   // Write the reply to the pipe. 
      fSuccess = WriteFile( 
         hPipe,        // handle to pipe 
         chReply,      // buffer to write from 
         cbReplyBytes, // number of bytes to write 
         &cbWritten,   // number of bytes written 
         NULL);        // not overlapped I/O 

      if (! fSuccess || cbReplyBytes != cbWritten) 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. 
// „ํ˜ ‚จ€ Data Flush ํ•ด€‹ค.
   FlushFileBuffers(hPipe); 
   DisconnectNamedPipe(hPipe); 
   CloseHandle(hPipe); 
} 
Client
~cpp 
#include <windows.h> 
 
DWORD main(int argc, char *argv[]) 
{ 
   HANDLE hPipe; 
   LPVOID lpvMessage; 
   CHAR chBuf[512]; 
   BOOL fSuccess; 
   DWORD cbRead, cbWritten, dwMode; 
   LPTSTR lpszPipename = "\\.\pipe\mynamedpipe"; 
 
// 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,           // no security attributes
         OPEN_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) 
         MyErrExit("Could not open pipe"); 
 
      // All pipe instances are busy, so wait for 20 seconds. 
 
      if (! WaitNamedPipe(lpszPipename, 20000) ) 
         MyErrExit("Could not open pipe"); 
   } // ํŒŒ„ —ดณ  Pipe „œ„—  ‘†ํ•˜ธฐ  „Œ€ Œ€ธฐ ƒํƒœกœ งŒ“ค–ด‘”‹ค.
 
// The pipe connected; change to message-read mode. 
// ํŒŒดํ”„€ —ฐฒฐด ˜ฉด ํŒŒดํ”„ ฝธฐšฉœกœ ฐ”‹ค.
// —ฌธฐ„œ ž  PIPE_READMODE_MESSAGEŠ” ฝธฐšฉดณ  ‚˜™€žˆ€งŒ MSDN—Š” ด ชจ“œ€ ƒˆกœšด ชจ“œกœ
// ฝธฐ™€ “ฐธฐ ชจ‘ €Šฅํ•œ ชจ“œณ  ‚˜™€ žˆ‹ค. 
// DefaultŠ” PIPE_READMODE_DATA ดณ  PIPE_READMODE_MESSAGE€ ‹คํŒจํ•  ฒฝšฐ defaultกœ  •ํ•ด„‹ค.
   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) 
      MyErrExit("SetNamedPipeHandleState"); 
 
// Send a message to the pipe server. 
// ํŒŒดํ”„กœ ฉ”„€ ณด‚ธ‹ค. 
   lpvMessage = (argc > 1) ? argv[1] : "default message"; 
 
   fSuccess = WriteFile( 
      hPipe,                  // pipe handle 
      lpvMessage,             // message 
      strlen(lpvMessage) + 1, // message length 
      &cbWritten,             // bytes written 
      NULL);                  // not overlapped 
   if (! fSuccess) 
      MyErrExit("WriteFile"); 
// ํŒŒดํ”„กœ €„ฉ”„€ ฝ–ด˜จ‹ค.
   do 
   { 
   // Read from the pipe. 
   // ํŒŒดํ”„กœ€„ฝธฐ
      fSuccess = ReadFile( 
         hPipe,    // pipe handle 
         chBuf,    // buffer to receive reply 
         512,      // size of buffer 
         &cbRead,  // number of bytes read 
         NULL);    // not overlapped 
 
      if (! fSuccess && GetLastError() != ERROR_MORE_DATA) 
         break; 
 
      // Reply from the pipe is written to STDOUT. 
      // STDOUTกœ Reply “ฐธฐ
      if (! WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), 
         chBuf, cbRead, &cbWritten, NULL)) 
      {
         break; 
      }
 
   } while (! fSuccess);  // repeat loop if ERROR_MORE_DATA 
 
   CloseHandle(hPipe); 
 
   return 0; 
} 

3. example

‹ค œ ˜ˆ œ ํŒŒ NamedPipe ดšฉํ•œ Chat Program http://www.zeropage.org/pds/20031103027/NamedPipe.zip

4. function

~cpp CallNamedPipe ฉ”„€ ํ˜•‹˜ Named Pipe Connectํ•  •Œ “ฐดŠ” ํ•จˆ˜
~cpp ConnectNamedPipe Named Pipe — Connectํ•  •Œ “ฐดŠ” ํ•จˆ˜
~cpp CreateNamedPipe Named Pipe ƒ„ํ•œ‹ค.
~cpp CreatePipe anonymous Pipe ƒ„ํ•œ‹ค.
~cpp DisconnectNamedPipe Named Pipe Server— —ฐฒฐ„ ŠŠ”‹ค.
~cpp GetNamedPipeHandleState ํŠ • Named Pipe— Œ€ํ•œ  •ณด –ปŠ”‹ค.
~cpp GetNamedPipeInfo ํŠ • Named Pipe— Œ€ํ•œ  •ณด –ปŠ”‹ค.
~cpp PeekNamedPipe anonymous / Named Pipeกœ€„ฐ Data –ป–ด˜จ‹ค.
~cpp SetNamedPipeHandleState ~cpp NamedPipe˜ ~cpp ReadMode , ~cpp Block ƒํƒœ Setํ•œ‹ค.
~cpp TransactNamedPipe Single Operationœกœ Read & Write ํ•  ˆ˜ žˆŠ” function ด‹ค.
~cpp WaitNamedPipe Connection ƒํƒœ—„œ Time-Out OR  •ํ•ด€ ‹œ„ด ˜ธฐ  „Œ€ Waitํ•œ‹ค.

contributor fnwinter

Valid XHTML 1.0! Valid CSS! powered by MoniWiki
last modified 2021-02-07 05:23:50
Processing time 0.0223 sec