参考

• Writing WebSocket servers
• The uwsgi Protocol

词汇

• peer，VPN中的节点，对于服务器而言包括自己的tuntap和每个客户端socket
• tuntap，Linux/Unix中创建的虚拟网卡，读取和写入数据和其它文件设备如socket、file差不多

实现

VPN的实现无非是客户端创建一个虚拟网卡tun/tap，从tun/tap中读取数据包，发送到服务端，服务端写入到它的tun/tap虚拟网卡中，从而让两端像是在同一个局域网内。发送数据无论是走UDP/TCP还是websocket，都只是为了转发虚拟网卡中接收到的数据包（以太包或者ip包）。

客户端与服务端的交互如下:

vpn-ws client <—HTTP/websocket—> Nginx <—uWSGI—> vpn-ws server

VPN-WS的客户端与Nginx Web交互，通过HTTP/HTTPS传送HTTP数据，而后Nginx通过uWSGI接口协议发送至应用服务即VPN-WS服务端。在完成了websocket的upgrade协商后，整个通路变成了websocket数据帧的转发通路。

用Nginx作前端的好处是，可以直接在现有的基于Nginx的服务上添加入口布置这个VPN服务器。客户端有重连机制，*但是只有一条连接到服务端，如果拿来翻墙，可就太弱了*。

服务端实现

创建tun/tap虚拟网卡

因为Linux视一切设备为File，所以其与file fd（文件句柄），与socket fd使用上没有区别。以此创建一个peer放到全局数组vpn_ws_conf.peers里。

tuntap_fd = vpn_ws_tuntap(vpn_ws_conf.tuntap_name);
vpn_ws_peer_create(event_queue, tuntap_fd, vpn_ws_conf.tuntap_mac);

void vpn_ws_peer_create(int queue, vpn_ws_fd client_fd, 
	uint8_t *mac) {

	vpn_ws_event_add_read(queue, client_fd)
	vpn_ws_peer *peer = vpn_ws_calloc(sizeof(vpn_ws_peer));
	peer->fd = client_fd;
	vpn_ws_conf.peers[client_fd] = peer;
	if (mac) {
			memcpy(peer->mac, mac, 6);
			peer->mac_collected = 1;
			//只有创建虚拟网卡时，peer的raw属性才置为1,这个值
			//决定了websocket数据包是直接转发还是还原成原始数据包再转发
			peer->handshake = 1;
			peer->raw = 1;
		}

创建服务端口，以接收客户端连接

server_fd = vpn_ws_bind(vpn_ws_conf.server_addr);
vpn_ws_event_add_read(event_queue, server_fd);

接收新客户端连接并分配一个peer节点

为走web socket而来的客户端创建的peer，其raw属性为0，也就是说从这个peer读取出的数据包非原始包（而是websocket数据帧格式）。而handshake属性也为0，则需要与服务端作协议认证交互后才能让这个peer正常使用，即接收和转发数据包。

int ret = vpn_ws_event_wait(event_queue, events);
for(int i=0;i<ret;i++) {
		int fd = vpn_ws_event_fd(events, i);
		if (fd == server_fd) {
			vpn_ws_peer_accept(event_queue, server_fd);
			continue;
		}
	
		if (vpn_ws_manage_fd(event_queue, fd)) break;
}

服务端添加一个peer到peer数组里:

void vpn_ws_peer_accept(int queue, int fd) {
	int client_fd = accept(fd, (struct sockaddr *) &s_un, &s_len);
	
	vpn_ws_peer *peer = vpn_ws_calloc(sizeof(vpn_ws_peer));
	peer->fd = client_fd;
	if (mac) {
		//只有虚拟网卡才会进这里
		memcpy(peer->mac, mac, 6);
		peer->mac_collected = 1;
		peer->handshake = 1;
		peer->raw = 1;
	}
	vpn_ws_conf.peers[client_fd] = peer;
}

处理每一个peer事件（发送数据或接收数据）

这里只解释读取的代码。读取部分，主要是做三件事:

1, 完成HTTP到websocket的协议升级协商。 
2, 读取websocket的数据帧。忽略掉其中一些ping/pong等无用类型数据。并解出里面的以太网帧格式的数据包
3, 跟据包的目标MAC地址，进行数据包转发。转发的目标peer在已登录了的所有的peer中查找。

1, 如参考文档所示，The WebSocket Handshake是请求web服务进行HTTP->Websocket协议升级的过程(其实跟HTTP->HTTP2的升级协商几乎是一样的)。因为Nginx与server是通过uWSGI交互的，所以这里HTTP请求头通过uWSGI的api解释出来的。

请求头除了标准的升级要求的字段，还有自定义字段HTTP_X_VPN_WS_MAC/HTTP_X_VPN_WS_BRIDGE，用来传送客户端peer的MAC地址和是不是bridge的属性:

#define HTTP_RESPONSE "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "

int64_t vpn_ws_handshake(int queue, vpn_ws_peer *peer) {
	ssize_t rlen = vpn_ws_uwsgi_parse(peer, &modifier1, &modifier2);
	
	char *ws_mac = vpn_ws_peer_get_var(peer,
		 "HTTP_X_VPN_WS_MAC", 
		 17, &ws_mac_len);
		 
	char *ws_bridge = vpn_ws_peer_get_var(peer,
		 "HTTP_X_VPN_WS_BRIDGE", 
		 20, &ws_bridge_len);
	
	… 
	int ret = vpn_ws_write(
		peer, 
		http_response, 
		sizeof(HTTP_RESPONSE)-1 + ws_accept_len + 4);

}

2, 如果来源peer是raw的（即tuntap/本地虚拟网卡)，直接将数据包读取出来就好了。如果这peer是raw的，那么就没有上面的第1步:

	if (peer->raw) {
		data = peer->buf;
		data_len = peer->pos;
		mac = data;
		ws_ret = data_len;
		goto parsed;
	}

