Windows網絡編程筆記3 ---- 郵槽和命名管道

　　郵槽和命名管道的使用方法也很簡單，只需幾個有限的函數就可以實現雙方的通信。

第三、郵槽

　　郵槽----進程間通信機制。

　　通過郵槽客戶進程可以將消息通過廣播給一個或多個服務進程。這是一個單向通信機制，缺點是只允許從客戶機到服務器，優點也是這個原理，使客戶機應用能夠非常容易地將廣播消息發送給一個或多個服務器應用。郵槽是一種無連接方式，是一種”不可靠“的數據傳輸。

　　郵槽名也使用UNC路徑，第二個關鍵字是Mailslot，不可改變

　　\\\\server\\Mailslot\\[path]name  

　　服務器實現過程：

　　CreateMailslot();//創建一個郵槽句柄

　　ReadFile();//接受任何客戶機的數據

　　CloseHandle();//關閉郵槽句柄

　　服務器端郵槽實現

//server1.cpp
//郵槽的實現
#include "windows.h"
#include "winbase.h"
#include "stdio.h"

void main()
{
    HANDLE Mailslot;
    char buffer[256];
    DWORD NumberOfBytesRead;

    //創建郵槽
    if ((Mailslot = CreateMailslot("\\\\.\\Mailslot\\Myslot",0,MAILSLOT_WAIT_FOREVER,NULL)) 
        == INVALID_HANDLE_VALUE)
    {
        printf("Failed to create a mailslot %d\n",GetLastError());
        getchar();
        return ;
    }

    //從郵槽中讀取數據，只有服務器才能從郵槽中讀取數據
    while(ReadFile(Mailslot,buffer,256,&NumberOfBytesRead,NULL) != 0)
    {
        printf("%.*s\n",NumberOfBytesRead,buffer);
    }
    if (!Mailslot)
    {
        CloseHandle(Mailslot);
    }
}

 

　　客戶端實現過程

　　CreateFile();//打開指向郵槽的句柄

　　WriteFile();//寫入數據

　　CloseHandle();//關閉句柄

　　客戶端郵槽代碼實現

//client.cpp
//郵槽客戶端

#include "windows.h"
#include "stdio.h"

void main()
{
    HANDLE Mailslot;
    DWORD ByteWritten;
    CHAR ServerName[256];

    if((Mailslot=CreateFile("\\\\.\\Mailslot\\Myslot",GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIB　　　　　　　　　　　　　　　　　　　　UTE_NORMAL,NULL)) == INVALID_HANDLE_VALUE)//這里就是郵槽的創建
    {
        printf("Createfile failed with error %d\n",GetLastError());
        getchar();
        return ;
    }

    if (WriteFile(Mailslot,"This is a test",15,&ByteWritten,NULL) == 0)//寫入數據
    {
        printf("WriteFile failed with error %d\n",GetLastError());
        getchar();
        return ;
    }

    printf("Write %d bytes\n",ByteWritten);
    getchar();
    CloseHandle(Mailslot);
}

　　下面在服務器上添加線程，用於自己終止程序運行，而不是讓其一直處於掛起狀態。這種方式是為了避免服務器在ReadFile()時服務器程序因某種原因而終止，此時ReadFile()沒有完成，程序會一直處於掛起狀態，直到有數據可讀。

　　服務器端可以自己終止接受數據

//server2.cpp
//郵槽的線程實現
#include "windows.h"
#include "winbase.h"
#include "stdio.h"
#include "conio.h"

BOOL StopProcessing;

DWORD WINAPI ServerMailslot(LPVOID lpParameter);
void SendMessageToMailslot(void);//自己向郵槽發送數據

void main()
{
    HANDLE MailslotThread;
    DWORD ThreadID;
    StopProcessing = FALSE;
    MailslotThread = CreateThread(NULL,0,ServerMailslot,NULL,0,&ThreadID);

    printf("Press a key to stop the server\n");
    _getch();

    //按下按鍵以后，賦值為TRUE，在線程中終止程序運行
    StopProcessing = TRUE;

    //發送消息，之后線程會進入while()循環，並且會終止循環
    SendMessageToMailslot();//自己向郵槽發送數據

    //
    if (WaitForSingleObject(MailslotThread,INFINITE) == WAIT_FAILED)
    {
        printf("WaitForSingleObject Failed with error  %d\n",GetLastError());
        getchar();
        return ;
    }
}

