基于visual c++之windows核心编程代码分析（17）通过pipe进程间通信

管道是一种用于在进程间共享数据的机制，其实质是一段共享内存。Windows系统为这段共享的内存设计采用数据流I/0的方式来访问。由一个进程读、另一个进程写，类似于一个管道两端，因此这种进程间的通信方式称作“管道”。

管道分为匿名管道和命名管道。

匿名管道只能在父子进程间进行通信，不能在网络间通信，而且数据传输是单向的，只能一端写，另一端读。

命令管道可以在任意进程间通信，通信是双向的，任意一端都可读可写，但是在同一时间只能有一端读、一端写。

管道客户端代码实现如下

/* 头文件 */
#include <windows.h> 
#include <stdio.h>
#include <conio.h>
#include <tchar.h>
/* 常量 */
#define BUFSIZE 512
/* ************************************
* int main(VOID) 
* 功能	pipe 通信服务端主函数
**************************************/
int main(int argc, TCHAR *argv[]) 
{ 
	HANDLE hPipe; 
	LPTSTR lpvMessage=TEXT("Default message from client"); 
	TCHAR chBuf[BUFSIZE]; 
	BOOL fSuccess; 
	DWORD cbRead, cbWritten, dwMode; 
	LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\samplenamedpipe"); 

	if( argc > 1 )	// 如果输入了参数，则使用输入的参数
		lpvMessage = argv[1];
	while (1) 
	{ 
		// 打开一个命名pipe
		hPipe = CreateFile( 
			lpszPipename,   // pipe 名 
			GENERIC_READ |   GENERIC_WRITE,		//  可读可写
			0,              // 不共享
			NULL,           // 默认安全属性
			OPEN_EXISTING,  // 已经存在（由服务端创建）
			0,              // 默认属性
			NULL);    
		if (hPipe != INVALID_HANDLE_VALUE) 
			break; 

		// 如果不是 ERROR_PIPE_BUSY 错误，直接退出  
		if (GetLastError() != ERROR_PIPE_BUSY) 
		{
			printf("Could not open pipe"); 
			return 0;
		}

		// 如果所有pipe实例都处于繁忙状态，等待2秒。
		if (!WaitNamedPipe(lpszPipename, 2000)) 
		{ 
			printf("Could not open pipe"); 
			return 0;
		} 
	} 

	// pipe已经连接，设置为消息读状态 
	dwMode = PIPE_READMODE_MESSAGE; 
	fSuccess = SetNamedPipeHandleState( 
		hPipe,    // 句柄
		&dwMode,  // 新状态
		NULL,     // 不设置最大缓存
		NULL);    // 不设置最长时间
	if (!fSuccess) 
	{
		printf("SetNamedPipeHandleState failed"); 
		return 0;
	}

	// 写入pipe
	fSuccess = WriteFile( 
		hPipe,                  // 句柄
		lpvMessage,             // 写入的内容
		(lstrlen(lpvMessage)+1)*sizeof(TCHAR), // 写入内容的长度
		&cbWritten,             // 实际写的内容
		NULL);                  // 非 overlapped 
	if (!fSuccess) 
	{
		printf("WriteFile failed"); 
		return 0;
	}

	do 
	{ 
		// 读回复 
		fSuccess = ReadFile( 
			hPipe,    // 句柄
			chBuf,    // 读取内容的缓存
			BUFSIZE*sizeof(TCHAR),  // 缓存大小
			&cbRead,  // 实际读的字节
			NULL);    // 非 overlapped 

		if (! fSuccess && GetLastError() != ERROR_MORE_DATA) 
			break; //失败，退出

		_tprintf( TEXT("%s\n"), chBuf ); // 打印读的结果
	} while (!fSuccess);  //  ERROR_MORE_DATA 或者成功则循环

	getch();//任意键退出
	// 关闭句柄
	CloseHandle(hPipe);  
	return 0; 
}

管道服务端代码实现如下，

