连接世界的纽带：掌握Linux网络设计中的WebSocket服务器
【摘要】 本文探索了在Linux环境下实现WebSocket服务器的网络设计，将WebSocket服务器作为连接世界的纽带，为读者介绍了如何掌握Linux网络设计中的关键技术。文章从实现WebSocket协议到优化服务器性能和稳定性等方面进行了深入讲解。通过学习本文，读者将能够全面了解WebSocket服务器的原理和工作机制，并获得构建高效、可靠的Linux WebSocket服务器的实用技巧和最佳实践。
websocket描述
websocket是在单个TCP连接上进行全双工通信的协议，允许Server主动向Client推送数据。
客户端和服务器只需要完成一次握手，就可以创建持久性的连接，进行双向数据传输。
websocket是独立的，作用在TCP上的协议。
为了向前兼容， WebSocket 协议使用 HTTP Upgrade 协议升级机制来进行 WebSocket 握手, 当握手完成之后, 客户端和服务端就可以依据WebSocket 协议的规范格式进行数据传输。
websocket相对HTTP协议的优点
1、支持双向通信，数据的实时性更新更强。
2、开销小；客户端和服务端进行数据通信时，websocket的header（数据头）较小。服务端到客户端的header只有2~10 Bytes，客户端到服务端的需要加上额外的4 Bytes的masking-key。而HTTP协议每次通信都需要携带完整的数据头。
3、扩展性。
4、二进制数据支持更好。
websocket的应用场景
从websocket的优点可以知道，主要应用场景有：
1、视频弹幕
2、媒体即时通讯
3、需要实时位置/数据的应用
5、金融行业的股票基金价格实时更新
等。
websocket握手
1、客户端：Upgrade（申请升级到websocket协议）
协议包含两个部分：握手和数据传输。WebSocket复用了HTTP的握手通道。
客户端通过HTTP请求与WebSocket服务端协商升级到websocket协议。协议升级完成后，后续的数据传输按照WebSocket的data frame进行。
WebSocket 握手采用 HTTP Upgrade 机制，使用标准的HTTP报文格式，只支持使用HTTP的GET方法，客户端发送如下所示的结构发起握手：
GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin: http://fly.example.com
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13
说明：
| 参数 | 值 | 含义 |
|---|---|---|
| Upgrade: | websocket | 升级到websocket协议 |
| Connection: | Upgrade | 升级协议 |
| Sec-WebSocket-Key: | (key value) | 与服务端响应的sec-websocket-accept对应，提供安全防护 |
| Sec-WebSocket-Version: | 13 | 指示websocket的版本 |
2、服务器：响应协议升级
服务端如果支持 WebSocket 协议，则返回 101 的 HTTP 状态码。返回如下所示的结构:
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Protocol: chat
Sec-WebSocket-Version: 13
参数说明：
| 参数 | 说明 |
|---|---|
| Sec-WebSocket-Accept | 必须有，与客户端的Sec-WebSocket-Key对应 |
| Sec-WebSocket-Version | 必须有, 返回服务端和客户端都支持的 WebSocket 协议版本。如果服务端不支持客户端的协议版本则立即终止握手, 并返回 HTTP 426 状态码，同时设置 Sec-WebSocket-Version 说明服务端支持的 WebSocket 协议版本列表 |
| Sec-WebSocket-Protocol | 可选, 是否支持 WebSocket 子协议 |
| Sec-WebSocket-Extensions | 可选, 是否支持拓展列表 |
注意：每个HTTP的header都以\r\n结尾，并且最后一行要加上一个额外的\r\n。这是由于http协议制定的时候，就是用分隔符进行分包。
3、Sec-WebSocket-Accept值的计算
客户端发起握手时通过 Sec-WebSocket-Key 传递了一个安全防护字符串，服务端将该值与 WebSocket 魔数 “258EAFA5-E914-47DA- 95CA-C5AB0DC85B11” 进行字符串拼接，将得到的字符串做 SHA-1 哈希, 将得到的哈希值再做 base64 编码，最后得到的值就是Sec-WebSocket-Accept值。
计算公式为：
（1）将Sec-WebSocket-Key的值与258EAFA5-E914-47DA-95CA-C5AB0DC85B11魔数进行字符串拼接；
（2）使用SHA1对拼接的字符串做哈希，得到一个哈希值；
（3）将哈希值做base64编码得到Sec-WebSocket-Accept值。
伪代码：
//......
// 字符串拼接
char *str=Sec-WebSocket-Key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
// 计算sha1哈希
char sec_data[64];
SHA1(str,strlen(str),sec_data);
// 编码成base64
char sec_accept[64];
base64_encode(sec_data,strlen(sec_data),sec_accept);
//......
base64_encode函数实现：
#include <openssl/sha.h>
#include <openssl/pem.h>
#include <openssl/bio.h>
#include <openssl/evp.h>
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;
}
WebSocket 数据帧 (data frame)
WebSocket 协议以 frame 为最小单位传输数据，当一条message（消息）过长时，发送方可以将message（消息）拆分成多个 frame 发送，接收方收到以后再重新拼接、解码还原出一条完整的message（消息）。
WebSocket 协议的data frame 的结构如下所示（从左到右，单位是比特）:
0 |1 |2 |3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| |Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
说明：
| 字段 | bit占用 | 语义 |
|---|---|---|
| FIN | 1 bit | 指示当前的 frame是否是消息的最后一个切片。1 表示这是消息(message)的最后一个分片(fragment)；0 表示不是是消息（message）的最后一个分片(fragment) |
| RSV1~3 | 1 bit | 一般情况下全为0。使用WebSocket扩展时，这三个标志位可以非0，由扩展进行定义。注意，如果这三个数是非零的值，并且并没有使用WebSocket扩展，接收方应该立刻终止websocket的连接。 |
| opcode | 4 bit | 操作代码，指示data frame 的类型，决定了数据载荷（data payload）的解析方式。如果操作代码是非法的，那么接收端应该断开连接 |
| mask | 1 bit | 指示是否要对数据载荷（data payload）进行掩码操作。从客户端向服务端发送数据时，需要对数据进行掩码操作；从服务端向客户端发送数据时，不需要对数据进行掩码操作。即所有客户端发送到服务端的数据帧，Mask必须为1，如果服务端接收到的数据没有进行掩码操作，服务端应该断开连接。 |
| Payload len | 7 bit | 指示数据载荷的长度，单位是字节。该字段的长度有三种可能：7 bit ，7 + 16 bit ，7 + 64 bit。当 数据载荷（Payload ）的实际长度 <126 时， 则 此字段的长度为 7bit, 直接代表了数据载荷的实际长度；当 此字段为 126 时, 则其后跟随的 16 bit将被解释为 16-bit 的无符号整数, 该整数的值指示数据载荷的实际长度； 当 此字段为 127 时, 其后的 64 bit将被解释为 64-bit 的无符号整数, 该整数的值指示数据载荷的实际长度。注意，如果payload length占用了多个字节的话，payload length的二进制表达采用网络序（需要解决大小端问题） |
| Masking-key | 32 bit | 可选字段，如果 Mask 为 1 ，Masking-key 字段存在，长度为 32 bit（4字节），所有由客户端发往服务端的data frame 都必须使用掩码覆盖； 如果Mask为0，则没有Masking-key。注意，载荷数据的长度，不包括masking-key的长度 |
| Payload | 0~64bit | 数据载荷，长度不固定，是 fram的数据部分。 如果使用了 WebSocket 扩展，扩展数据 (Extension data) 也将存放在这里, 扩展数据 + 应用数据, Payload Len 字段指示的值等于它们的长度和 |
opcode可选操作代码：
| 操作码 | 含义 |
|---|---|
| 0x0 | 特殊，表示一个延续帧。本次数据传输采用了数据分片，当前收到的数据帧为其中一个数据分片 |
| 0x1 | 表示这是一个文本帧 |
| 0x2 | 表示这是一个二进制帧 |
| 0x3-0x7 | 保留 |
| 0x8 | 连接断开 |
| 0x9 | ping操作 |
| 0xA | pong操作 |
| 0xB-0xF | 保留 |
掩码算法unmask
Masking-key是由客户端发送过来的32位的随机数。Masking-key不影响数据载荷的长度。掩码、反掩码操作都采用如下算法：
以字节为步长遍历 Payload, 对于 Payload 的第 i 个字节, 首先做 i 对 4 取模得到 j, 则掩码覆盖后的 Payload 的第 i 个字节的值为原先 Payload 第 i 个字节与 Masking-Key 的第 j 个字节做按位异或操作。
伪代码如下：
如果
original-octet-i：为原始数据的第i字节。
transformed-octet-i：为转换后的数据的第i字节。
j=i mod 4。
masking-key-octet-j：为mask key第j字节。
则算法描述为：
j = i MOD 4
transformed-octet-i = original-octet-i XOR masking-key-octet-j
掩码/反掩码的代码实现：
void umask(char *payload, int len, char *mask)
{
int i = 0;
for (i = 0; i < len; i++)
{
payload[i] ^= mask[i % 4];
}
}
websocket数据传输
WebSocket的客户端、服务端握手成功后，就可以进行数据传输，以data frame进行传递。opcode区数据载荷的类型，0x0~0x2。
消息(message)分片
当要发送的一条消息(message)很长或者消息(message)长度不能预测时， 消息可以切分成多个frame发出；接收方收到一个frame时，根据FIN的值来判断是否是最后一个frame。
消息分片可以实现发送端在一条 TCP 链路上进行多份数据并发的发往接收端。
消息分片主要利用 frame Header 的 FIN 和 Opcode 字段来实现。
消息分片例子（以文本消息为例，分N片）：
第一片：FIN=0，opcode=1；
第二片：FIN=0，opcode=0；
......
第N-1片：FIN=0，opcode=0；
第N片：FIN=1，opcode=1；
接收端按序拼接分片得到完整的消息（message）。
心跳包–保持连接
有些场景，客户端、服务端虽然长时间没有数据交互，但仍需要保持连接。这个时候，可以采用心跳来实现。
逻辑：
发送方 --> 接收方：ping，探测，实现 WebSocket 的 Keep-Alive，可以有Payload。
接收方 --> 发送方：pong，Ping 的响应，Payload 的内容需要和 Ping frame 相同
ping、pong的操作对应opcode分别是0x9、0xA。
Sec-WebSocket-Key/Sec-WebSocket-Accept的作用
Sec-WebSocket-Key主要目的不是确保数据的安全性，最主要作用是提供基本的安全防护，减少恶意连接。连接是否安全、数据是否安全、客户端/服务端是否合法，并没有实际性的保证。
数据掩码(Masking-key)的作用
WebSocket协议中，数据掩码的作用是增强websocket协议的安全性，并不是为了保护数据本身。
数据掩码并不是为了防止数据泄密，而是为了防止代理缓存污染攻击（proxy cache poisoning attacks） 问题。
websocket服务器实现
处理流程：
1、接收到client发送的请求升级协议包
2、解析请求包，获取Sec-WebSocket-Key字符串，转换到数据解析状态
3、解析升级协议包，获取相关信息，转换到数据交互状态
4、打包websocket协议头，发送frame。
代码简单示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <openssl/sha.h>
#include <openssl/pem.h>
#include <openssl/bio.h>
#include <openssl/evp.h>
#include <assert.h>
#define GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
#define BUFFER_LENGTH 1024
enum {
WS_HANDSHARK = 0,
WS_TRANMISSION=1,
WS_END=2,
WS_COUNT
};
struct ws_ophdr
{
unsigned char opencode : 4,
rsv3 : 1,
rsv2 : 1,
rsv1 : 1,
fin : 1;
unsigned char pl_len : 7,
mask : 1;
};
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;
char wbuffer[BUFFER_LENGTH]; //response
int wlength;
char sec_accept[ACCEPT_KEY_LENGTH];
int wsstatus; //0, 1, 2, 3
char mask_key[4];
};
/*
......
*/
// 按行读取数据
int readline(char *buffer,int idx,char *linebuffer)
{
int len = strlen(buffer);
for (; idx < len; ++idx)
{
if (buffer[idx] == '\r' && buffer[idx + 1] == '\n')
return idx + 2;
*(linebuffer++) = buffer[idx];
}
return -1;
}
// base64 encode
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;
}
// 握手，获取Sec-WebSocket-Key的字符串，并转换为Sec-WebSocket-Accept所需字符串
int ws_open_shark(struct ntyevent *ev)
{
int idx = 0;
char sec_data[128] = { 0 };
char sec_accept[128] = { 0 };
do
{
char linebuff[BUFFER_LENGTH] = { 0 };
idx = readline(ev->buffer, idx, linebuff);
if (strstr(linebuff, "Sec-WebSocket-Key"))
{
strcat(linebuff, GUID);
int keylen = strlen("Sec-WebSocket-Key: ");
SHA1(linebuff + keylen, strlen(linebuff + keylen), sec_data);
base64_encode(sec_data, strlen(sec_data), sec_accept);
printf("index %d, line : %s\n", idx, sec_accept);
memcpy(ev->sec_accept, sec_accept, ACCEPT_KEY_LENGTH);
}
} while ((ev->buffer[idx] != '\r' || ev->buffer[idx + 1] != '\n')
&& idx != -1);
return 0;
}
// 掩码、反掩码
void umask(char *payload, int len, char *mask)
{
int i = 0;
for (i = 0; i < len; i++)
{
payload[i] ^= mask[i % 4];
}
}
// 解析payloade数据
int ws_tranmission(struct ntyevent *ev)
{
struct ws_ophdr *ophdr = (struct ws_ophdr *)ev->buffer;
char *payload = NULL;
size_t datalen = 0;
int mask_key_offset = 0;
if (ophdr->pl_len < 126)
{
if (ophdr->mask)
{
payload = ev->buffer + 6;
mask_key_offset = 2;
umask(payload, ophdr->pl_len, ev->buffer + mask_key_offset);
}
else
payload = ev->buffer + 2;
datalen = ophdr->pl_len;
}
else if(ophdr->pl_len == 126)
{
printf("%x %x\n", (unsigned char)ev->buffer[2], (unsigned char)ev->buffer[3]);
datalen = (((unsigned char)ev->buffer[2]) << 8) | ((unsigned char)ev->buffer[3]);
if (ophdr->mask)
{
payload = ev->buffer + 8;
mask_key_offset = 4;
umask(payload, datalen, ev->buffer + mask_key_offset);
}
else
payload = ev->buffer + 4;
}
else if (ophdr->pl_len == 127)
{
int i = 0;
for (i = 2; i <10; i++)
{
datalen |= ((unsigned char)ev->buffer[i]);
if (i + 1 < 10)
datalen <<= 8;
}
if (ophdr->mask)
{
payload = ev->buffer + 14;
mask_key_offset = 10;
umask(payload, datalen, ev->buffer + mask_key_offset);
}
else
payload = ev->buffer + 10;
}
else
assert(0);
printf("fin : %d\n", ophdr->fin);
printf("rsv1: %d,rsv2: %d,rsv3: %d\n", ophdr->rsv1, ophdr->rsv2, ophdr->rsv3);
printf("opcode: %d\n", ophdr->opencode);
printf("mask : %d\n", ophdr->mask);
printf("payload len : %d\n", ophdr->pl_len);
if (mask_key_offset)
printf("mask-key: %x %x %x %x\n",
ev->buffer[mask_key_offset],
ev->buffer[mask_key_offset + 1],
ev->buffer[mask_key_offset + 2],
ev->buffer[mask_key_offset + 3]);
printf("data len: %lu\n", datalen);
printf("payload data [len = %ld]: %s\n", strlen(payload), payload);
strcpy(ev->wbuffer, payload);
ev->wlength = datalen;
memcpy(ev->mask_key, ev->buffer + mask_key_offset, 4);
return datalen;
}
// 解析获取申请升级协议请求，转换状态
void ws_status(struct ntyevent *ev)
{
char linebuff[BUFFER_LENGTH] = { 0 };
readline(ev->buffer, 0, linebuff);
if (strstr(linebuff, "GET "))
ev->wsstatus = WS_HANDSHARK;
else
ev->wsstatus = WS_TRANMISSION;
}
// 响应请求
int ws_request(struct ntyevent *ev)
{
ev->wlength = ev->length;
ws_status(ev);
if (ev->wsstatus == WS_HANDSHARK)
{
ws_open_shark(ev);
}
else if (ev->wsstatus = WS_TRANMISSION)
{
ws_tranmission(ev);
}
}
// 处理大小端的函数
void ws_inverted_string(char *str,int len)
{
int i = 0;
char temp;
for (i = 0; i < len / 2; ++i)
{
temp = *(str + i);
*(str + i) = *(str + len - i - 1);
*(str + len - i - 1) = temp;
}
}
// 发送websocket的header
int ws_send_hdr(struct ntyevent *ev)
{
struct ws_ophdr ophdr;
char extend[16] = { 0 };
int extend_length = 0;
int ret = 0;
ophdr.fin = 1;
ophdr.rsv1 = ophdr.rsv2 = ophdr.rsv3 = 0;
ophdr.mask = 1;
ophdr.opencode = 1;
if (ev->wlength<126)
ophdr.pl_len = ev->wlength;
else if (ev->wlength < 0xFFFF)
{
ophdr.pl_len = 126;
extend_length += 2;
extend[2] = (ev->wlength >> 8) & 0xFF;
extend[3] = ev->wlength & 0xFF;
printf("plelode length: %x%x\n", extend[2], extend[3]);
}
else
{
ophdr.pl_len = 127;
extend_length += 8;
printf("plelode length: ");
int i = 0;
for (i = 0; i<8; i++)
{
extend[i+2] = (ev->wlength >> ((7-i)*8)) & 0xFF;
printf("%x", extend[i+2]);
}
// 处理大小端问题
//ws_inverted_string((char *)extend + 2, sizeof(unsigned long long));
printf("\n");
}
extend_length += 2;// ophdr length
if (ophdr.mask)
{
printf("mask key start index: %d\n", extend_length);
extend[extend_length] = ev->mask_key[0];
extend[extend_length+1] = ev->mask_key[1];
extend[extend_length+2] = ev->mask_key[2];
extend[extend_length+3] = ev->mask_key[3];
printf("mask-key: %x %x %x %x\n",
extend[extend_length],
extend[extend_length + 1],
extend[extend_length + 2],
extend[extend_length + 3]);
umask(ev->wbuffer, ev->wlength, ev->mask_key);
extend_length += 4;
printf("mask key end index: %d\n", extend_length);
}
printf("fin: %d\nmask: %d\nopcode: %d\n", ophdr.fin, ophdr.mask, ophdr.opencode);
printf("send hdr[%d],extend_length=%d\n\n", ophdr.pl_len, extend_length);
char *tmp = (char*)&ophdr;
extend[0] = tmp[0];
extend[1] = tmp[1];
struct ws_ophdr_mask *maskkey=(struct ws_ophdr_mask *)extend;
printf("mask key: %s,%d,%s\n",ev->mask_key,
maskkey->mask,
maskkey->mask_key);
int i = 0;
printf("\n\nALL: ");
for (i = 0; i < extend_length; i++)
{
printf("%x ", extend[i]);
}
printf("\n\n");
send(ev->fd, &extend, extend_length, 0);
return ret;
}
// 响应请求
int ws_response(struct ntyevent *ev)
{
if (ev->wsstatus == WS_HANDSHARK)
{
ev->wlength = sprintf(ev->wbuffer, "HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: %s\r\n\r\n", ev->sec_accept);
}
else if (ev->wsstatus = WS_TRANMISSION)
{
ws_send_hdr(ev);
}
return ev->wlength;
}
/*
......
*/
int main(int argc,char *argv[])
{
int listenfd=socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in server;
memset(&server,0,sizeof(server));
server.sin_family=AF_INET;
server.sin_addr.s_addr=htonl(INADDR_ANY);
server.sin_port=htons(8888);
bind(listenfd,(struct sockaddr*)&server,sizeof(server));
if(listen(listenfd,10)<0)
return -1;
while(1)
{
struct sockaddr_in client;
socklen_t len=sizeof(client);
int clientfd=accept(listenfd,(struct sockaddr *)&client,&len);
struct ntyevent ev;
memset(&ev,0,sizeof(ev));
recv(clientfd,ev.buffer,BUFFER_LENGTH,0);
// 解析请求
ws_request(&ev);
// 响应请求
ws_response(&ev);
send(clientfd,ev->wbuffer,ev->wlength,0);
}
return 0;
}
总结
WebSocket 协议主要为了解决 HTTP/1.x 缺少双向通信机制的问题, 它使用 TCP 作为传输层协议, 使用 HTTP Upgrade 机制来握手,它与 HTTP 是相互独立的协议, 二者没有上下的分层关系。
【版权声明】本文为华为云社区用户原创内容，未经允许不得转载，如需转载请自行联系原作者进行授权。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）