//線程入口函數
DWORD WINAPI ServerMailslot(LPVOID lpParameter)
{
    char buffer[2048];
    DWORD NumberOfBytesRead;
    DWORD Ret;
    HANDLE Mailslot;

    if ((Mailslot = CreateMailslot("\\\\.\\mailslot\\myslot",2048,MAILSLOT_WAIT_FOREVER,NULL))
        == INVALID_HANDLE_VALUE)
    {
        printf("Failed to create a mailslot %d\n",GetLastError());
        getchar();
        return 0;
    }

    while ((Ret = ReadFile(Mailslot,buffer,2048,&NumberOfBytesRead,NULL)) != 0)
    {
        if(StopProcessing)
            break;
        printf("Receive %d bytes \n",NumberOfBytesRead);
    }
    CloseHandle(Mailslot);
    return 0;
}

//發送終止信息
void SendMessageToMailslot()
{
    HANDLE Mailslot;
    DWORD BytesWritten;
    if ((Mailslot = CreateFile("\\\\.\\mailslot\\myslot",GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_EXISTING
        ,FILE_ATTRIBUTE_NORMAL,NULL)) == INVALID_HANDLE_VALUE)
    {
        printf("CreateFile Failed with error  %d\n",GetLastError());
        getchar();
        return ;
    }
    if (WriteFile(Mailslot,"STOP",4,&BytesWritten,NULL) == 0)
    {
        printf("WriteFile Failed with error  %d\n",GetLastError());
        getchar();
        return ;
    }
    CloseHandle(Mailslot);
}

　 這樣可以避免服務器進入無限的等待。

郵槽總結：

　　使用郵槽，應用程序可以在Windows重定向器的幫助下，實現簡單的單向進程間數據通信。對郵槽來說，它最有價值的一項功能便是通過網絡，將一條消息廣播給一台或多台計算機。然而，郵槽並未提供對數據可靠傳輸的保障。是一種不可靠的數據傳輸。

 

第四、命名管道

　　命名管道實際上建立一個簡單的客戶機／服務器數據通信體系，可在其中可靠地傳輸數據。

　　規則：

命名管道的標識是采用 U N C格式進行的：\ \ server\pipe\ [ path ]name

　　其中的pipe是一個標記，不能改變，不區分大小寫。例子如下：

　　\\\\ myserver\\pipe\\mypipe

　　通信方式

　　命名管道提供了兩種基本通信模式：字節模式和消息模式。

　　在字節模式中，消息以一個連續的字節流的形式，在客戶機與服務器之間流動。在一方寫入某個數量的字節，並不表示在另一方會讀出等量的字節。這樣一來，客戶機和服務器在傳輸數據的時候，便不必關心數據的內容。

　　在消息模式中，客戶機和服務器則通過一系列不連續的數據單位，進行數據的收發。每次在管道上發出了一條消息后，它必須作為一條完整的消息讀入。

　　服務器與客戶機的區別

　　命名管道的最大特點就是建立了一個基於服務器/客戶機的程序設計體系。在這個體系結構中，數據既可以單向流動，也可以雙向流動。但是服務器是唯一一個有權利創建命名管道的進程，也只有它有權利接受來自客戶端的鏈接請求。

　　服務器的實現過程

　　CreateNamedPipe();//創建命名管道實例句柄

　　ConnectNamedPipe();//監聽來自客戶機的鏈接請求

　　ReadFile(),WriteFile();//讀寫數據

　　DisconnectNmaePipe();//關閉命名通道連接

　　CloseHandle();//關閉命名管道實例句柄

　　客戶端實現過程

　　WaitNamedPipe();// 等候一個命名管道實例可供自己使用

　　CreateFile();// 建立與命名管道的連接

