websocket协议与实现原理

2023-11-13

文章目录

一、websocket
二、websocket的协议实现

一、websocket

websocket是一个基于tcp的应用层的协议，对tcp的包做了一些限制，websocket只对协议的格式做了规定，不管你发送了什么，只要符合数据格式就可以了，里面是否有get或者post请求websocket压根儿不管，比http协议更加的宽泛更加松散。
websocket除了连接当中有一次握手需要确定数据的内容，其实就跟我们的自定义协议是一个意思。
在什么场景下我们需要自定义协议呢
即时通信login，register，添加好友，消息转发，这些当然http协议也可以做这些，但是传输数据加了http的头，在消息数据量小的情况下，消息利用率上不大，所以我们需要一些自定义的协议
自定义协议有两部分组成
tcp包本身的信息，业务协议，有的协议可能会有版本号
网页实时消息的更新用的就是websocket，比如说用微信扫码登录的过程，浏览器与服务器之间实时通信，就用的webserver就是实现的http的协议。

<html>
<head>
    <script>
        let ws;

        function doConnect(addr) {
            ws = new WebSocket("ws://" + addr);//这个ws是协议类型
            ws.onopen = () => {
                document.getElementById("log").value += (" Connection 
                .........

二、websocket的协议实现

websocket的协议格式

一共两种
一种是http的明文
另一种是，建立连接后，第一个数据包是符合http协议头，叫handshark（握手数据），后边的数据的数据格式不一定符合http的格式。
先看实现，引入状态机的概念
websocket协议头，三部分组成
从FIN到opcode叫操作码，从PayLoad len到Extend payload length表示这个包总共有多长，第三部分就是那个Masking-key,表示到底是传输明文还是传输密文，如果是传输明文，MASK也就是8位那个会置0，如果是密文，会置1，就用MASK的值与Payload data做处理
这个长度也有三种情况
PayLoad len如果小于7个字节的时候（125），这7个位能够表示出来，如果是126的时候，那么就是7个字节加上，Extended payload length这一段，如果大于7个字节再加上这16位，后面还有空白部分的8个字节，一共3种情况
在这里插入图片描述

websocket如何验证客户端合法

我们可以去参考一下，《websocket_rfc6455》这份文档上写的内容，我们翻到第6页
openningshake旨在与基于HTTP的握手兼容服务器端软件和中介，因此可以使用单个端口由与该服务器和WebSocket对话的HTTP客户端使用与服务器对话的客户。为此，WebSocket客户端的握手是一种HTTP升级请求：
在这里插入图片描述为了证明这次握手被接收了，服务端将两次握手信息片段，组合起来形成响应。第一个这条信息来自| Sec WebSocket Key | 在客户端握手中header字段：
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==

对于此标头字段，服务器必须获取值（如标头字段中存在的值，例如base64编码的[RFC4648]版本减去任何前导和尾随空格），并将其与全局唯一标识符（GUID，[RFC4122]）258EAFA5-E914-47DA-95CA-C5AB0DC85B11“字符串形式，不理解WebSocket协议的网络端点不太可能使用。然后在服务器的握手中返回此串联的SHA-1哈希（160位）[FIPS.180-3]，base64编码（参见[RFC4648]第4节）。

具体地说，如果像上面的例子一样，|Sec WebSocket Key | header字段的值为“dghlihnhbxbssbub25jzq==”，则服务器将串接字符串“258EAFA5-E914-47DA-95CA-C5AB0DC85B11”以形成字符串“DGHLIHNHBXBSSBUB25JZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11”。
然后，服务器将获取该文件的SHA-1hash，给出值0xb3 0x7a 0x4f 0x2c 0xc0 0x62 0x4f 0x16 0x90 0xf6 0x46 0x06 0xcf 0x38 0x59 0x45 0xb2 0xbe 0xc4 0xea。然后对该值进行base64编码（参见[RFC4648]第4节），以给出该值“s3pplmbitxaq9kygzhzrbk+xOo=”。然后，该值将在| Sec WebSocket Accept | header field。
以上是原文的翻译，意思是这样的
客户端发送请求给服务器，服务器返回消息，如果消息合法，经过客户端验证ok就行了，那怎么验证呢，就是上边的Sec-WebSocket-Key，拿到Sec-WebSocket-Key这个值以后，跟一个GUID，"258EAFA5-E914-47DA-95CA-C5AB0DC85B11"组织成这样一个字符串"DGHLIHNHBXBSSBUB25JZQ ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11"然后对其做一个hash映射，得到这样一组值0xb3 0x7a 0x4f 0x2c 0xc0 0x62 0x4f 0x16 0x90 0xf6 0x46 0x06 0xcf 0x38 0x59 0x45 0xb2 0xbe 0xc4 0xea，然后对这个值做一个base64的编码"s3pplmbitxaq9kygzhzrbk+xOo="然后把这个值返回给客户端
在这里插入图片描述
也就是说我们的握手的功能，主要是以下这三个步骤需要去做

websocket传输的明文和密文的传输

在运行这个程序的时候，我们可以看到输出的时候会有密文
在这里插入图片描述
那怎么传输的密文呢
MASK置为1，就是个掩住的码，我们看到5.3

在这里插入图片描述这里给出了一个公式，这个公式是什么意思呢
payload[length];
mask_key[4];
payload[i] = payload[i]^mask_key[i%4];
这个掩码就是通过这个公式传的
MASK这一位，置为1，就拿着这个mask_key跟payload异或操作

如何进行解码呢，就用umask函数去操作，后边如果是密文，就用这个函数去解

void umask(char *payload, int length, char *mask_key) {//解码
	int i = 0;
	for (i = 0;i < length;i ++) {
		payload[i] ^= mask_key[i%4];//异或成掩码后，再次异或就可以解码
	}
}

我们这边发送“nihao”以后，不在是掩码了
在这里插入图片描述

websocket如何断开

通过websocket协议头的fin这个位可以断开
那么客户端调用close可以断开，为什么websocket还要留出一个fin位来断开呢
在这里插入图片描述
websocket 是在 tcp 协议基础上扩展的通信协议，所以支持双向通信。客户端直接调用close方法并不会关闭连接，而是发送请求到服务器请求对方。服务器接收请求后可以断开连接。这会触发客户端的close事件。当然，在断开之前也可以发送个同样的断连请求，并包含状态码和原因描述。

实现

#define GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"//老外定义的GUID
enum {
	WS_HANDSHARK = 0,
	WS_TRANMISSION = 1,
	WS_END = 2,
};//定义三个状态
typedef struct _ws_ophdr {//协议头定义
	
	unsigned char opcode:4,
				  rsv3:1,
				  rsv2:1,
				  rsv1:1,
				  fin:1;
	unsigned char pl_len:7,
				  mask:1;
} ws_ophdr;

struct ntyevent {
	int fd;
	int events;
	void *arg;
	int (*callback)(int fd, int events, void *arg);
	
	int status;
	char buffer[BUFFER_LENGTH];
	int length;
	long last_active;

	int status_machine; //状态机
};
int base64_encode(char *in_str, int in_len, char *out_str) {    
	BIO *b64, *bio;    
	BUF_MEM *bptr = NULL;    
	size_t size = 0;    

	if (in_str == NULL || out_str == NULL)        
		return -1;    

	b64 = BIO_new(BIO_f_base64());    
	bio = BIO_new(BIO_s_mem());    
	bio = BIO_push(b64, bio);
	
	BIO_write(bio, in_str, in_len);    
	BIO_flush(bio);    

	BIO_get_mem_ptr(bio, &bptr);    
	memcpy(out_str, bptr->data, bptr->length);    
	out_str[bptr->length-1] = '\0';    
	size = bptr->length;    

	BIO_free_all(bio);    
	return size;
}
void nty_event_set(struct ntyevent *ev, int fd, NCALLBACK callback, void *arg) {

	ev->fd = fd;
	ev->callback = callback;
	ev->events = 0;
	ev->arg = arg;
	ev->last_active = time(NULL);
	
	//ev->status_machine = WS_HANDSHARK;//在建立连接后
	return ;
	
}
int readline(char *allbuf, int idx, char *linebuf) {
	int len = strlen(allbuf);
	for(;idx < len;idx ++) {
		if (allbuf[idx] == '\r' && allbuf[idx+1] == '\n') {
			return idx+2;
		} else {
			*(linebuf++) = allbuf[idx];
		}
	}
	return -1;
}
#define WEBSOCK_KEY_LENGTH 19
int handshark(struct ntyevent *ev) {

	//ev->buffer , ev->length

	char linebuf[1024] = {0};//key
	int idx = 0;
	char sec_data[128] = {0};
	char sec_accept[32] = {0};

	do {
		memset(linebuf, 0, 1024);
		idx = readline(ev->buffer, idx, linebuf);//读一行，返回下一行的开始位置，如果读完了
		if (strstr(linebuf, "Sec-WebSocket-Key")) {//判断key
			//协议当中出现的下面一行是非常标准的
			//linebuf: Sec-WebSocket-Key: QWz1vB/77j8J8JcT/qtiLQ==
			strcat(linebuf, GUID);//将key与GUID结合在一起
			//linebuf: 
			//Sec-WebSocket-Key: QWz1vB/77j8J8JcT/qtiLQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11
			SHA1(linebuf + WEBSOCK_KEY_LENGTH, strlen(linebuf + WEBSOCK_KEY_LENGTH), sec_data); // openssl库里边的函数，哈希映射
			base64_encode(sec_data, strlen(sec_data), sec_accept);
			memset(ev->buffer, 0, BUFFER_LENGTH); //清空buffer
			ev->length = sprintf(ev->buffer, "HTTP/1.1 101 Switching Protocols\r\n"
					"Upgrade: websocket\r\n"
					"Connection: Upgrade\r\n"
					"Sec-WebSocket-Accept: %s\r\n\r\n", sec_accept);
			printf("ws response : %s\n", ev->buffer);
			break;
		}

	} while((ev->buffer[idx] != '\r' || ev->buffer[idx+1] != '\n') && idx != -1 );//循环读完每一行

	return 0;
}
void umask(char *payload, int length, char *mask_key) {//解码

	int i = 0;
	for (i = 0;i < length;i ++) {
		payload[i] ^= mask_key[i%4];
	}

}
int transmission(struct ntyevent *ev) {

	//ev->buffer; ev->length
	ws_ophdr *hdr = (ws_ophdr*)ev->buffer;
	printf("length: %d\n", hdr->pl_len);
	if (hdr->pl_len < 126) { //Payload小于126的时候
		unsigned char *payload = ev->buffer + sizeof(ws_ophdr) + 4; // 6  payload length < 126
		if (hdr->mask) { // mask set 1，如果是密文
			umask(payload, hdr->pl_len, ev->buffer+2);
		}
		printf("payload : %s\n", payload);
	} else if (hdr->pl_len == 126) {//如果等于126
		ws_head_126 *hdr126 = ev->buffer + sizeof(ws_ophdr);
	} else {
		ws_head_127 *hdr127 = ev->buffer + sizeof(ws_ophdr);
	}
}
int websocket_request(struct ntyevent *ev) {

	if (ev->status_machine == WS_HANDSHARK) {//在握手的时候
		ev->status_machine = WS_TRANMISSION;
		handshark(ev);// 
	} else if (ev->status_machine == WS_TRANMISSION) {//
		transmission(ev);
	} else {
	
	}

	printf("websocket_request --> %d\n", ev->status_machine);
	
}

int recv_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);
	int len = recv(fd, ev->buffer, BUFFER_LENGTH , 0); // 
	
	if (len > 0) {
		ev->length = len;
		ev->buffer[len] = '\0';

		printf("C[%d]: machine: %d\n", fd, ev->status_machine);

		websocket_request(ev);

		nty_event_del(reactor->epfd, ev);
		nty_event_set(ev, fd, send_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLOUT, ev);
		
	} else if (len == 0) {

		nty_event_del(reactor->epfd, ev);//连接断开后，先从epoll里边移除然后再close，在连接时先创键socket然后再添加
		close(ev->fd);
		
		//printf("[fd=%d] pos[%ld], closed\n", fd, ev-reactor->events);
		 
	} else {

		nty_event_del(reactor->epfd, ev);
		close(ev->fd);
		printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
		
	}

	return len;
}
int accept_cb(int fd, int events, void *arg) {
	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	if (reactor == NULL) return -1;
	struct sockaddr_in client_addr;
	socklen_t len = sizeof(client_addr);
	int clientfd;

	if ((clientfd = accept(fd, (struct sockaddr*)&client_addr, &len)) == -1) {
		if (errno != EAGAIN && errno != EINTR) {
			
		}
		printf("accept: %s\n", strerror(errno));
		return -1;
	}
	int flag = 0;
	if ((flag = fcntl(clientfd, F_SETFL, O_NONBLOCK)) < 0) {
		printf("%s: fcntl nonblocking failed, %d\n", __func__, MAX_EPOLL_EVENTS);
		return -1;
	}

	struct ntyevent *event = ntyreactor_idx(reactor, clientfd);
	event->status_machine = WS_HANDSHARK;//在这里初始化
	nty_event_set(event, clientfd, recv_cb, reactor);
	nty_event_add(reactor->epfd, EPOLLIN, event);
	
	
	printf("new connect [%s:%d], pos[%d]\n", 
		inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), clientfd);

	return 0;

}

最后实现效果，输出协议格式，以及返回的消息
在这里插入图片描述

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)