/* 头文件 */
#include <windows.h> 
#include <stdio.h>
#include <tchar.h>
/* 常量 */
#define PIPE_TIMEOUT 5000
#define BUFSIZE 4096
/* 结构定义 */
typedef struct 
{ 
	OVERLAPPED oOverlap; 
	HANDLE hPipeInst; 
	TCHAR chRequest[BUFSIZE]; 
	DWORD cbRead;
	TCHAR chReply[BUFSIZE]; 
	DWORD cbToWrite; 
} PIPEINST, *LPPIPEINST; 
/* 函数声明 */
VOID DisconnectAndClose(LPPIPEINST); 
BOOL CreateAndConnectInstance(LPOVERLAPPED); 
BOOL ConnectToNewClient(HANDLE, LPOVERLAPPED); 
VOID GetAnswerToRequest(LPPIPEINST); 
VOID WINAPI CompletedWriteRoutine(DWORD, DWORD, LPOVERLAPPED); 
VOID WINAPI CompletedReadRoutine(DWORD, DWORD, LPOVERLAPPED); 
/* 全局变量 */
HANDLE hPipe; 
/* ************************************
* int main(VOID) 
* 功能	pipe 通信服务端主函数
**************************************/
int main(VOID) 
{ 
	HANDLE hConnectEvent; 
	OVERLAPPED oConnect; 
	LPPIPEINST lpPipeInst; 
	DWORD dwWait, cbRet; 
	BOOL fSuccess, fPendingIO; 

	// 用于连接操作的事件对象 
	hConnectEvent = CreateEvent( 
		NULL,    // 默认属性
		TRUE,    // 手工reset
		TRUE,    // 初始状态 signaled 
		NULL);   // 未命名

	if (hConnectEvent == NULL) 
	{
		printf("CreateEvent failed with %d.\n", GetLastError()); 
		return 0;
	}
	// OVERLAPPED 事件
	oConnect.hEvent = hConnectEvent; 

	// 创建连接实例，等待连接
	fPendingIO = CreateAndConnectInstance(&oConnect); 

	while (1) 
	{
		// 等待客户端连接或读写操作完成 
		dwWait = WaitForSingleObjectEx( 
			hConnectEvent,  // 等待的事件 
			INFINITE,       // 无限等待
			TRUE);       

		switch (dwWait) 
		{ 
		case 0:		
			// pending 
			if (fPendingIO) 
			{ 
				// 获取 Overlapped I/O 的结果
				fSuccess = GetOverlappedResult( 
					hPipe,     // pipe 句柄 
					&oConnect, // OVERLAPPED 结构 
					&cbRet,    // 已经传送的数据量
					FALSE);    // 不等待
				if (!fSuccess) 
				{
					printf("ConnectNamedPipe (%d)\n", GetLastError()); 
					return 0;
				}
			} 

			// 分配内存 
			lpPipeInst = (LPPIPEINST) HeapAlloc(GetProcessHeap(),0,sizeof(PIPEINST)); 
			if (lpPipeInst == NULL) 
			{
				printf("GlobalAlloc failed (%d)\n", GetLastError()); 
				return 0;
			}
			lpPipeInst->hPipeInst = hPipe; 

			// 读和写，注意CompletedWriteRoutine和CompletedReadRoutine的相互调用
			lpPipeInst->cbToWrite = 0; 
			CompletedWriteRoutine(0, 0, (LPOVERLAPPED) lpPipeInst); 

			// 再创建一个连接实例，以响应下一个客户端的连接
			fPendingIO = CreateAndConnectInstance( 
				&oConnect); 
			break; 

			// 读写完成 
		case WAIT_IO_COMPLETION: 
			break; 

		default: 
			{
				printf("WaitForSingleObjectEx (%d)\n", GetLastError()); 
				return 0;
			}
		} 
	} 
	return 0; 
} 

/* ************************************
* CompletedWriteRoutine 
* 	写入pipe操作的完成函数
*	接口参见FileIOCompletionRoutine回调函数定义
*
*	当写操作完成时被调用，开始读另外一个客户端的请求
**************************************/
VOID WINAPI CompletedWriteRoutine(
								  DWORD dwErr, 
								  DWORD cbWritten, 
								  LPOVERLAPPED lpOverLap) 
{ 
	LPPIPEINST lpPipeInst; 
	BOOL fRead = FALSE; 
	// 保存overlap实例
	lpPipeInst = (LPPIPEINST) lpOverLap; 

// 如果没有错误
	if ((dwErr == 0) && (cbWritten == lpPipeInst->cbToWrite)) 
	{		
		fRead = ReadFileEx( 
		lpPipeInst->hPipeInst, 
		lpPipeInst->chRequest, 
		BUFSIZE*sizeof(TCHAR), 
		(LPOVERLAPPED) lpPipeInst, 
		// 写读操作完成后，调用CompletedReadRoutine
		(LPOVERLAPPED_COMPLETION_ROUTINE) CompletedReadRoutine); 
	}	
	if (! fRead) 
		// 出错，断开连接
		DisconnectAndClose(lpPipeInst); 
} 

/* ************************************
* CompletedReadRoutine 
* 	读取pipe操作的完成函数
*	接口参见FileIOCompletionRoutine回调函数定义
*
*	当读操作完成时被调用，写入回复
**************************************/
VOID WINAPI CompletedReadRoutine(
								 DWORD dwErr, 
								 DWORD cbBytesRead, 
								 LPOVERLAPPED lpOverLap) 
{ 
	LPPIPEINST lpPipeInst; 
	BOOL fWrite = FALSE; 

	// 保存overlap实例
	lpPipeInst = (LPPIPEINST) lpOverLap; 

	// 如果没有错误
	if ((dwErr == 0) && (cbBytesRead != 0)) 
	{ 
		// 根据客户端的请求，生成回复
		GetAnswerToRequest(lpPipeInst); 
		// 将回复写入到pipe
		fWrite = WriteFileEx( 
			lpPipeInst->hPipeInst, 
			lpPipeInst->chReply,	//将响应写入pipe
			lpPipeInst->cbToWrite, 
			(LPOVERLAPPED) lpPipeInst, 
			// 写入完成后，调用CompletedWriteRoutine
			(LPOVERLAPPED_COMPLETION_ROUTINE) CompletedWriteRoutine); 
	} 

	if (! fWrite) 
		// 出错，断开连接
		DisconnectAndClose(lpPipeInst); 
} 