　　WriteFile(); ，ReadFile();//讀寫數據

　　CloseHandle();// 關閉命名管道會話

　　

　簡單命名管道的實現

//命名管道的實現

#include "windows.h"
#include "stdio.h"

void main()
{
    HANDLE PipeHnadle;
    DWORD BytesRead;
    CHAR buffer[256];

    if ((PipeHnadle = CreateNamedPipe("\\\\.\\Pipe\\Song",PIPE_ACCESS_DUPLEX,PIPE_TYPE_BYTE | PIPE_READMODE_BYTE
        ,1,0,0,1000,NULL)) == INVALID_HANDLE_VALUE)//創建
    {
        printf("CreateNamedPipe failed with error %d\n",GetLastError());
        getchar();
        return ;
    }
    printf("Server is now running!\n");

    if (ConnectNamedPipe(PipeHnadle,NULL) == 0)//連接客戶端
    {
        printf("ConnectNamedPipe failed with error %d\n",GetLastError());
        CloseHandle(PipeHnadle);
        getchar();
        return ;
    }

    if (ReadFile(PipeHnadle,buffer,sizeof(buffer),&BytesRead,NULL) <= 0)//讀取數據
    {
        printf("ReadFile failed with error %d\n",GetLastError());
        CloseHandle(PipeHnadle);
        getchar();
        return ;
    }

    printf("%.*s\n",BytesRead,buffer);

    if (DisconnectNamedPipe(PipeHnadle) == 0)//關閉
    {
        printf("DisconnectNamedPipe failed with error %d\n",GetLastError());
        getchar();
        return ;
    }

    CloseHandle(PipeHnadle);
    getchar();
    getchar();
}

　　同時控制多個管道實例，命名管道可以實現多個實例的連接。這個數量有函數CreateNamedPipe()控制

HANDLE WINAPI CreateNamedPipe(
  _In_      LPCTSTR lpName,//管道名稱
  _In_      DWORD dwOpenMode,//打開模式，如PIPE_ACCESS_DUPLES 雙向管道，PIPE_FLAG_OVEERLAPPED(重疊I/O)
  _In_      DWORD dwPipeMode,//管道模式，字節流還是信息流
  _In_      DWORD nMaxInstances,//最大連接實例數量
  _In_      DWORD nOutBufferSize,//輸出緩沖區大小
  _In_      DWORD nInBufferSize,//輸入緩沖區大小
  _In_      DWORD nDefaultTimeOut,//超時設置
  _In_opt_  LPSECURITY_ATTRIBUTES lpSecurityAttributes//安全描述符
);

　　多管道實現，使用線程

//命名管道的實現,多線程

#include "windows.h"
#include "stdio.h"
#include "conio.h"

#define NUM_PIPES 5

DWORD WINAPI PipeInstanceProc(LPVOID lpParameter);
void main()
{
    HANDLE ThreadHandle;
    INT i;
    DWORD ThreadID;

    for(i = 0 ; i < NUM_PIPES ;i ++ )
    {
        //創建線程保存管道實例
        if ((ThreadHandle = CreateThread(NULL,0,PipeInstanceProc,
            NULL,0,&ThreadID)) == NULL)
        {
            printf("CreateThread failed with error %d \n",GetLastError());
            getchar();
            return ;
        }
        CloseHandle(ThreadHandle);
    }

    printf("Press any key to stop the server!\n");
    _getch();
}

//入口函數

