Go Premium for a chance to win a PS4. Enter to Win

x
  • Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 285
  • Last Modified:

Using pipes in WinNt for proccess comunication

Could anybody send me an example of
using pipes or anything else for interproccess communication.

Thanx
0
Yulia
Asked:
Yulia
1 Solution
 
ufolk123Commented:
Server Part


#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
      // zero, GetLastError returns ERROR_PIPE_CONNECTED.
 
      fConnected = ConnectNamedPipe(hPipe, NULL) ?
         TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);
 
      if (fConnected)
      {
      // Create a thread for this client.
         hThread = CreateThread(
            NULL,              // no security attribute
            0,                 // default stack size
            (LPTHREAD_START_ROUTINE) InstanceThread,
            (LPVOID) hPipe,    // thread parameter
            0,                 // not suspended
            &dwThreadId);      // returns thread ID

         if (hThread == NULL)
            MyErrExit("CreateThread");
 
      }
      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.
      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;
      GetAnswerToRequest(chRequest, chReply, &cbReplyBytes);
 
   // 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.
 
   FlushFileBuffers(hPipe);
   DisconnectNamedPipe(hPipe);
   CloseHandle(hPipe);
}

Client :
#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");
   }
 
// 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)
      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.
 
      if (! WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),
         chBuf, cbRead, &cbWritten, NULL))
      {
         break;
      }
 
   } while (! fSuccess);  // repeat loop if ERROR_MORE_DATA
 
   CloseHandle(hPipe);
 
   return 0;
}

0

Featured Post

Industry Leaders: We Want Your Opinion!

We value your feedback.

Take our survey and automatically be enter to win anyone of the following:
Yeti Cooler, Amazon eGift Card, and Movie eGift Card!

Tackle projects and never again get stuck behind a technical roadblock.
Join Now