/* ************************************
* VOID DisconnectAndClose(LPPIPEINST lpPipeInst) 
* 功能	断开一个连接的实例
* 参数	lpPipeInst，断开并关闭的实例句柄
**************************************/
VOID DisconnectAndClose(LPPIPEINST lpPipeInst) 
{ 
	// 关闭连接实例
	if (! DisconnectNamedPipe(lpPipeInst->hPipeInst) ) 
	{
		printf("DisconnectNamedPipe failed with %d.\n", GetLastError());
	}
	// 关闭 pipe 实例的句柄 
	CloseHandle(lpPipeInst->hPipeInst); 
	// 释放
	if (lpPipeInst != NULL) 
		HeapFree(GetProcessHeap(),0, lpPipeInst); 
} 

/* ************************************
* BOOL CreateAndConnectInstance(LPOVERLAPPED lpoOverlap)
* 功能	建立连接实例
* 参数	lpoOverlap，用于overlapped IO的结构
* 返回值	是否成功
**************************************/
BOOL CreateAndConnectInstance(LPOVERLAPPED lpoOverlap) 
{ 
	LPTSTR lpszPipename = TEXT("\\\\.\\pipe\\samplenamedpipe"); 
	// 创建named pipe	 
	hPipe = CreateNamedPipe( 
		lpszPipename,             // pipe 名 
		PIPE_ACCESS_DUPLEX |      // 可读可写
		FILE_FLAG_OVERLAPPED,     // overlapped 模式 
		// pipe模式
		PIPE_TYPE_MESSAGE |       // 消息类型 pipe 
		PIPE_READMODE_MESSAGE |   // 消息读模式 
		PIPE_WAIT,                // 阻塞模式
		PIPE_UNLIMITED_INSTANCES, // 无限制实例
		BUFSIZE*sizeof(TCHAR),    // 输出缓存大小
		BUFSIZE*sizeof(TCHAR),    // 输入缓存大小
		PIPE_TIMEOUT,             // 客户端超时
		NULL);                    // 默认安全属性
	if (hPipe == INVALID_HANDLE_VALUE) 
	{
		printf("CreateNamedPipe failed with %d.\n", GetLastError()); 
		return 0;
	}

	// 连接到新的客户端
	return ConnectToNewClient(hPipe, lpoOverlap); 
}

/* ************************************
* BOOL ConnectToNewClient(HANDLE hPipe, LPOVERLAPPED lpo)
* 功能	建立连接实例
* 参数	lpoOverlap，用于overlapped IO的结构
* 返回值	是否成功
**************************************/
BOOL ConnectToNewClient(HANDLE hPipe, LPOVERLAPPED lpo) 
{ 
	BOOL fConnected, fPendingIO = FALSE; 

	// 开始一个 overlapped 连接 
	fConnected = ConnectNamedPipe(hPipe, lpo); 

	if (fConnected) 
	{
		printf("ConnectNamedPipe failed with %d.\n", GetLastError()); 
		return 0;
	}
	switch (GetLastError()) 
	{ 
		// overlapped连接进行中. 
	case ERROR_IO_PENDING: 
		fPendingIO = TRUE; 
		break; 
		// 已经连接，因此Event未置位 
	case ERROR_PIPE_CONNECTED: 
		if (SetEvent(lpo->hEvent)) 
			break; 
		// error
	default: 
		{
			printf("ConnectNamedPipe failed with %d.\n", GetLastError());
			return 0;
		}
	} 
	return fPendingIO; 
}

// TODO根据客户端的请求，给出响应
VOID GetAnswerToRequest(LPPIPEINST pipe)
{
	_tprintf( TEXT("[%d] %s\n"), pipe->hPipeInst, pipe->chRequest);
	lstrcpyn( pipe->chReply,  TEXT("Default answer from server") ,BUFSIZE);
	pipe->cbToWrite = (lstrlen(pipe->chReply)+1)*sizeof(TCHAR);
}

基于visual c++之windows核心编程代码分析（17）通过pipe进程间通信

继续阅读

CQ V1.0分词bates(基于双数组tire树)—应该是目前最快的中文分词算法

windows不能在本地计算机上运行oracleDbConsoleorcl

成员函数初始化列表

2021-08-13c++——类之操作符重载

swmm与lisflood-fp源码如何一起编译 CMake命令

Windows下VS开发环境环境安装工程项目设置关于Debug和Release的提示

一文看懂字符串的加减乘除

Android – ListView 中添加按钮，动态删除添加ItemView的操作

C++ 第十五周报告1--《冒泡法排序》

C++实现简单顺序表

Windows下配置Apache的SSL服务

Mac｜Windows系统本地照片自动上传到服务器

C经典书籍笔记——C陷阱与缺陷②(语法陷阱之优先级)一、错误案列二、优先级规律

线性表之顺序表的实现

C++判断素数、求最大公约数代码判断一个数是否为素数求两个数的最大公约数

SequoiaDB巨杉数据库C++驱动概述