DWORD WINAPI PipeInstanceProc(LPVOID lpParameter)
{
    HANDLE PipeHandle;
    DWORD BytesRead;
    DWORD BytesWritten;
    CHAR buffer[256];

    if ((PipeHandle = CreateNamedPipe("\\\\.\\Pipe\\Song",PIPE_ACCESS_DUPLEX,PIPE_TYPE_BYTE | PIPE_READMODE_BYTE
        ,NUM_PIPES,0,0,1000,NULL)) == INVALID_HANDLE_VALUE)
    {
        printf("CreateNamedPipe failed with error %d \n",GetLastError());
        getchar();
        return 0;
    }
    //一直嘗試連接客戶端
    while (true)
    {
        if (ConnectNamedPipe(PipeHandle,NULL) == 0)
        {
            printf("ConnectNamedPipe failed with error %d \n",GetLastError());
            getchar();
            break;
        }
        //讀取數據
        while (ReadFile(PipeHandle,buffer,sizeof(buffer),&BytesRead,NULL) > 0)
        {
            printf("Echo %d bytes to client \n",BytesRead);
            if (WriteFile(PipeHandle,buffer,BytesRead,&BytesWritten,NULL) == 0)
            {
                printf("WriteFile failed with error %d \n",GetLastError());
                getchar();
                break;
            }
        }
        if (DisconnectNamedPipe(PipeHandle) == 0)
        {
            printf("DisconnectNamedPipe failed with error %d \n",GetLastError());
            getchar();
            break;
        }
    }
    CloseHandle(PipeHandle);
    return 0;
}

　　最后看一下基於重疊I/O模式的管道通信

　　這個重疊I/O的設置在CreateNamedPipe();的第二個參數 dwOpenMode，只需在里面包含 PIPE_FLAG_OVEERLAPPED就行。

//overlapped_server.cpp

//重疊I/O方式是下命名管道

#include "windows.h"
#include "stdio.h"

#define NUM_PIPES 5
#define BUFFER_SIZE 256

void main()
{
    HANDLE PipeHandles[NUM_PIPES];
    DWORD BytesTransferred;
    CHAR buffer[NUM_PIPES][BUFFER_SIZE];
    int i;
    OVERLAPPED ovlap[NUM_PIPES];
    HANDLE Event[NUM_PIPES];

    //////////////////////////////////////////////////////////////////////////

    BOOL DataRead[NUM_PIPES];
    DWORD Ret;
    DWORD Pipe;

    for (i = 0; i < NUM_PIPES ; i ++)
    {
        //創建命名管道實例
        if ((PipeHandles[i] = CreateNamedPipe("\\\\.\\pipe\\Song",PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
            PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,NUM_PIPES,0,0,1000,NULL)) == INVALID_HANDLE_VALUE)
        {
            printf("CreateNamedPipe for pipe %d failed with error %d\n",i,GetLastError());
            getchar();
            return ;
        }
        //創建事件
        if ((Event[i] = CreateEvent(NULL,TRUE,FALSE,NULL)) == NULL)
        {
            printf("CreateEvent for pipe %d failed with error %d\n",i,GetLastError());
            getchar();
            continue ;
        }
        //保存事件狀態
        DataRead[i] = FALSE;
        ZeroMemory(&ovlap[i],sizeof(OVERLAPPED));

        //監聽事件
        if (ConnectNamedPipe(PipeHandles[i],&ovlap[i]) == 0)
        {
            if (GetLastError() != ERROR_IO_PENDING)
            {
                printf("ConnectNamedPipe for pipe %d failed with error %d\n",i,GetLastError());
                CloseHandle(PipeHandles[i]);
                getchar();
                return ;
            }
        }
    }

    //
    printf("Server is running!\n");
    //////////////////////////////////////////////////////////////////////////

    //讀取數據
    while (true)
    {
        if ((Ret = WaitForMultipleObjects(NUM_PIPES,Event,FALSE,INFINITE)) == WAIT_FAILED)
        {
            printf("WaitForMultipleObjects  failed with error %d\n",GetLastError());
            getchar();
            return ;
        }
        Pipe = Ret - WAIT_OBJECT_0;
        ResetEvent(Event[Pipe]);

        //檢查I/O狀態，如果失敗，就斷開連接並重新嘗試讀取數據
        if (GetOverlappedResult(PipeHandles[Pipe],&ovlap[Pipe],&BytesTransferred,TRUE) == 0)
        {
            printf("GetOverlappedResult  failed with error %d\n",GetLastError());
            //斷開連接
            if (DisconnectNamedPipe(PipeHandles[Pipe]) == 0)
            {
                printf("DisconnectNamedPipe  failed with error %d\n",GetLastError());
                return ;
            }
            if (ConnectNamedPipe(PipeHandles[Pipe],&ovlap[pipe]) == 0)
            {
                if (GetLastError() != ERROR_IO_PENDING)
                {
                    //服務器出錯，關閉句柄
                    printf("ConnectNamedPipe for pipe %d failed with error %d\n",i,GetLastError());
                    CloseHandle(PipeHandles[Pipe]);
                }
            }

            DataRead[Pipe] = FALSE;
        }
        else
        {
            //如果管道上有數據就讀取並發送客戶端，如果沒有就一直嘗試讀取
            if (DataRead[Pipe] == FALSE)
            {
                ZeroMemory(&ovlap[Pipe],sizeof(OVERLAPPED));
                ovlap[Pipe].hEvent = Event[Pipe];

                if (ReadFile(PipeHandles[Pipe],buffer[Pipe],BUFFER_SIZE,NULL,&ovlap[Pipe]) == 0)
                {
                    if (GetLastError() != ERROR_IO_PENDING)
                    {
                        printf("ReadFile failed with error %d\n",GetLastError());

                    }
                }
                DataRead[Pipe] = TRUE;
            }
            else
            {
                //向管道寫入數據
                printf("Received %d bytes ,echo bytes back \n",BytesTransferred);
                ZeroMemory(&ovlap[Pipe],sizeof(OVERLAPPED));
                ovlap[Pipe].hEvent = Event[Pipe];

                if (WriteFile(PipeHandles[Pipe],buffer[Pipe],BUFFER_SIZE,NULL,&ovlap[Pipe]) == 0)
                {
                    if (GetLastError() != ERROR_IO_PENDING)
                    {
                        printf("WriteFile failed with error %d\n",GetLastError());

                    }
                }
                DataRead[Pipe] = FALSE;
            }

        }
    }
}

