
/******************************************************************************\
*       This is a part of the Microsoft Source Code Samples. 
*       Copyright (C) 1993-1996 Microsoft Corporation.
*       All rights reserved. 
*       This source code is only intended as a supplement to 
*       Microsoft Development Tools and/or WinHelp documentation.
*       See these sources for detailed information regarding the 
*       Microsoft samples programs.
\******************************************************************************/

/*************************************************************************\
*  PROGRAM: client32.c
*
*  PURPOSE:
*
*     To demonstrate the use of named pipes and the overlapped structure.
*     This code serves as the client side of the named pipe instances.
*     For more details on an overview of this codes designs or use, see
*     the README file.  For details on the implementation, see the comments
*     in this code.
*
*
\*************************************************************************/

#define  STRICT
#include <windows.h>
#include "client32.h"

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

HANDLE hInst;
HWND   hWndClient;

CHAR ShrName[LINE_LEN];                 // Global: net share name.
CHAR ClntName[NAME_SIZE];               // Global: user or pipe client name.
CHAR lpBuffer[255];                     // Global: buffer for string resources                                                 

/*************************************************************************\
*
*  FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
*
*  PURPOSE: Launches the Client's dialog box.
*
*  COMMENTS:
*
\*************************************************************************/

int APIENTRY WinMain (HINSTANCE hInstance,
                      HINSTANCE hPrevInstance,
                      LPSTR     lpCmdLine,
                      int       nCmdShow)


{
  DWORD retCode;

  UNREFERENCED_PARAMETER( nCmdShow );
  UNREFERENCED_PARAMETER( lpCmdLine );
  UNREFERENCED_PARAMETER( hPrevInstance );

  hInst   = hInstance;
  retCode = DialogBox ((HANDLE)hInst, (LPCTSTR)"ClientDialog",
                       NULL, (DLGPROC)ClientDlgProc);
  return  (retCode);

}


/*************************************************************************\
*
*  PROCEDURE: InitDlgProc (HWND hDlg, WORD wMsg, LONG wParam, LONG lParam)
*
*  PURPOSE:  This dialog box prompts the user for a net share name and
*            a client or user name.  These values are placed into global
*            strings ShrName and ClntName.
*
*  CALLED BY:
*
*    ClientDlgProc();
*
\*************************************************************************/

