The Windows Pipes Programming windows“管道”编程 之 "匿名管道"

何为“管道”？

“管道”是进程间通讯的一段共享内存区域。创建管道的进程成为管道服务器，连接到管道上的进程成为管道客户端。一个进程向管道写数据，其他进程可以从管道中读取数据。

“管道的分类”

管道分为两种，匿名管道和命名管道。匿名管道比命名管道需要的开销要小，但是提供的功能要少。管道在这里的含义暗示着它是一种连接信息的管子。管子有两端，单工通讯的管道允许在写端的进程把信息写入管子，在读端的进程读取管道中的信息。全双工通讯的管道允许在两端进行读写。

匿名管道提供单工通讯，没有名称。并且只能用于本地，不能通过网络通讯。

命名管道是一个有名称，能提供单工或全双工通讯的管子。它允许一个管道服务器，多个管道客户端。所有命名管道的实例共享一个管道名称，但是每个实例有它自己的缓冲区和句柄，并且为每个服务器/客户端通讯提供单独的信息传输渠道.这种方式允许多个管道客户端同时使用命名管道.任何命名管道都可以被任何进程访问,但是受制与安全检测策略.因此命名管道可以方便的区分相关与不相关的进程.

任何进程都可以作为服务器或者客户端,这使得p2p通信成为可能.这里管道服务器是指创建管道的进程,管道客户端是指连接到一个命名管道实例上的进程.管道服务器端使用CreateNamedPipe创建命名管道,使用ConnectNamedPipe接收连接请求.管道客户端使用CreateFile 和CallNamedPipe连接命名管道.

命名管道可以为本地或者通过网络与远程电脑中的进程提供通讯.如果你仅仅想让命名管道运行在本地,可以用本地RPC策略或者禁止访问NT AUTHORITY\NETWORK.

“匿名管道”使用示例

代码要实现的功能就是创建两个控制台程序，一个控制台写消息，另一个控制台收消息。这是子父进程通信中匿名管道的典型用法，我们先直观看看这个示例是怎么工作的：

 

左边是父控制台，右边是子控制台。左边输入字符，右边就会显示出来：

下面是代码：

#include "UnNamedPipe.h"
#include <iostream>

using namespace std;

HANDLE g_hReadPipe;
HANDLE g_hWritePipe;