　　　再看一下客戶端的實現

 //client3.cpp

//簡單命名管道客戶機


#include "windows.h"
#include "stdio.h"
#include "conio.h"

#define PIPE_NAME "\\\\.\\pipe\\Song"

void main()
{

    HANDLE PipeHandle;
    DWORD BytesWritten;
    DWORD BytesRead;
    CHAR buffer[256];
    memset(&buffer,0,sizeof(buffer));
    //等待可用的命名管道
    if (WaitNamedPipe(PIPE_NAME,NMPWAIT_WAIT_FOREVER) == 0)
    {
        printf("WaitNamedPipe failed with error %d \n",GetLastError());
        getchar();
        return ;
    }
    //創建命名管道句柄

    if ((PipeHandle = CreateFile(PIPE_NAME,GENERIC_READ | GENERIC_WRITE,
            0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL)) == INVALID_HANDLE_VALUE)
    {
        printf("CreateFile failed with error %d \n",GetLastError());
        getchar();
        return ;
    }
    //寫入數據
    if ((WriteFile(PipeHandle,"This is a test",14,&BytesWritten,NULL)) == 0)
    {
        printf("WriteFile failed with error %d \n",GetLastError());
        CloseHandle(PipeHandle);
        getchar();
        return ;
    }
    
    printf("Wrote %d bytes\n",BytesWritten);

    //讀取數據
    if (ReadFile(PipeHandle,buffer,sizeof(buffer),&BytesRead,NULL) > 0)
    {    
        printf("Receive:dfj %s\n",buffer);
        printf("Read  %d bytes\n",BytesWritten);
        getchar();
        return ;
    }

    getchar();
    CloseHandle(PipeHandle);

}

 　

　最后還有幾個簡化后的API，使用起來更加方便　

CallNamedPipe();//客戶機，可同時讀寫數據

TransactNamedPipe();//客戶機、服務器，可同時讀寫數據

BOOL WINAPI CallNamedPipe(
  _In_   LPCTSTR lpNamedPipeName,//管道名稱，采用UNC格式
  _In_   LPVOID lpInBuffer,//發送數據緩存區
  _In_   DWORD nInBufferSize,//數據緩存區大小
  _Out_  LPVOID lpOutBuffer,//接受數據緩存區
  _In_   DWORD nOutBufferSize,//接受數據緩存區大小
  _Out_  LPDWORD lpBytesRead,//從管道中讀取的數據大小
  _In_   DWORD nTimeOut//超時
);