LONG CALLBACK InitDlgProc (HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
  {

  UNREFERENCED_PARAMETER(lParam);

  switch (wMsg)
    {
    case WM_INITDIALOG:
      PostMessage (GetDlgItem (hDlg, IDD_SVREDIT),
                   EM_LIMITTEXT, LINE_LEN, 0);

      PostMessage (GetDlgItem (hDlg, IDD_CLNTEDIT),
                   EM_LIMITTEXT, NAME_SIZE, 0);
    case WM_COMMAND:
      switch (LOWORD(wParam))
        {                            // When the user clicks okay, get the
        case IDB_INITOK:             // share name and user name from the
                                     // edit fields.
          GetWindowText (GetDlgItem (hDlg, IDD_SVREDIT), ShrName, LINE_LEN);
          GetWindowText (GetDlgItem (hDlg, IDD_CLNTEDIT), ClntName, NAME_SIZE);
          EndDialog(hDlg, 0);
          return (0);

        default:
          return (0);
        }
    default:
      return (0);
    }
  return (0);
  }


/*************************************************************************\
*
*  PROCEDURE: ClientDlgProc (HWND hDlg, WORD wMsg, LONG wParam, LONG lParam)
*
*  PURPOSE:  This procedure services the dialog box that serves as an interface
*            to the named pipe server instance.  The larger edit field is used
*            to read messages from the server instance.  The smaller edit field
*            is used to type messages to the server instance.  This procedure
*            is responsible for connecting to the named pipe, creating a
*            seperate thread to read the pipe, and sending to the pipe.
*
*  CALLED BY:
*
*    WinMain();
*
*  CALLS TO:
*
*    InitDlgProc();
*    ReadPipe();
*
\**************************************************************************/

LONG CALLBACK ClientDlgProc (HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
  {
  DWORD  retCode;                      // Return code.
  CHAR   errorBuf[LINE_LEN] = "";      // Error message buffer.
  CHAR   outBuf[OUT_BUF_SIZE]  = "";   // Buffer trapping message to send.
  CHAR   sendBuf[OUT_BUF_SIZE] = "";   // Buffer used to modify message.
  DWORD  bytesWritten;                 // Used for WriteFile().
  DWORD  threadID;                     // Used for CreateThread().
  CHAR   fileName[LINE_LEN+NAME_SIZE+2]; // Used to modify pipe/file name.
  DWORD  lastError;                    // Used to get returns from GetLastError.

  static HANDLE hPipe;                 // File or Pipe handle.
  static OVERLAPPED OverLapWrt;        // Overlapped structure
  static HANDLE     hEventWrt;         // Event handle for overlapped writes.

  UNREFERENCED_PARAMETER( lParam );

  hWndClient = hDlg;

  switch (wMsg)
    {

    case WM_COMMAND:
      switch (LOWORD(wParam))
        {

        // When the user presses Send: capture the string from the edit
        // field, prepend it with the user name, and overlap write it to
        // the server instance of the named pipe.

        case IDB_SEND:                 // Get the text from the edit field.
          GetWindowText (GetDlgItem(hDlg,IDD_EDITWRITE),
                         outBuf, PLEASE_WRITE);

                                       // Prepend it with the user name, and
                                       // terminate it with a new line
                                       // character.

          wsprintf (sendBuf, "%s%s %s\n", ClntName, ":", outBuf);

                                       // Do the overlapped write.
          retCode = WriteFile (hPipe, sendBuf, PLEASE_WRITE,
                     &bytesWritten, &OverLapWrt);
          if (!retCode)
            {
            lastError = GetLastError();
                                       // If Error = IO_PENDING, wait til
                                       // the event signals success.
            if (lastError == ERROR_IO_PENDING)
              WaitForSingleObject (hEventWrt, (DWORD)-1);
            }

          return (0);

        default:
          return (0);

        }


    case WM_INITCLIENT:

       // On initialization, use the Init dialog box prompt the user for a
       // net share name and a client or user name.  A share name of "."
       // means that the named pipe is local to this machine.  Named pipe
       // names should have the form '\\.\PIPE\<pipename>', for a local machine
       // or '\\<machinename>\PIPE\<pipename>' for remote machines.
       // Once the share name is captured from the Init dialog box,
       // convert the name into the proper form; then do a CreateFile()
       // to connect to the pipe.  Handle any error from the CreateFile().
       // Then write the user name to the server instance of the named
       // pipe.  Finally, create a thread to read the named pipe.

                                       // Launch Init dialog box to capture
                                       // share name and user name.
       DialogBox ((HANDLE)GetModuleHandle(NULL),
                  (LPCTSTR)"InitDialog",
                  (HWND)hDlg,
                  (DLGPROC)InitDlgProc);

                                       // Put captured user name in window
                                       // caption.
       SetWindowText (hDlg, ClntName);

                                       // Construct file/pipe name.
       wsprintf (fileName, "%s%s%s", "\\\\", ShrName, "\\PIPE\\test");

                                       // Do CreateFile() to connect to the
                                       // named pipe.
       hPipe = CreateFile (fileName,              // Pipe name.
                           GENERIC_WRITE          // Generic access, read/write.
                           | GENERIC_READ,
                           FILE_SHARE_READ        // Share both read and write.
                           | FILE_SHARE_WRITE ,
                           NULL,                  // No security.
                           OPEN_EXISTING,         // Fail if not existing.
                           FILE_FLAG_OVERLAPPED,  // Use overlap.
                           NULL);                 // No template.

                                       // Do some error checking.
       if ((DWORD)hPipe == 0xFFFFFFFF)
         {
         retCode = GetLastError();

                                       // This error means pipe wasn't found.
         if ((retCode == ERROR_SEEK_ON_DEVICE) ||
             (retCode == ERROR_FILE_NOT_FOUND)) {
             LoadString(hInst, IDS_CANTFINDPIPE, lpBuffer, sizeof(lpBuffer));
             MessageBox (hDlg, lpBuffer, "", MB_OK);
         }
         else
           {                           // Flagging unknown errors.
             LoadString(hInst, IDS_GENERALERROR, lpBuffer, sizeof(lpBuffer));
             wsprintf (errorBuf, lpBuffer, retCode);
             LoadString(hInst, IDS_DEBUGTITLE, lpBuffer, sizeof(lpBuffer));
             MessageBox (hDlg, errorBuf, lpBuffer,
                       MB_ICONINFORMATION | MB_OK | MB_APPLMODAL);
           }

         EndDialog (hDlg, 0);          // Kill app if pipe didn't connect.
         };

                                       // Create and init overlapped structure
                                       // for writes.
       hEventWrt = CreateEvent (NULL, TRUE, FALSE, NULL);
       OverLapWrt.hEvent = hEventWrt;

                                       // Write the client name to server.
       retCode = WriteFile (hPipe, ClntName, PLEASE_WRITE,
                            &bytesWritten, &OverLapWrt);

       if (!retCode)                   // Wait on overlapped if need be.
         {
         lastError = GetLastError();
         if (lastError == ERROR_IO_PENDING)
           WaitForSingleObject (hEventWrt, (DWORD)-1);
         }
                                       // Create a thread to read the pipe.
       CreateThread (NULL,
                     0,
                     (LPTHREAD_START_ROUTINE)ReadPipe,
                     (LPVOID)&hPipe,
                     0,
                     &threadID);
       return (0);



     case WM_INITDIALOG:
                                       // PostMessage() give time for the
                                       // dialog box to be created.
       PostMessage (hDlg, WM_INITCLIENT, 0, 0);
       return (0);



     case WM_GO_AWAY:
       CloseHandle (hPipe);
       CloseHandle (hEventWrt);
       EndDialog (hDlg, TRUE);
       return TRUE;



     case WM_SYSCOMMAND:
       if (wParam == SC_CLOSE)
         {
         CloseHandle (hPipe);
         CloseHandle (hEventWrt);
         EndDialog(hDlg, TRUE);
         return TRUE;
         }
       break;
     }
    return (FALSE);

  }

/*************************************************************************\
*
*  PROCEDURE: ReadPipe (HANDLE *hRead)
*
*  PURPOSE:  This is a thread function which loops and reads the named pipe.
*
*  CALLED BY:
*
*    ClientDlgProc.
*
*
\*************************************************************************/

VOID ReadPipe (HANDLE *hPipe)
  {
    CHAR       inBuf[IN_BUF_SIZE] = "";// Input buffer.
    DWORD      bytesRead;              // Used for ReadFile()
    DWORD      retCode;                // Used to trap return codes.
    CHAR       Buf[80];                // Message box buffer.
    DWORD      lastError;              // Used to trap returns from GetLastError.

    HANDLE     hEventRd;               // Event handle for overlapped reads.
    OVERLAPPED OverLapRd;              // Overlapped structure.
    DWORD      bytesTrans;             // Bytes transferred in read.

                                       // Create and init overlap structure.
    hEventRd = CreateEvent (NULL, TRUE, FALSE, NULL);
    memset (&OverLapRd, 0, sizeof(OVERLAPPED));
    OverLapRd.hEvent = hEventRd;

    // Loop, reading the named pipe until it is broken.  The ReadFile() uses
    // an overlapped structure.  When the event handle signals a completed
    // read, this loop writes the message to the larger edit field.

    do{
                                       // Read the pipe handle.
      retCode = ReadFile (*hPipe, inBuf, IN_BUF_SIZE, &bytesRead, &OverLapRd);

      if (!retCode) {                  // Do some error checking.
   
        lastError = GetLastError();
                                       // Check for 3 kinds of errors:
                                       // IO_PENDING, BROKEN_PIPE, or
                                       // other.
                                       // If Error = IO_PENDING, wait for
                                       // event handle to signal success.
        if (lastError == ERROR_IO_PENDING)
          {
          WaitForSingleObject (hEventRd, (DWORD)-1);

          }
        else {                         // If pipe is broken, tell user and break.

          if (lastError == (DWORD)ERROR_BROKEN_PIPE) {
            LoadString(hInst, IDS_CONNECTBROKEN, lpBuffer, sizeof(lpBuffer));
            MessageBox (hWndClient, lpBuffer, "", MB_OK);
          }
          else {                       // Or flag unknown errors, and break.
             LoadString(hInst, IDS_READFAILED, lpBuffer, sizeof(lpBuffer));
             wsprintf (Buf, lpBuffer, GetLastError());
             LoadString(hInst, IDS_CLIENTDBG, lpBuffer, sizeof(lpBuffer));
             MessageBox (hWndClient, Buf, lpBuffer, MB_OK);
          }
          break;
        }
      }
                                       // NULL terminate string.
      GetOverlappedResult (*hPipe, &OverLapRd, &bytesTrans, FALSE);
      inBuf[bytesTrans] = '\0';

                                       // Write message to larger edit field.
      SendMessage (GetDlgItem (hWndClient, IDD_EDITREAD),
                   EM_REPLACESEL,
                   0, (LONG)inBuf);
                                       // Add a new line.
      SendMessage (GetDlgItem (hWndClient, IDD_EDITREAD),
                   EM_REPLACESEL,
                   0, (LONG)"\r\n");
      }while(1);

                                       // When pipe is broken, send quit
                                       // messages to Client dialog box.
    PostMessage (hWndClient, WM_GO_AWAY, 0,0);
    ExitThread(0);
  }
