Windows下实现socketpair进行进程通信

前言：行动是治愈拖延的良药，现代人所谓的拖延症都是对自己懒惰的借口。
一直说要看看libevent源码，却又一直拖着忙着，不知道在忙些什么。我说在公司看着那一堆乱七八糟的源码都看下去了，为什么不能花点时间来研读下别人的优秀的源码呢？同学说那是因为在公司那是被动的，而这个是主动的，想想也挺有道理。。

这篇文章是看libevent的第一篇记录，libevent是基于信号来分发消息，对于信号的描述结构
 

typedef void (*ev_sighandler_t)(int);

/* Data structure for the default signal-handling implementation in signal.c
 */
struct evsig_info {
	/* Event watching ev_signal_pair[1] */
	struct event ev_signal;
	/* Socketpair used to send notifications from the signal handler */
	evutil_socket_t ev_signal_pair[2];
	/* True iff we've added the ev_signal event yet. */
	int ev_signal_added;
	/* Count of the number of signals we're currently watching. */
	int ev_n_signals_added;

	/* Array of previous signal handler objects before Libevent started
	 * messing with them.  Used to restore old signal handlers. */
#ifdef _EVENT_HAVE_SIGACTION
	struct sigaction **sh_old;
#else
	ev_sighandler_t **sh_old;
#endif
	/* Size of sh_old. */
	int sh_old_max;
};

其中里面有个成员变量 ev_signal_pair[2]; 在初始化时将它设为了一组连接着的socket。在linux下使用的是socketpair函数，

int socketpair(int d, int type, int protocol, int sv[2])；

而windows下没有这个函数，是手动实现的。这个socketpair的用途为

1. 这对套接字可以用于全双工通信，每一个套接字既可以读也可以写。例如，可以往sv[0]中写，从sv[1]中读；或者从sv[1]中写，从sv[0]中读； 
2. 如果往一个套接字(如sv[0])中写入后，再从该套接字读时会阻塞，只能在另一个套接字中(sv[1])上读成功； 
3. 读、写操作可以位于同一个进程，也可以分别位于不同的进程，如父子进程。如果是父子进程时，一般会功能分离，一个进程用来读，一个用来写。因为文件描述副sv[0]和sv[1]是进程共享的，所以读的进程要关闭写描述符, 反之，写的进程关闭读描述符。
借此博客的一张图https://www.cnblogs.com/big-xuyue/p/4098578.html

实现原理我还没有看到，此文主要说windows下socketpair的实现。
 

#include<WinSock2.h>
#include<Windows.h>
#pragma comment(lib,"ws2_32.lib")
#include<iostream>
using namespace std;

void EVUTIL_SET_SOCKET_ERROR(int code)
{
	cout<<"error code"<<code<<endl;
}
int evutil_ersatz_socketpair(int family, int type, int protocol, SOCKET fd[2])
{
	/* This code is originally from Tor.  Used with permission. */

	/* This socketpair does not work when localhost is down. So
	* it's really not the same thing at all. But it's close enough
	* for now, and really, when localhost is down sometimes, we
	* have other problems too.
	*/
#ifdef WIN32
#define ERR(e) WSA##e
#else
#define ERR(e) e
#endif
	SOCKET listener = -1;
	SOCKET connector = -1;
	SOCKET acceptor = -1;
	struct sockaddr_in listen_addr;
	struct sockaddr_in connect_addr;
	int size;
	int saved_errno = -1;

	if (protocol
		|| (family != AF_INET
#ifdef AF_UNIX
			&& family != AF_UNIX
#endif
			)) {
		EVUTIL_SET_SOCKET_ERROR(ERR(EAFNOSUPPORT));
		return -1;
	}
	if (!fd) {
		EVUTIL_SET_SOCKET_ERROR(ERR(EINVAL));
		return -1;
	}

	listener = socket(AF_INET, type, 0);
	if (listener < 0)
		return -1;
	memset(&listen_addr, 0, sizeof(listen_addr));
	listen_addr.sin_family = AF_INET;
	listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	listen_addr.sin_port = 0;	/* kernel chooses port.	 */
	if (bind(listener, (struct sockaddr *) &listen_addr, sizeof(listen_addr))
		== -1)
		goto tidy_up_and_fail;
	if (listen(listener, 1) == -1)
		goto tidy_up_and_fail;
	connector = socket(AF_INET, type, 0);
	if (connector < 0)
		goto tidy_up_and_fail;
	/* We want to find out the port number to connect to.  */
	size = sizeof(connect_addr);
	//获取监听地址
	if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -1)
		goto tidy_up_and_fail;
	if (size != sizeof(connect_addr))
		goto abort_tidy_up_and_fail;
	//connector连接到listener上
	if (connect(connector, (struct sockaddr *) &connect_addr,
		sizeof(connect_addr)) == -1)
		goto tidy_up_and_fail;

	size = sizeof(listen_addr);
	//listener接受连接，此时connector与acceptor是一对已连接的socket pair
	acceptor = accept(listener, (struct sockaddr *) &listen_addr, &size);
	if (acceptor < 0)
		goto tidy_up_and_fail;
	if (size != sizeof(listen_addr))
		goto abort_tidy_up_and_fail;
	/* 判断两个socket之间的地址，端口，协议是否相同	 */
	if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -1)
		goto tidy_up_and_fail;
	if (size != sizeof(connect_addr)
		|| listen_addr.sin_family != connect_addr.sin_family
		|| listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
		|| listen_addr.sin_port != connect_addr.sin_port)
		goto abort_tidy_up_and_fail;
	closesocket(listener);//不需要再监听了
	fd[0] = connector;
	fd[1] = acceptor;

	/**
	* 此时就已经创建了两个连接起来的socket，即可以实现进程间的通信
	*/
	return 0;

abort_tidy_up_and_fail:
	saved_errno = ERR(ECONNABORTED);
tidy_up_and_fail:
	if (saved_errno < 0)
		;//saved_errno = EVUTIL_SOCKET_ERROR();
	if (listener != -1)
		closesocket(listener);
	if (connector != -1)
		closesocket(connector);
	if (acceptor != -1)
		closesocket(acceptor);

	EVUTIL_SET_SOCKET_ERROR( saved_errno);
	return -1;
#undef ERR
}

int main() {
	WSADATA wsa;
	WSAStartup(MAKEWORD(2, 2), &wsa);
	SOCKET fd[2];
	if (evutil_ersatz_socketpair(AF_INET, SOCK_STREAM, 0, fd))
		goto end;

	char buf[1024] = { 0 };
	send(fd[0], "hello", 6, 0);
	
	int len = recv(fd[1], buf, 1024, 0);
	if (len)
	{
		buf[len] = '\0';
		cout << "收到" << buf << endl;
		
		strcat(buf, " word");
		int r=send(fd[0], buf, strlen(buf), 0);
		
	}
	char buf2[1024] = { 0 };
	len = recv(fd[1], buf2, 1024, 0);
	if (len)
	{
		buf2[len] = '\0';
		cout << "2收到" << buf2 << endl;
	}

end:
	system("pause");
	return 1;
}

代码中首先定义了一个listener来监听连接，然后有一个connecter去主动连接，然后调用accept后返回一个accepter，如果没有发生异常问题，那此时connecter与accepter是一组可以相互通信的socket。最后通过参数fd返回函数调用处实参。