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

最新推荐文章于 2023-06-13 09:29:17 发布
最新推荐文章于 2023-06-13 09:29:17 发布
阅读量3.5k 收藏 4
点赞数 3
分类专栏： Visual C++2010编程技术 Windows8 VC++编程技术 Visual Studio2012 信息安全 WindowsC++编程 文章标签： 代码分析 windows c++ 编程 winapi null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itcastcpp/article/details/7079696
版权

管道是一种用于在进程间共享数据的机制，其实质是一段共享内存。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);
}


 

尹成
关注
专栏目录
nmm.zip_Windows编程_Visual_C++_
08-11
通过学习这些示例代码，开发者可以深入理解Windows编程的基础，如窗口管理、进程间通信等，并掌握如何使用Visual C++来实现这些功能。这对于想要提升Windows应用开发技能的程序员来说是一份宝贵的资源。
【小沐学C++】C++实现进程通信（管道pipe）
热门推荐
爱看书的小沐
12-03 1万+
本节内容1、功能简介1.1 匿名管道1.2 命名管道2、匿名管道3、命名管道3.1 注意事项3.2 服务器3.2 客户端后记 1、功能简介 管道用于进程间共享数据，其实质是共享内存，常用IPC之一。管道不仅可以用于本机进程间通信，还可实现跨网络进程间通信，如同Socket通信，管道同样封装计算机底层网络实现，提供一个良好的API接口。 管道（Pipe）实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。一个进程在向管道写入数据后，另一进程就可以从管道的另一端
Windows下C++ 使用有名管道实现进程间通信范例
a1534219218的博客
02-18 1783
本实例为了展示，使用有名管道的方法，实现进行间的消息传递。 实现须知： 1. 两个对象，服务器和客户端； 2. 有名管道需要创建的文件路径及文件名； 3. 有名管道的创建方法及消息发送机制； 具体事例如下： 服务器代码： #include<windows.h> //包含头文件 #include<stdio.h> int main() {...
使用C++将守护进程和主进程设计成windows服务，并使用命名管道进行通讯
qq_28107929的博客
12-04 935
由于项目需求，需要设计一个守护进程来守护主进程。 守护进程的实现方式： 1. 设计成进程 2. 设计成服务 因为希望主服务随windows开机启动即启动，所以将守护进程和主进程设计成windows服务。 守护服务于主服务间的通讯方式： 1. socket 2. 管道（分为匿名管道和命名管道） 3. WM_COPYDATA消息 　　WM_COPYDATA是一种非常强大却鲜为人知的消息。当一个应用向另...
C++ 命名管道 IPC
白话机器学习
05-02 2027
技术：IPC，RPC，Windows General 主题：Named Pipe，Inter-process Communication 概要： 命名管道是一种进程间单工或双工的通信机制。它可以在管道服务器和一个或多个管道客户端间进行。客户端可以位于本机或互联网上的远程计算机。 PIPE_ACCESS_INBOUND（呼入）： Client (GENERIC_WRITE) ---> Se
C/C++开发，win下命名管道通信压力测试实现（含c++示例代码）
技术需要分享
09-11 1315
win下命名管道通信压力测试实现，利用win c++标准函数CreateNamedPipe、ConnectNamedPipe、WriteFile、ReadFile、CloseHandle等创建、连接、使用、关闭的管道操作函数，本测试中，同时有300百个线程对管道进行数据写入及读取操作，测试完成10万次数据写入及读取操作，以实现本地系统进程间通信压力测试。
pipe.rar_进程与线程_Visual_C++_
08-11
总结，"pipe.rar_进程与线程_Visual_C++_"这个资源提供了丰富的实践案例，涵盖了Windows编程中重要的进程间通信和多线程技术。通过深入学习和实践这些示例，开发者可以巩固理论知识，提高在Visual C++环境下的编程...
process.rar_通讯编程文档_Visual_C++_
08-12
"进程.txt"文件可能详细阐述了在Visual C++中如何创建和管理进程，以及如何实现上述的进程间通信方法。通过深入学习这份文档，开发者将能够更好地在Visual C++环境中进行多进程编程，解决复杂系统的设计和实现问题。
ConsoleToPipeTest.rar_系统编程_Visual_C++_
08-11
在这个项目中，开发者可能使用了标准C++库，以及可能的Windows API函数，如CreateProcess和CreatePipe，来实现调用DOS命令和管理进程间通信。 创建这样的程序通常包括以下步骤： 1. **创建管道**：使用CreatePipe...
kkk.rar_visual c_进程通信
09-21
在Windows操作系统中，`GetMessage`和`PostMessage`是窗口消息处理函数，用于进程间通信（IPC，Inter-Process Communication）。这两个函数是Windows消息机制的核心，通过它们，一个进程可以向另一个进程发送消息，...
滴水逆向三期15611 进程通信 项目练习
四位的博客
01-10 1842
进程通信联系概要步骤进程通信为什么要进程通信命名管道dll 无模块注入为什么必须是dllshellcode 注入模块注入shellcode 部分Extract代码 概要 最终效果 创建进程通信 通信测试 IATHOOK 剪切板内容 inlineHook 创建进程 文章分如下几部分 步骤 进程通信 dll注入 问题总结 本篇文章不是一个实现过程, 而是一个关于这个项目的一个总结, 包含了比较多外链, 帮助更好的理解. 步骤 实现进程通信 无模块注入dll hook 进程通信
进程间通信(匿名管道)pipe函数
m0_63089723的博客
03-05 522
1.进程间通信简单来说就是让两个或者两个以上的进程能够相互交换数据 2.一般的进程是独立的,一个进程的PCB(struct task_struct结构体)也叫进程控制块里只保存了本进程的信息,虚拟地址空间通过页表映射的物理内存也是只有自己通过操作系统能访问到,他只是能访问到,他自己是不知道数据存储在物理内存的什么位置.而操作系统只会让他访问到属于他自己的空间,不会让他访问到别的进程所保存的数据的地方. 3.为了让进程之间能交流,就有了管道,下面是有关管道的介绍 1.管道符号 | ; 管道的本质是
操作系统，创建两个子进程用pipe通道与父进程通信，用lockf加锁
m0_59834108的博客
11-16 706
如有错误欢迎指正 父进程创建单个进程并通信的例子： fork()+pipe() --&gt; 父子进程间通过管道通信_薰衣草PK向日葵的博客-CSDN博客_父子进程管道通信 父进程创建两个子进程并通信的例子： 管道通信(操作系统课程设计) - 豆丁网 (docin.com) 在多端写入时用lockf加锁 用四个进程公用一个管道，2读2写 ...
NamedPipe，利用IOCP实现命名管道异步通信
alpbrook的专栏
01-29 4535
微软提供了利用回调函数来实现有名管道的示例：Named Pipe Server Using Completion Routines. 该示例使用了ReadFileEx和WriteFileEx函数来进行有名管道的异步读写操作。我们在该示例的基础上进行改写来实现通过IOCP来进行异步读写。主要改动在哪下几个方面： 1.删去 CreateEvent操作，改为CreateIoCompletion
关于windows异步命名管道通信的一些记录
最新发布
youyudexiaowangzi的专栏
06-13 465
要注意CreateEvent的第二个参数bManualReset：是否手动重置事件，一般手动设置的事件需要在事件触发后自行reset，是event处于无信号状态，如果是自动设置的事件，事件触发后，所有的wait结束后会自行变为无信号状态。客户端使用CreateFile打开命名管道，使用ReadFileEx和WriteFileEx进行管道的读写，经过测试，可以不用给overlap的hevent初始化，只需要有wait函数，读写完成后就能触发完成回调函数。分为服务端和客户端，参考。
IPC之命名管道
weixin_34143774的博客
03-11 132
1.管道是通过IO接口存取得字节流， windows中利用得是ReadFile()和WriteFile(),windows利用单一句柄支持双向IO,命名管道也称做FIFO(first in first out)命名管道得机制：一个进程把数据放到管道里，另一个知道管道名字得进程把数据把取走，实际是用于进程间通信得一段共享内存，创建管道得进程称为管道服务器，链接到一个管道得进程为管道客户机，用以下函数...
Windows进程间通信—命名管道
错位竞争，单点突破。
04-05 3414
命名管道是通过网络来完成进程间的通信，它屏蔽了底层的网络协议细节。我们在不了解网络协议的情况下，也可以利用命名管道来实现进程间的通信。与Socket网络通信相比，命名管道不再需要编写身份验证的代码。将命名管道作为一种网络编程方案时，它实际上建立了一个C/S通信体系，并在其中可靠的传输数据。命名管道服务器和客户机的区别在于：服务器是唯一一个有权创建命名管道的进程，也只有它能接受管道客户机的连接请求。
管道通信相关知识总结
Yvan Jiang的专栏
06-28 653
管道 概念 管道是进程间通信使用的一种共享内存的方式，创建管道的进程称为管道服务器，连接管道的进程成为管道客户端。进程间通过管道方式，一个进程往管道写入数据，另一个进程从管道取数据，类似socket通信从buf缓冲区读写数据，管道操作也类似文件读写。管道分为匿名管道和命名管道，文中主要介绍命名管道操作。 匿名管道 匿名管道，没有名称，而且是单工模式，就是两个进程只能一个进程往管道写入数据，另一个进程往管道区数据，而且匿名管道只能使用在父进程与子进程之间，因此如果想要在局域网内使用管道通信，不能使用匿名管道。
Windows平台下的Visual C++编程示例代码
- 样例代码是学习编程非常重要的工具，通过分析和修改样例代码，可以加深对Windows编程概念的理解。 - 样例代码能够展示如何使用Visual C++和Windows API实现具体功能，例如创建窗口、响应事件、绘制图形等。 - ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

尹成

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值