其中nTimeOut 的參數可供選擇為：

　　NMPWAIT_NOWAIT   //不可用則直接退出，並返回錯誤

　　WMPWAIT_WAIT_FOREVER//一直等待

　　NMPWAIT_USE_DEFAULT_WAIT//使用默認的超時設置

BOOL WINAPI TransactNamedPipe(
  _In_         HANDLE hNamedPipe,//命名管道句柄
  _In_         LPVOID lpInBuffer,//發送數據緩沖區
  _In_         DWORD nInBufferSize,//緩沖區大小
  _Out_        LPVOID lpOutBuffer,//接受數據緩沖區
  _In_         DWORD nOutBufferSize,//緩沖區大小
  _Out_        LPDWORD lpBytesRead,//實際讀取的數據多少
  _Inout_opt_  LPOVERLAPPED lpOverlapped//重疊I/O
);

GetNamedPipeHandleState();//

用於接收與一個指定命名管道對應的信息，比如運行模式（消息或字節模式）、管道實例數以及緩沖區信息等等。

BOOL WINAPI GetNamedPipeHandleState(
  _In_       HANDLE hNamedPipe,//命名管道句柄
  _Out_opt_  LPDWORD lpState,//管道狀態PIPE_NOWAIT，PIPE_READMODE_MESSAGE
  _Out_opt_  LPDWORD lpCurInstances,//當前管道的實例數量
  _Out_opt_  LPDWORD lpMaxCollectionCount,//實際最大字節數
  _Out_opt_  LPDWORD lpCollectDataTimeout,//超時
  _Out_opt_  LPTSTR lpUserName,//客戶機名稱
  _In_       DWORD nMaxUserNameSize//客戶機數量
);

 

SetNamedPipeHandleState ();//設置管道的一些參數，傳輸模式

BOOL WINAPI SetNamedPipeHandleState(
  _In_      HANDLE hNamedPipe,//命名管道句柄
  _In_opt_  LPDWORD lpMode,//傳輸模式，字節流或者信息流
  _In_opt_  LPDWORD lpMaxCollectionCount,//最大字節數
  _In_opt_  LPDWORD lpCollectDataTimeout//超時
);

lpMode的參數有兩個PIPE_READMODE_BYTE（字節流），PIPE_READMODE_MESSAGE（消息流）

 

GetNamedPipeInfo();//獲得緩沖區大小以及管道實例最大數量信息

BOOL WINAPI GetNamedPipeInfo(
  _In_       HANDLE hNamedPipe,
  _Out_opt_  LPDWORD lpFlags,//管道類型，服務器或者客戶端
  _Out_opt_  LPDWORD lpOutBufferSize,
  _Out_opt_  LPDWORD lpInBufferSize,
  _Out_opt_  LPDWORD lpMaxInstances//管道最大實例數量
);

lpFlags的參數選擇為：

　　PIPE_CLIENT_END//客戶機

　　PIPE_SERVER_END//服務器

　　PIPE_TYPE_BYTE//字節流

　　PIPE_TYPE_MESSAGE//消息流

 

PeekNamedPipe();//可用它對命令管道內的數據進行瀏覽，同時毋需將其從管道的內部緩沖區挪出。

BOOL WINAPI PeekNamedPipe(
  _In_       HANDLE hNamedPipe,
  _Out_opt_  LPVOID lpBuffer,//讀取數據緩沖區
  _In_       DWORD nBufferSize,//緩沖區大小
  _Out_opt_  LPDWORD lpBytesRead,//讀取數據大小
  _Out_opt_  LPDWORD lpTotalBytesAvail,//接收可從管道發出的字節總數
  _Out_opt_  LPDWORD lpBytesLeftThisMessage//於接收消息內尚存的字節數量（前提是管道用消息模式打開
);