不然就是远端的peer，那么还要解码websocket的数据帧格式，得到原始的以太网数据包：

int64_t vpn_ws_websocket_parse(vpn_ws_peer *peer, uint16_t *ws_header) {

	uint8_t byte1 = peer->buf[0];
	uint8_t opcode = byte1 & 0xf;
	uint64_t pktsize = byte2 & 0x7f;
	…
	
		switch(opcode) {
		case 0:
		case 1:
		case 2:
			return needed + pktsize;
		case 8:
			return -1;
		case 9:
		case 10:
			*ws_header = 0;
			return needed + pktsize;
		default:
			return -1;
	}
}

这段代码主要是解释头部格式，找出Payload在websocket数据包中的范围。跟据RFC文档，websocket数据帧里的opcode取值如下，注意binary frame和ping/pong的处理就行了:

*  %x0 denotes a continuation frame
*  %x1 denotes a text frame
*  %x2 denotes a binary frame
*  %x3-7 are reserved for further non-control frames
*  %x8 denotes a connection close
*  %x9 denotes a ping
*  %xA denotes a pong
*  %xB-F are reserved for further control frames

综上，第1和2步旨在解释出以太网数据包，代码简要如下:

int vpn_ws_manage_fd(int queue, vpn_ws_fd fd) {
	int ret = vpn_ws_read(peer, 8192);
		
	if (!peer->handshake) {
		int64_t hret = vpn_ws_handshake(queue, peer);
	}
	
	ws_ret = vpn_ws_websocket_parse(peer, &ws_header);
	uint8_t *ws = peer->buf + ws_header;
	uint64_t ws_len = ws_ret - ws_header;
	// 用以整个websocket包进行转发
	data = peer->buf;
	data_len = ws_ret;

3, 转发非多播目标MAC地址的数据包 目标MAC地址是某个peer的MAC地址或者其bridge下的某个MAC:

	if (b_peer->raw && !peer->raw) {
	  //从远程节点的websocket中取数据包写入到虚拟网卡
		wret = vpn_ws_write(
			b_peer, 
			peer->buf+ws_header, 
			ws_ret-ws_header);
	}
	else if (!b_peer->raw && peer->raw) {
	  //从虚拟网卡写入到远程节点websocket
		wret = vpn_ws_write_websocket(
			b_peer, 
			data, 
			data_len);
	}
	else {
		//这里只可能有一种情况即 !b_peer->raw && !peer->raw成立
		//也就是从远程节点转发到另一个远程节点，所以保持整个websocket包进行转发
		wret = vpn_ws_write(b_peer, data, data_len);
	}

客户端实现

1, 创建tun/tap设备，

	vpn_ws_fd tuntap_fd = 
		vpn_ws_tuntap(vpn_ws_conf.tuntap_name);

2, 创建连接至Nginx Web端

int main(){
	vpn_ws_fd tuntap_fd = vpn_ws_tuntap(vpn_ws_conf.tuntap_name);
	vpn_ws_nb(tuntap_fd);
	peer = vpn_ws_calloc(sizeof(vpn_ws_peer));
	memcpy(peer->mac, vpn_ws_conf.tuntap_mac, 6);
	
	if (vpn_ws_connect(peer, vpn_ws_conf.server_addr)) {
			vpn_ws_client_destroy(peer);
			goto reconnect;
	}
	
	…
}

发送HTTP请求进行websocket升级协商。如果使用HTTPS，那么在此前还有SSL的握手:

int vpn_ws_connect(vpn_ws_peer *peer, char *name) {
	if (!strncmp(cpy, "wss://", 6)) {
		ssl = 1;
		port = 443;
	}
	
	struct hostent *he = gethostbyname(domain);
	…
	
	if (connect(peer->fd, 
		(struct sockaddr *) &sin, 
		sizeof(struct sockaddr_in))) {
		
		vpn_ws_error("vpn_ws_connect()/connect()");
		return -1;
	}
	
	int ret = snprintf(buf, 8192, 
	"GET /%s HTTP/1.1\r\nHost: %s%s%s\r\n%sUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: %.*s\r\nX-vpn-ws-MAC: %02x:%02x:%02x:%02x:%02x:%02x%s\r\n\r\n",
	)
	
	if (ssl) {
		vpn_ws_conf.ssl_ctx = vpn_ws_ssl_handshake(
			peer, 
			domain, 
			vpn_ws_conf.ssl_key, 
			vpn_ws_conf.ssl_crt);
		
		if (!vpn_ws_conf.ssl_ctx) {
			return -1;
		}
		if (vpn_ws_ssl_write(vpn_ws_conf.ssl_ctx,
		 (uint8_t *)buf, ret)) {
			return -1;
		}
	}
	
	…

等待websocket升级协商回应:

int http_code = vpn_ws_wait_101(
	peer->fd, 
	vpn_ws_conf.ssl_ctx);

if (http_code != 101) {
		vpn_ws_log("error, 
		websocket handshake returned code: %d\n", 
		http_code);
		
		return -1;
	}

3, 读事件的响应。 每个客户端要监听的是tuntap和peer到服务端的连接socket这两个fd，接收前者的以太网格式数据包封装成websocket包转发到后者，接收后者的websocket数据包解码成以太网数据包后转发到前者。

这里的17秒超时设置是为了超时后会发送一个ping包，即每17秒一个ping包的保证。ping包为\x89\x00，这里websocket的数据帧格式，表示FIN=1，opcode=9(PING类型)，HAS_MASK=0，Payload length=0:

for(;;) {

	FD_ZERO(&rset);
	FD_SET(peer->fd, &rset);
	FD_SET(tuntap_fd, &rset);
	tv.tv_sec = 17;
	tv.tv_usec = 0;
	int ret = select(max_fd, &rset, NULL, NULL, &tv);
	
	if (ret == 0) {
		// 超时
		if (vpn_ws_client_write(peer, 
			(uint8_t *) "\x89\x00", 2)) {
				vpn_ws_client_destroy(peer);
				goto reconnect;
		}	
		continue;
	}

	…

处理远端来的websocket数据包，即写入本地的tuntap设备:

	if (FD_ISSET(peer->fd, &rset)) {
		if (vpn_ws_client_read(peer, 8192)) {
			vpn_ws_client_destroy(peer);
			goto reconnect;
		}
		int64_t rlen = vpn_ws_websocket_parse(
			peer, 
			&ws_header);
			
		uint8_t *ws = peer->buf + ws_header;
		uint64_t ws_len = rlen - ws_header;
		if (peer->has_mask) {
			//XOR解密…
		}
		
		vpn_ws_full_write(tuntap_fd, ws, ws_len)
	}			

转发来自tuntap的以太网数据包以websocket格式封装后转发到服务器:

	if (FD_ISSET(tuntap_fd, &rset)) {
		vpn_ws_recv(tuntap_fd, mtu+8, 1500, rlen);
		…
		vpn_ws_client_write(peer, mtu, rlen + 8)
	}

代码不严谨/不妥的地方

C语言直是一门可怕的语言，拿C语言写出大工程更不容易。心疼C语言超弱的表达能力:字符串操作还要自己写，字符串拷贝还要自己写，还要小心什么时候应该释放掉。缺乏面向对象和结构体的权限限制。

本项目代码存在的一些问题：

• 低效的重分配内存。没有内存池复用，只使用了C的realloc，会有频繁的分配内存和内存拷贝（这里又没有对write_buf的收缩，网络状态不好时只能一直涨大下去)

uint64_t available = peer->write_len - peer->write_pos;
	if (available < amount) {
		peer->write_len += amount;
		void *tmp = realloc(peer->write_buf, 
				peer->write_len);

• 可能会指针越界的字符串拷贝（几处地方，一下子找不到了）
• websocket的代码没有封装，客户端和服务端代码都把websocket的组包和解包的逻辑（尤其是XOR解密MASK的数据）全放入发包的地方，可读性差
• 没有客户端认证机制？看起来是是个客户端就能连上服务端
• 缺少合理的封装。比如MAC地址及相关方法。比如vpn_ws_peer这个结构太多成员而且很多不相关，可以封装更多子结构。
• 客户端与服务端的主循环代码太长，还使用了好多goto，每一个IO调用都要有不同返回值表示出了什么情况，也就是0,小于0,大于0的三种路经，整体逻辑复杂。