Websocket协议
一、websocket简介
websocket是在单个TCP连接上进行全双工通信的协议，允许Server主动向Client推送数据。
客户端和服务器只需要完成一次握手，就可以创建持久性的连接，进行双向数据传输。
websocket是独立的，作用在TCP上的协议。
为了向前兼容， WebSocket 协议使用 HTTP Upgrade 协议升级机制来进行 WebSocket 握手, 当握手完成之后, 客户端和服务端就可以依据WebSocket 协议的规范格式进行数据传输。
二、WebSocket与HTTP
2.1、WebSocket与HTTP的关系
相同点
- 都是一样基于TCP的，都是可靠性传输协议。
- 都是应用层协议。
不同点
- WebSocket是双向通信协议，模拟Socket协议，可以双向发送或接受信息。HTTP是单向的。
- WebSocket是需要握手进行建立连接的。
联系
WebSocket在建立握手时，数据是通过HTTP传输的。但是建立之后，在真正传输时候是不需要HTTP协议的。
2.2、websocket相对HTTP协议的优点
- 支持双向通信，数据的实时性更新更强。
- 开销小；客户端和服务端进行数据通信时，websocket的header（数据头）较小。服务端到客户端的header只有2~10 Bytes，客户端到服务端的需要加上额外的4 Bytes的masking-key。而HTTP协议每次通信都需要携带完整的数据头。
- 扩展性。ws协议定义了扩展，用户可以扩展协议，或者实现自定义的子协议。
- 二进制数据支持更好。
三、连接握手
WebSocket为了兼容HTTP协议，是在HTTP协议的基础之上进行升级得到的。在客户端和服务器端建立HTTP连接之后，客户端会向服务器端发送一个升级到webSocket的协议，如下所示：
GET /chat HTTP/1.1
Host: example.com:8000
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
注意，这里的HTTP版本必须是1.1以上。HTTP的请求方法必须是GET
通过设置Upgrade和Connection这两个header，表示我们准备升级到webSocket了。
除了这里列的属性之外，其他的HTTP自带的header属性都是可以接受的。
这里还有两个比较特别的header，他们是Sec-WebSocket-Version和Sec-WebSocket-Key。
Sec-WebSocket-Version：
客户端请求的WebSocket的版本号。如果服务器端并不明白客户端发送的请求，则会返回一个400 ("Bad Request")，在这个返回中，服务器端会返回失败的信息。如果是不懂客户端发送的Sec-WebSocket-Version，服务器端同样会将Sec-WebSocket-Version返回，以告知客户端。
Sec-WebSocket-Key：服务器响应返回的Sec-WebSocket-Accept就是根据请求中的Sec-WebSocket-Key来生成
当服务器端收到客户端的请求之后，会返回给客户端一个响应，告诉客户端协议已经从HTTP升级到WebSocket了。
返回的响应可能是这样的：
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
这里的Sec-WebSocket-Accept是根据客户端请求中的Sec-WebSocket-Key来生成的。具体是将客户端发送的Sec-WebSocket-Key 和 字符串"258EAFA5-E914-47DA-95CA-C5AB0DC85B11" 进行连接。然后使用SHA1算法求得其hash值。最后将hash值进行base64编码即可。
当服务器端返回Sec-WebSocket-Accept之后，客户端可以对其进行校验，以完成整个握手过程。
四、数据传输
4.1 消息格式
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 ... |
+---------------------------------------------------------------+
FIN: 1 bit
表示这是消息的最后一个片段。第一个片段也有可能是最后一个片段。
RSV1，RSV2，RSV3: 每个 1 bit
必须设置为 0，除非扩展了非 0 值含义的扩展。如果收到了一个非 0 值但是没有扩展任何非 0 值的含义，接收终端必须断开 WebSocket 连接。
Opcode: 4 bit
定义“有效负载数据”的解释。如果收到一个未知的操作码，接收终端必须断开 WebSocket 连接。下面的值是被定义过的。
- %x0 表示一个持续帧
- %x1 表示一个文本帧
- %x2 表示一个二进制帧
- %x3-7 预留给以后的非控制帧
- %x8 表示一个连接关闭包
- %x9 表示一个 ping 包
- %xA 表示一个 pong 包
- %xB-F 预留给以后的控制帧
Mask: 1 bit
mask 标志位，定义“有效负载数据”是否添加掩码。如果设置为 1，那么掩码的键值存在于 Masking-Key 中，所有的从客户端发送到服务端的帧都需要设置这个 bit 位为 1。
Payload length: 7 bits, 7+16 bits, 7+64 bits
以字节为单位的“有效负载数据”长度，如果值为 0-125，那么就表示负载数据的长度。如果是 126，那么接下来的 2 个 bytes 解释为 16bit 的无符号整形作为负载数据的长度。如果是 127，那么接下来的 8 个 bytes 解释为一个 64bit 的无符号整形（最高位的 bit 必须为 0）作为负载数据的长度。
有效负载长度是指“扩展数据”+“应用数据”的长度。
Masking-Key: 0 or 4 bytes
所有从客户端发往服务端的数据帧都已经与一个包含在这一帧中的 32 bit 的掩码进行过了运算。如果 mask 标志位（1 bit）为 1，那么这个字段存在，如果标志位为 0，那么这个字段不存在。在 5.3 节中会介绍更多关于客户端到服务端增加掩码的信息。
Payload data: (x+y) bytes
“有效负载数据”是指“扩展数据”和“应用数据”。
-
Extension data: x bytes
除非协商过扩展，否则“扩展数据”长度为 0 bytes。在握手协议中，任何扩展都必须指定“扩展数据”的长度，这个长度如何进行计算，以及这个扩展如何使用。如果存在扩展，那么这个“扩展数据”包含在总的有效负载长度中。
-
Application data: y bytes
任意的“应用数据”，占用“扩展数据”后面的剩余所有字段。“应用数据”的长度等于有效负载长度减去“扩展应用”长度。
4.2 Websocket消息实例
这是客户端给服务器发送 "Hello, WebSocket!" 字符串的示例数据报文：
81 91 BD 14 A5 6E F5 71 C9 02 D2 38 85 39 D8 76 F6 01 DE 7F C0 1A 9C
报文分析：
-
0x81(b1000 0001): FIN=1, opcode=1，说明这一帧是文本数据；
-
0x91(b1001 0001): MASK=1，Payload len: 17(Hello, WebSocket!的长度)；
- 如果Payload len长度是126，则扩展2个字节 extend payload length 作为数据长度；
- 如果Payload len长度是127，则扩展8个字节 extend payload length 作为数据长度；
-
BD 14 A5 6E， 如果MASK位设置位1，这里4字节为 掩码键(Masking-key)，它是由客户端挑选出来的32位随机数；
-
F5 71 C9 02 D2 38 85 39 D8 76 F6 01 DE 7F C0 1A 9C Payload掩码算法(payload data与masking-key进行异或)处理后的结果，该操作不会影响数据载荷的长度；
五、示例
客户端
<!DOCTYPE html>
<html>
<head>
<title>WebSocket 客户端</title>
</head>
<body>
<h1>WebSocket 客户端</h1>
<label for="server">服务器:</label>
<input type="text" id="server" value="ws://192.168.10.167:8888" />
<button onclick="connect()">连接</button><br/>
<label for="message">消息:</label>
<input type="text" id="message" value="hello" />
<button onclick="sendMessage()">发送</button><br/>
<div id="output"></div>
<script>
var ws;
function connect() {
var server = document.getElementById('server').value;
ws = new WebSocket(server);
ws.onopen = function() {
document.getElementById('output').innerHTML += '连接已打开<br/>';
};
ws.onmessage = function(event) {
document.getElementById('output').innerHTML += '接收: ' + event.data + '<br/>';
};
ws.onclose = function() {
document.getElementById('output').innerHTML += '连接已关闭<br/>';
};
}
function sendMessage() {
var message = document.getElementById('message').value;
ws.send(message);
document.getElementById('output').innerHTML += '发送: ' + message + '<br/>';
}
</script>
</body>
</html>
服务器
下面只给了websocket相关的函数
#define BUFFER_LENGTH 4096
#define GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
#define WEBSOCK_KEY_LENGTH 19 //length of "Sec-WebSocket-Key: "
enum {
WS_HANDSHARK = 0,
WS_TRANMISSION = 1,
WS_END = 2,
};
typedef struct ws_ophdr_s
{
unsigned char opcode:4,
rsv3:1,
rsv2:1,
rsv1:1,
fin:1;
unsigned char pl_len:7,
mask:1;
} ws_ophdr_t;
typedef struct ws_head_126_s
{
unsigned short pl_len;
char mask_key[4];
} ws_head_126_t;
typedef struct ws_head_127_s
{
unsigned long long pl_len;
char mask_key[4];
} ws_head_127_t;
typedef struct ws_ctx_s
{
char buf[BUFFER_LENGTH];
struct event_base *base;
struct evconnlistener *listener;
struct bufferevent *bev;
int state;
} ws_ctx_t;
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;
}
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;
}
int handshark(struct bufferevent *bev, char *buf, int len)
{
char linebuf[1024] = {0};
int idx = 0;
char sec_data[20] = {0};
char sec_accept[128] = {0};
/*读每一行找到Sec-WebSocket-Key，对这个key进行SHA1和base64获取对应的accept-key，再生成一个符合规范的响应报文回给客户端*/
do{
memset(linebuf, 0, 1024);
idx = readline(buf, idx, linebuf);
if(strstr(linebuf, "Sec-WebSocket-Key"))
{
strcat(linebuf, GUID);
SHA1(linebuf + WEBSOCK_KEY_LENGTH, strlen(linebuf + WEBSOCK_KEY_LENGTH), sec_data);
base64_encode(sec_data, strlen(sec_data), sec_accept);
memset(buf, 0, BUFFER_LENGTH);
len = sprintf(buf, "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("Response: %s\n", buf);
bufferevent_write(bev, buf, len); //我的服务器端是基于libevent来实现的，这里就是把buf里的数据传给客户端
break;
}
} while ((buf[idx] != '\r' || buf[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(ws_ctx_t *ws_ctx, char *buf, int len)
{
ws_ophdr_t *hdr = NULL;
ws_head_126_t *hdr126 = NULL;
ws_head_127_t *hdr127 = NULL;
unsigned char *payload = NULL;
int pl_len = 0;
printf("buf:%s\n", buf);
hdr = (ws_ophdr_t *)buf;
if( hdr->pl_len < 126 )
{
pl_len = hdr->pl_len;
payload = (unsigned char *)(buf + sizeof(ws_ophdr_t) + 4);
if (hdr->mask) //mask=1,需要解掩码
{
umask((char *)payload, pl_len, buf + sizeof(ws_ophdr_t));
}
printf("payload:%s\n", payload);
}
else if ( hdr->pl_len == 126 )
{
hdr126 = (ws_head_126_t *)(buf + sizeof(ws_ophdr_t));
pl_len = ntohs(hdr126->pl_len);
payload =(unsigned char *) (buf + sizeof(ws_ophdr_t) + sizeof(ws_head_126_t) + 4);
if (hdr->mask)
{
umask(payload, pl_len, buf + sizeof(ws_ophdr_t) + sizeof(ws_head_126_t));
}
printf("payload:%s\n", payload);
}
else
{
hdr127 = (ws_head_127_t *)(buf + sizeof(ws_ophdr_t));
pl_len = ntohll(hdr127->pl_len);
payload =(unsigned char *) (buf + sizeof(ws_ophdr_t) + sizeof(ws_head_127_t) + 4);
if (hdr->mask)
{
umask(payload, hdr->pl_len, buf + sizeof(ws_ophdr_t) + sizeof(ws_head_127_t));
}
printf("payload:%s\n", payload);
}
return 0;
}
void ws_request(struct bufferevent *bev, char *buf, int len, void *arg)
{
ws_ctx_t *ws_ctx = (ws_ctx_t *)arg;
printf("state: %d\n", ws_ctx->state);
if (ws_ctx->state == WS_HANDSHARK)
{
ws_ctx->state = WS_TRANMISSION;
handshark(bev, buf, len);
}
else if (ws_ctx->state == WS_TRANMISSION)
{
transmission(ws_ctx, buf, len);
}
printf("websocket request: %d\n", ws_ctx->state);
}
