websocket 协议封装
1、websocket 协议
websocket 兼容 http，是 http 的升级请求，最大特点是服务器可以主动向客户端推送信息。
websocket 协议与 http 协议
- 服务器与客户端通信双向通信，http 单向通信（只能由客户端发起连接）
- websocket 是持久连接，http 是短连接
- websocket 是有状态的，http 是无状态的
- websocket 以 ws/wss 开头，http 以 http/https 开头
- websocket 连接建立之后，不需要再发送request请求，数据直接从 tcp 通道传输。
websocket 协议组成
- ws 握手：字符格式
- 传输格式：二进制
根据 websocket 协议的设计，自定义协议应该考虑解决两个问题：
- tcp 分包和粘包：分隔符、具体的长度
- 自定义的数据传输格式：json / xml 等
2、ws Handshake
在 tcp 三次握手后，websocket 两次握手。
服务器的解析协议的流程
// key：客户端发送的报文 Sec-WebSocket-Key 字段
key = dGhlIHNhbXBsZSBub25jZQ==
// GUID：Globally Unique Identifier，唯一标识 websocket 协议
GUID = 258EAFA5-E914-47DA-95CA-C5AB0DC85B11
// 计算流程
// 1、拼接字符，key + GUID
str = dGhlIHNhbXBsZSBub25jZQ==258EAFA5-E914-47DA-95CA-C5AB0DC85B11
// 2、SHA-1 hash
sha = SHA-1(str)
// 3、base64-encoded
value = base64-encoded(sha)
// 4、将 value 填在报文的Sec-WebSocket-Accept字段中
Sec-WebSocket-Accept = value
3、数据传输格式
payload len
解码 umask
当 mask 位为1时，需要 umask 操作。
4、代码实现
// gcc -o websocket websocket.c -lssl -lcrypto
#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>
#define BUFFER_LENGTH 1024
#define ACCEPT_KEY_LENGTH 64
#define MAX_EPOLL_EVENTS 1024
#define SERVER_PORT 8888
#define PORT_COUNT 1
#define GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
// 有限状态机，状态转移
enum {
WS_HANDSHAKE = 0,
WS_TRANMISSION = 1,
WS_END = 2,
WS_COUNT // 状态总数，方便循环使用
};
// 定义 ws 操作字段（两字节），小端模式 lscpu | grep -i byte
struct ws_ophdr {
unsigned char opcode:4,
rsv3:1,
rsv2:1,
rsv1:1,
fin:1;
unsigned char pl_len:7,
mask:1;
};
// 回调函数
typedef int NCALLBACK(int ,int, void*);
// 管理每个连接fd的信息
struct ntyevent {
int fd;
int events; // io事件，EPOLL_IN, EPOLL_OUT
void *arg; // 其他附带的参数
int (*callback)(int fd, int events, void *arg); // 回调函数
int status; //对fd的操作，0添加，1修改
char rbuffer[BUFFER_LENGTH]; //request
int rlength;
char wbuffer[BUFFER_LENGTH]; //response
int wlength;
char sec_accept[ACCEPT_KEY_LENGTH];
int wsstatus; // ws状态机
};
struct eventblock {
struct eventblock *next;
struct ntyevent *events;
};
struct ntyreactor {
int epfd;
int blkcnt; //eventblock的块数
struct eventblock *evblks;
};
int recv_cb(int fd, int events, void *arg);
int send_cb(int fd, int events, void *arg);
struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd);
/**
* @brief 设置ntyevent的相关属性
*/
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);
return;
}
/**
* @brief 将 ntyevent 添加到epfd
*/
int nty_event_add(int epfd, int events, struct ntyevent *ev) {
struct epoll_event ep_ev = {0, {0}};
ep_ev.data.ptr = ev; // 指针指向ntyevent结构体
ep_ev.events = ev->events = events; //指向对应的事件
int op;
if (ev->status == 1) {
op = EPOLL_CTL_MOD;
} else {
op = EPOLL_CTL_ADD;
ev->status = 1;
}
if (epoll_ctl(epfd, op, ev->fd, &ep_ev) < 0) {
printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
return -1;
}
return 0;
}
/**
* @brief epfd删除对应的ntyevent
*/
int nty_event_del(int epfd, struct ntyevent *ev) {
struct epoll_event ep_ev = {0, {0}};
if (ev->status != 1) {
return -1;
}
ep_ev.data.ptr = ev;
ev->status = 0;
epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ep_ev);
return 0;
}
// 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;
}
/**
* @brief: 按行读取收到的协议数据
* @param: allbuf 协议数据，idx 行号，linebuf 返回读取的一行数据
* @return: 成功返回下一次要读取的行号，失败返回-1（数据中没有'\r\n'）
*/
int readline(char* allbuf, int idx, char* linebuf) {
int len = strlen(allbuf);
for (; idx < len; ++idx) {
// 读取到行结束('\r\n')
if (allbuf[idx] == '\r' && allbuf[idx+1] == '\n') {
return idx + 2; // 返回下次读取的行号
}
// 读取数据
else
*(linebuf++) = allbuf[idx];
}
return -1;
}
/** @brief: 完成ws_server的握手操作*/
int ws_handshake(struct ntyevent *ev) {
int idx = 0;
char sec_data[128] = {0};
char sec_accept[128] = {0};
do {
char linebuf[1024] = {0};
idx = readline(ev->rbuffer, idx, linebuf);
// 匹配 client 发送来的数据包的 Sec-WebSocket-Key 字段
if (strstr(linebuf, "Sec-WebSocket-Key")) {
// Sec-WebSocket-Accept 的 value 计算流程
// 1、拼接GUID和key
strcat(linebuf, GUID);
// 2、SHA1，参数(偏移位置、hash长度、存储位置)，openssl,
int n = strlen("Sec-WebSocket-Key: ");
SHA1(linebuf + n, strlen(linebuf + n), sec_data);
// 3、base64_encode
base64_encode(sec_data, strlen(sec_data), sec_accept);
memcpy(ev->sec_accept, sec_accept, ACCEPT_KEY_LENGTH);
}
// 1、下次要读取的数据仍是'\r\n'，结合之前已经读到'\r\n'，遇到了结束符('\r\n\r\n')
// 2、idx = -1，数据包格式非法，不含有'\r\n'
} while((ev->rbuffer[idx] != '\r' || ev->rbuffer[idx+1] != '\n') && idx != -1);
}
// 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];
}
}
/** @brief: 完成ws_server的c传输操作*/
int ws_tranmission(struct ntyevent *ev) {
// 取出 ws 操作字段
struct ws_ophdr *hdr = (struct ws_ophdr *)ev->rbuffer;
// <126, 7bit表示; =126，7+16bit表示; =127，7+64bit表示
if (hdr->pl_len < 126) {
unsigned char *payload = NULL;
// 若mask位为1，需要umask操作
if (hdr->mask) {
// 数据开始的位置，2(操作字段) + 4(masking-key字段)
payload = ev->rbuffer + 6;
// umask操作，数据解码
umask(payload, hdr->pl_len, ev->rbuffer + 2);
}
else {
payload = ev->rbuffer + 2;
}
// printf("payload: %s\n", payload);
// printf("sizeof payload %d\n", (int)hdr->pl_len);
memset(ev->wbuffer, 0, ev->wlength);
ev->wlength = (int)hdr->pl_len;
memcpy(ev->wbuffer, payload, ev->wlength);
} else if (hdr->pl_len == 126) {
} else if (hdr->pl_len == 127) {
} else {
// assert(0);
}
return 0;
}
// request
int ws_request(struct ntyevent *ev) {
if (ev->wsstatus == WS_HANDSHAKE) {
ws_handshake(ev);
// ev->wsstatus = WS_TRANMISSION;
} else if (ev->wsstatus == WS_TRANMISSION) {
ws_tranmission(ev);
}
return 0;
}
// response
int ws_response(struct ntyevent *ev) {
if (ev->wsstatus == WS_HANDSHAKE) {
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);
printf("response: %s\n", ev->wbuffer);
ev->wsstatus = WS_TRANMISSION;
return ev->wlength;
}
else if (ev->wsstatus == WS_TRANMISSION) {
// 封装包
}
}
int recv_cb(int fd, int events, void *arg) {
struct ntyreactor *reactor = (struct ntyreactor*)arg;
struct ntyevent *ev = ntyreactor_idx(reactor, fd);
if (ev == NULL) return -1;
int len = recv(fd, ev->rbuffer, BUFFER_LENGTH, 0);
nty_event_del(reactor->epfd, ev);
if (len > 0) {
ev->rlength = len;
ev->rbuffer[len] = '\0';
// 对websocket报文进行解析
ws_request(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);
printf("recv_cb --> disconnect\n");
close(ev->fd);
} else {
if (errno == EAGAIN && errno == EWOULDBLOCK) { //
} else if (errno == ECONNRESET){
nty_event_del(reactor->epfd, ev);
close(ev->fd);
}
printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
}
return len;
}
int send_cb(int fd, int events, void *arg) {
struct ntyreactor *reactor = (struct ntyreactor*)arg;
struct ntyevent *ev = ntyreactor_idx(reactor, fd);
if (ev == NULL) return -1;
// ws 响应
ws_response(ev);
int len = send(fd, ev->wbuffer, ev->wlength, 0);
if (len > 0) {
printf("send[fd=%d], [%d]%s\n", fd, len, ev->wbuffer);
nty_event_del(reactor->epfd, ev);
nty_event_set(ev, fd, recv_cb, reactor);
nty_event_add(reactor->epfd, EPOLLIN, ev);
} else {
nty_event_del(reactor->epfd, ev);
close(ev->fd);
printf("send[fd=%d] error %s\n", fd, 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);
if (event == NULL) return -1;
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;
}
/**
* @brief 创建监听端口
* @return 返回port对应的fd
*/
int init_sock(short port) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(fd, F_SETFL, O_NONBLOCK);
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(port);
bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
if (listen(fd, 20) < 0) {
printf("listen failed : %s\n", strerror(errno));
return -1;
}
printf("listen server port : %d\n", port);
return fd;
}
/**
* @brief: 实现evblks的动态扩容，尾插法
* @return: 成功返回0，失败返回-1
* */
int ntyreactor_alloc(struct ntyreactor *reactor) {
if (reactor == NULL) return -1;
if (reactor->evblks == NULL) return -1;
struct eventblock *blk = reactor->evblks;
// 寻找最后一块的指针
while (blk->next != NULL) {
blk = blk->next;
}
// 创建新的ntyevent
struct ntyevent* evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
if (evs == NULL) {
printf("ntyreactor_alloc ntyevent failed\n");
return -2;
}
memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
// 创建新的块eventblock
struct eventblock *block = malloc(sizeof(struct eventblock));
if (block == NULL) {
printf("ntyreactor_alloc eventblock failed\n");
return -3;
}
// 当前块指向新的ntyevent
block->events = evs;
block->next = NULL;
// 尾插新创建的块
blk->next = block;
reactor->blkcnt++; //块的数量增加
return 0;
}
/**
* @brief: 查询sockfd对应的ntyevent。若没有，则动态创建新的
* @return: 返回对应的ntyevent
*/
struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd) {
if (reactor == NULL) return NULL;
if (reactor->evblks == NULL) return NULL;
// 查询 ntyevent 对应的块号，块号 = 块号 / 块长
int blkidx = sockfd / MAX_EPOLL_EVENTS;
// 当前块号越界，动态扩容。大fd不存在，每次循环一次
while (blkidx >= reactor->blkcnt) {
ntyreactor_alloc(reactor);
}
// 查询块号对应的块
struct eventblock *blk = reactor->evblks;
int i = 0;
while (i++ != blkidx && blk != NULL) {
blk = blk->next;
}
// 返回当前块内对应的ntyevent，块内地址 = 块号 % 块长
return &blk->events[sockfd % MAX_EPOLL_EVENTS];
}
// 初始化reactor
int ntyreactor_init(struct ntyreactor *reactor) {
if (reactor == NULL) return -1;
memset(reactor, 0, sizeof(struct ntyreactor));
reactor->epfd = epoll_create(1);
if (reactor->epfd <= 0) {
printf("create epfd in %s err %s\n", __func__, strerror(errno));
return -2;
}
struct ntyevent* evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
if (evs == NULL) {
printf("create epfd in %s err %s\n", __func__, strerror(errno));
close(reactor->epfd);
return -3;
}
memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
struct eventblock *block = malloc(sizeof(struct eventblock));
if (block == NULL) {
free(evs);
close(reactor->epfd);
return -3;
}
block->events = evs;
block->next = NULL;
reactor->evblks = block;
reactor->blkcnt = 1;
return 0;
}
/**
* @brief 关闭reactor，释放内存空间
* @return 成功返回0，失败返回-1
*/
int ntyreactor_destory(struct ntyreactor *reactor) {
close(reactor->epfd);
struct eventblock *blk = reactor->evblks;
struct eventblock *blk_next;
while (blk != NULL) {
blk_next = blk->next;
free(blk->events);
free(blk);
blk = blk_next;
}
return 0;
}
/**
* @brief 向 eactor添加监听的sockfd
* @param reactor 存储全局变量reactor
* @param sockfd 新建立连接对应的sockfd
* @param acceptor 注册接收连接的回调函数
* @return int 成功返回0，失败返回-1
*/
int ntyreactor_addlistener(struct ntyreactor *reactor, int sockfd, NCALLBACK *acceptor) {
if (reactor == NULL) return -1;
if (reactor->evblks == NULL) return -1;
struct ntyevent *event = ntyreactor_idx(reactor, sockfd);
if (event == NULL) return -1;
nty_event_set(event, sockfd, acceptor, reactor);
nty_event_add(reactor->epfd, EPOLLIN, event);
return 0;
}
/**
* @brief 启动reactor
* @param reactor
* @return int 成功返回0，失败返回-1
*/
int ntyreactor_run(struct ntyreactor *reactor) {
if (reactor == NULL) return -1;
if (reactor->epfd < 0) return -1;
if (reactor->evblks == NULL) return -1;
struct epoll_event events[MAX_EPOLL_EVENTS + 1];
int checkpos = 0, i;
while (1) {
int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENTS, 1000);
if (nready < 0) {
printf("epoll_wait error, exit\n");
continue;
}
for (i = 0; i < nready; ++i) {
struct ntyevent *ev = (struct ntyevent*)events[i].data.ptr;
if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) {
ev->callback(ev->fd, events[i].events, ev->arg);
}
if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) {
ev->callback(ev->fd, events[i].events, ev->arg);
}
}
}
}
int main(int argc, char *argv[]) {
struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
ntyreactor_init(reactor);
unsigned short port = SERVER_PORT;
if (argc == 2) {
port = atoi(argv[1]);
}
int i = 0;
int sockfds[PORT_COUNT] = {0};
for (i = 0;i < PORT_COUNT; ++i) {
sockfds[i] = init_sock(port + i);
ntyreactor_addlistener(reactor, sockfds[i], accept_cb);
}
ntyreactor_run(reactor);
ntyreactor_destory(reactor);
for (i = 0;i < PORT_COUNT;i ++) {
close(sockfds[i]);
}
free(reactor);
return 0;
}
文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习：服务器高级架构体系
1349
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