int main()
{
    LPTSTR errbuff;
    char strBuff[256] = {0};
    char* QUITCHAR = "q";
    CUnNamedPipe myPipe;
    SECURITY_ATTRIBUTES saAttr;
    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
    saAttr.bInheritHandle = TRUE; 
    saAttr.lpSecurityDescriptor = NULL; 
    STARTUPINFO siStartInfo;
    PROCESS_INFORMATION piProcInfo;
    DWORD nWriteTo;
    TCHAR szAppName[] = TEXT("C:\\Users\\user\\Documents\\Visual Studio 2010\\Projects\\PipeWorkShop\\Debug\\AnonymousPipeClientTest.exe"); 
    if(!myPipe.CreatePipe(g_hReadPipe, g_hWritePipe, saAttr, 0))
    {
        DWORD d = GetLastError();
        FormatMessage ( FORMAT_MESSAGE_ALLOCATE_BUFFER  | 
            FORMAT_MESSAGE_IGNORE_INSERTS  | 
            FORMAT_MESSAGE_FROM_SYSTEM,
            NULL,
            d, 
            LANG_NEUTRAL,
            (LPTSTR) & errbuff,
            0 ,
            NULL );
        cout<<"can not create pipe!"<<endl;
        return 1;
    }

    if(!SetHandleInformation(g_hReadPipe, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
    {
        cout<<"set handle property error!"<<endl;
    }
    /*if(!SetHandleInformation(g_hWritePipe, HANDLE_FLAG_INHERIT, 0))
    {
        cout<<"set handle property error!"<<endl;
    }*/
    ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
    siStartInfo.cb = sizeof(STARTUPINFO); 
    siStartInfo.hStdInput = g_hReadPipe;
    siStartInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
    
    if(!CreateProcess(szAppName, NULL, NULL, NULL, TRUE,CREATE_NEW_CONSOLE, NULL,NULL, &siStartInfo, &piProcInfo))
    {
        DWORD d = GetLastError();
        FormatMessage ( FORMAT_MESSAGE_ALLOCATE_BUFFER  | 
                     FORMAT_MESSAGE_IGNORE_INSERTS  | 
                     FORMAT_MESSAGE_FROM_SYSTEM,
                     NULL,
                     d, 
                     LANG_NEUTRAL,
                     (LPTSTR) & errbuff,
                      0 ,
                     NULL );

        cout<<"can't create process:"<<szAppName<<endl;
        cout<<errbuff;
        return 0;
    }
    cout<<"press q to quit, others to show!"<<endl;
    while (cin>>strBuff )
    {
        while(strBuff[0]!=0)
        {
            if(!WriteFile(g_hWritePipe, strBuff, sizeof strBuff, &nWriteTo, NULL))
            {
                cout<<"write file error!"<<endl;
                break;
            }
            if(strcmp(strBuff, QUITCHAR) == 0)
            {
                return 0;;
            }
            ZeroMemory(strBuff, sizeof(strBuff));
        }
        
    }
    CloseHandle(piProcInfo.hProcess);
    CloseHandle(piProcInfo.hThread);

    myPipe.ClosePipe(g_hReadPipe);
    myPipe.ClosePipe(g_hWritePipe);

    return 0;
}

#include <Windows.h>
#include <iostream>

using namespace std;
int main()
{
    HANDLE hStdin, hStdout;
    char buff[256] = {0};
    char* QUIT = "q";
    DWORD dwRead;
    DWORD dwWrite;
    hStdin = GetStdHandle(STD_INPUT_HANDLE);
    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hStdin == INVALID_HANDLE_VALUE || hStdout == INVALID_HANDLE_VALUE)
    {
        return 1;
    }
    cout<<"client is working!"<<endl;
    while(1)
    {
        if(ReadFile(hStdin, buff, 256, &dwRead, NULL) && buff[0] != 0)
        {
            if(strcmp(buff,QUIT) == 0)
                return 0;
            else
            {
                cout<<buff<<endl;
                //WriteFile(hStdout, buff, 256, &dwWrite, NULL); there is someting interesting if you use this instead of before one.
                ZeroMemory(buff, sizeof buff);
            }
            
        }
        
        Sleep(500);
    }
    cout<<"client will shutdown in 3 sec!"<<endl;
    Sleep(3000);
    return 0;
}

接口代码:

/********************************************************************
    created:    2012/08/11
    file name:    IPipe.h
    author:        baesky
    http://www.cnblogs.com/Baesky/
    purpose:    Give a public interface.
*********************************************************************/

#pragma once
#include <Windows.h>
class IPipe
{
public:
    virtual bool CreatePipe(HANDLE& hReadPipe, HANDLE& hWritePipe, SECURITY_ATTRIBUTES& lpPipeAttributes, DWORD nBuffSize) = 0;
    virtual bool ClosePipe(HANDLE hPipe) = 0;
};

#pragma once
#include "IPipe.h"


class CUnNamedPipe:public IPipe
{
public:
    CUnNamedPipe(void);
    ~CUnNamedPipe(void);

    bool CreatePipe(HANDLE& hReadPipe, HANDLE& hWritePipe, SECURITY_ATTRIBUTES& lpPipeAttributes, DWORD nBuffSize);
    bool ClosePipe(HANDLE hPipe);
};

#include "UnNamedPipe.h"


CUnNamedPipe::CUnNamedPipe(void)
{
}


CUnNamedPipe::~CUnNamedPipe(void)
{
}

bool CUnNamedPipe::CreatePipe(HANDLE& hReadPipe, HANDLE& hWritePipe, SECURITY_ATTRIBUTES& lpPipeAttributes, DWORD nBuffSize)
{
    return ::CreatePipe(&hReadPipe, &hWritePipe, &lpPipeAttributes, nBuffSize);
}

bool CUnNamedPipe::ClosePipe(HANDLE hPipe)
{
    return CloseHandle(hPipe);
}