前言
打算写一个WebSocket服务器来练练手，它是基于tcp实现的，与生俱来的优点较之http是全双工的，即服务端可主动向客户端推送数据，亦可请求响应的模式来进行数据传输
WebSocket讲解
网上有很多对WebSocket的格式进行了充分的讲解，我们搬来用用。
参考自 https://segmentfault.com/a/1190000012948613 感谢大神！！！
握手
首先是客户端和服务器建立连接，即握手操作。
GET / HTTP/1.1
Host: localhost:8080
Origin: http://127.0.0.1:3000
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Version: 13
Sec-WebSocket-Key: w4v7O6xFTi36lq3RNcgctw==
这是客户端的请求
- Connection: Upgrade：表示要升级协议
- Upgrade: websocket：表示要升级到 websocket 协议。
- Sec-WebSocket-Version: 13：表示 websocket 的版本。如果服务端不支持该版本，需要返回一个 Sec-WebSocket-Versionheader ，里面包含服务端支持的版本号。
- Sec-WebSocket-Key：与后面服务端响应首部的 Sec-WebSocket-Accept 是配套的，提供基本的防护，比如恶意的连接，或者无意的连接
HTTP/1.1 101 Switching Protocols
Connection:Upgrade
Upgrade: websocket
Sec-WebSocket-Accept: Oy4NRAQ13jhfONC7bP8dTKb4PTU=
这是服务器响应。
- Sec-WebSocket-Accept
伪代码如下：
>toBase64(sha1(Sec-WebSocket-Key + 258EAFA5-E914-47DA-95CA-C5AB0DC85B11))
接下来就是数据的传输（客户端与服务器）
数据帧的格式
> fin占1位，表示此次传输数据包是否传输完，因为websocket里有分片传输，1传输完，0未传输完
> rsv1,2,3占3位，是做扩展用
> opcode占4位，是数据帧的操作类型包括close，ping，pong，binary，text等
> mask占1位，1表示数据要经过掩码运算，0表示不需要掩码操作，服务器不需要掩码，客户端需要
>payload len占7位，表示数据的长度，分为[0, 126)，126，127
~ 第一种情况数据长度就是等于该值
~ 第二种情况用其后的2个字节表示数据的长度
~ 第三种情况用其后的8个字节表示数据的长度
>making-key占4字节，如果mask设置1，使用这个key与数据进行掩码操作来获得正式的数据
>之后便是数据部分，分为扩展数据和应用数据，我们在这里只讨论应用数据
>
代码
代码结构分为：
* Server: 管理客户端，接收客户端数据，同时向客户端写入数据
* ClientItem, 接受到的客户端的实例（可理解为socket）
* WebSokcetMsg 数据包的解析和封装
* WebSocketController 业务处理类，通过Server派发给任务，同时自己可通过回调写客户端写数据
1
我们首先看WebSocketMsg：数据包的封装和解析
#ifndef __WEBSOCKETMSG_H__
#define __WEBSOCKETMSG_H__
#include <map>
#include <sstream>
class WebSocketMsg
{
public:
WebSocketMsg();
~WebSocketMsg();
struct WebSocketPkt
{
enum MsgType {
MsgType_Handshake,
MsgType_FrameData,
};
enum OpcodeType {
OpcodeType_Continue = 0x0,
OpcodeType_Text = 0x1,
OpcodeType_Binary = 0x2,
OpcodeType_Close = 0x8,
OpcodeType_Ping = 0x9,
OpcodeType_Pong = 0xA,
};
void resetFrameData();
MsgType msg_type_;
std::map<std::string, std::string> header_map_;
uint8_t fin_; // 1bit
uint8_t opcode_; // 4bit
uint8_t mask_; // 1bit
uint8_t masking_key_[4]; // 0 or 4 bytes
uint64_t payload_length_; // 1 or 2 or 8 bytes
std::string data_;
};
/**
* return: -1:error, 0:continue, >0:done
*/
int fromFrameDataPkt(int nread, const char *buf);
bool fromHandshakePkt(int nread, const char *buf);
WebSocketMsg::WebSocketPkt::OpcodeType requestOpcode() {
return (WebSocketMsg::WebSocketPkt::OpcodeType)request_.opcode_;
}
std::string requestData() {
return request_.data_;
}
void resetRequestData() {
request_.resetFrameData();
}
std::string toHandshakePkt();
std::string toFrameDataPkt(const std::string &data,
WebSocketMsg::WebSocketPkt::OpcodeType type =
WebSocketMsg::WebSocketPkt::OpcodeType_Text);
private:
WebSocketPkt request_;
WebSocketPkt response_;
};
#endif // __WEBSOCKETMSG_H__
定义请求和响应的WebSocketPkt 对象来做处理，请求来了使用request_处理，要是组合响应信息通过response_，只是这样设想，可看具体实现
#include "WebSocketMsg.h"
#include "base/string_util.h"
#include "base/sha1.h"
#include "base/base64.h"
const char s_Key[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
const char s_ReqWSKey[] = "Sec-WebSocket-Key";
WebSocketMsg::WebSocketMsg()
{
request_.resetFrameData();
response_.resetFrameData();
}
WebSocketMsg::~WebSocketMsg()
{
}
bool WebSocketMsg::fromHandshakePkt(int nread, const char *buf)
{
request_.msg_type_ = WebSocketPkt::MsgType_Handshake;
std::string str(buf, nread);
std::vector<std::string> tokens;
int size = Tokenize(str, "\r\n", &tokens);
for (int i = 0; i < size; ++i) {
const std::string &line = tokens.at(i);
std::vector<std::string> lineEle;
int eleSize = Tokenize(line, ": ", &lineEle);
if (eleSize == 2) {
request_.header_map_[lineEle.at(0)] = lineEle.at(1);
}
}
return true;
}
int WebSocketMsg::fromFrameDataPkt(int nread, const char *buf)
{
request_.msg_type_ = WebSocketPkt::MsgType_FrameData;
unsigned bytePos = 0;
request_.fin_ = (buf[bytePos] >> 7);
request_.opcode_ = buf[bytePos] & 0x0F;
bytePos++;
request_.mask_ = (buf[bytePos] >> 7);
request_.payload_length_ = buf[bytePos] & 0x7F;
bytePos++;
if (request_.payload_length_ == 126) {
uint16_t length = 0;
memcpy(&length, buf + bytePos, 2);
request_.payload_length_ = ntohs(length);
bytePos += 2;
}
else if (request_.payload_length_ == 127) {
long long length = 0;
memcpy(&length, buf + bytePos, 8);
request_.payload_length_ = ntohll(length);
bytePos += 8;
}
if (request_.mask_ != 0) {
for (int i = 0; i < 4; ++i) {
request_.masking_key_[i] = buf[bytePos++];
}
}
std::string s = "";
if (request_.mask_ == 0) {
s = std::string(buf + bytePos, (unsigned)request_.payload_length_);
}
else {
for (unsigned i = 0; i < request_.payload_length_; ++i) {
unsigned j = i % 4U;
char c = buf[bytePos + i] ^ request_.masking_key_[j];
s.push_back(c);
}
}
request_.data_.append(s);
bytePos += (unsigned)request_.payload_length_;
return request_.fin_;
}
std::string WebSocketMsg::toHandshakePkt()
{
auto &headerMap = request_.header_map_;
if (headerMap.count(s_ReqWSKey) == 0) {
return "";
}
std::string pkt;
pkt.append("HTTP/1.1 101 Switching Protocols\r\n");
pkt.append("Connection: upgrade\r\n");
pkt.append("Upgrade: websocket\r\n");
pkt.append("Sec-WebSocket-Accept: ");
std::string SecWSKey = headerMap.at(s_ReqWSKey) + s_Key;
bool rc = base::Base64Encode(base::SHA1HashString(SecWSKey), &SecWSKey);
if (rc) {
pkt.append(SecWSKey + "\r\n\r\n");
}
else {
pkt = "";
}
return pkt;
}
std::string WebSocketMsg::toFrameDataPkt(const std::string &data,
WebSocketMsg::WebSocketPkt::OpcodeType type)
{
unsigned size = data.size();
std::string frame;
uint8_t c = (1 << 7);
c = c | type;
frame.push_back((char)c);
uint8_t paylength = 0;
if (size < 126U) {
paylength = size;
frame.push_back((char)paylength);
}
else if (size >= 126U && size <= 0xFFFFU) {
paylength = 126;
frame.push_back(paylength);
uint16_t l = htons(size);
char buf[2] = {0};
memcpy(buf, &l, 2);
frame.append(buf);
}
else {
paylength = 127;
frame.push_back(paylength);
uint64_t l = htonll((int64_t)size);
char buf[8] = {0};
memcpy(buf, &l, 8);
frame.append(buf);
}
frame.append(data);
return frame;
}
void WebSocketMsg::WebSocketPkt::resetFrameData()
{
fin_ = 0;
opcode_ = 0;
mask_ = 0;
memset(masking_key_, 0, sizeof(masking_key_));
payload_length_ = 0;
data_ = "";
}
这是具体实现，fromHandshakePkt函数 即解析握手包的收据，fromFrameDataPkt 函数即解析数据帧的数据，其中使用如下来获得真实数据
for (unsigned i = 0; i < request_.payload_length_; ++i) {
unsigned j = i % 4U;
char c = buf[bytePos + i] ^ request_.masking_key_[j];
s.push_back(c);
}
toHandshakePkt和toFrameDataPkt来封装响应的握手包及向客户端传输的数据包
2
然后我们来看Server看服务器是如何实现，我们使用libuv库来实现，libuv是事件驱动i/o模型，nodejs便是使用的它，适合i/o密集型的服务器
#ifndef __SERVER_H__
#define __SERVER_H__
#include <iostream>
#include <map>
#include "uv.h"
#include "ClientItem.h"
#include "WebSocketController.h"
typedef struct {
uv_write_t req_;
uv_buf_t buf_;
} write_response_t;
class Server
{
public:
Server(int port = 8080);
~Server();
int run();
void doWork(ClientItem *item);
void writeFrameData(int64_t id, const std::string &data);
inline void pushClient(const ClientItem &ci);
inline ClientItem* client(int64_t id);
void closeClient(int64_t id);
void removeClient(int64_t id);
inline const std::map<int64_t, ClientItem>& clientMap() const;
inline int64_t increaseId();
private:
static void on_new_connection(uv_stream_t* server, int status);
static void alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf);
static void read_msg(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf);
static void write_msg_ret(uv_write_t *response, int status);
static void timer_out(uv_timer_t* handle);
private:
uv_loop_t *loop_;
uv_tcp_t server_;
int port_;
sockaddr_in addr_;
std::map<int64_t, ClientItem> client_map_;
int64_t increase_id_;
uv_timer_t repeat_timer_;
std::unique_ptr<WebSocketController> ws_controller_;
};
#endif // __SERVER_H__
Server类的声明简要介绍：
write_response_t是向客户端写数据的结构体
libuv使用了好多C的回调函数，我们把它定义成static类型，有新客户端连接，读数据，定时器等
我们把写数据writeFrameData定义成成员函数，方便我们操作；
定时器的作用是我们隔段时间去检查客户端是否还活着，不活着就关闭。
*client系列函数是针对客户端实例的管理
首先我们先看入口函数：run
int Server::run()
{
uv_tcp_init(loop_, &server_);
uv_ip4_addr("0.0.0.0", port_, &addr_);
uv_tcp_bind(&server_, (const sockaddr *)&addr_, 0);
server_.data = this;
int rc = uv_listen((uv_stream_t *)&server_, DEFAULT_BACKLOG, &Server::on_new_connection);
if (rc) {
std::cout << "listen error:" << uv_strerror(rc) << std::endl;
return -1;
}
repeat_timer_.data = this;
uv_timer_init(loop_, &repeat_timer_);
uv_timer_start(&repeat_timer_, timer_out, 1000, 1000);
return uv_run(loop_, UV_RUN_DEFAULT);
}
监听port_端口进行初始化，设置回调函数on_new_connection有新的连接到来的函数，启动定时器，进入循环。
然后看“连接到来”的函数：on_new_connection
void Server::on_new_connection(uv_stream_t *server, int status)
{
if (status < 0) {
std::cout << "new connection error" << uv_strerror(status) << std::endl;
return ;
}
uv_tcp_t *client = (uv_tcp_t *)malloc(sizeof(uv_tcp_t));
uv_tcp_init(server->loop, client);
if (uv_accept(server, (uv_stream_t *)client) == 0) {
std::cout << "new connection" << std::endl;
Server *s = (Server *)(server->data);
ClientItem item(s->increaseId(), client, (int64_t)base::Time::Now().ToDoubleT());
item.user_data_ = s;
s->pushClient(item);
client->data = s->client(item.id_);
uv_read_start((uv_stream_t *)client, alloc_buffer, read_msg);
}
else {
uv_close((uv_handle_t *)client, NULL);
free(client);
}
}
连接到来时初始化客户端实例，为客户都安实例生成id,放置在map里来管理，然后开始读取数据：
void Server::read_msg(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf)
{
if (nread <= 0) {
std::cout << "read error" << uv_err_name(nread) << std::endl;
free(buf->base);
return ;
}
ClientItem *item = (ClientItem *)(client->data);
Server *s = (Server *)item->user_data_;
if (item == nullptr) {
return ;
}
item->pong_time_ = (int64_t) base::Time::Now().ToDoubleT();
WebSocketMsg msg;
if (!item->is_connected_) {
bool rc = msg.fromHandshakePkt(nread, buf->base);
if (!rc) {
s->closeClient(item->id_);
}
else {
item->is_connected_ = true;
item->msg_ = msg;
std::string pkt = msg.toHandshakePkt();
int64_t id = item->id_;
if (pkt.empty()) {
s->closeClient(id);
}
else {
s->writeFrameData(id, pkt);
}
}
}
else {
int rc = item->msg_.fromFrameDataPkt(nread, buf->base);
if (rc > 0) {
s->doWork(item);
}
}
free(buf->base);
}
读取到数据后，首先看是不是第一次连接，如果是第一次连接则解析握手包，回传响应，如果不是第一次读数据，解析数据帧，然后执行。
接着我们来看下dowork做的事情：
void Server::doWork(ClientItem *item)
{
int opcode = item->msg_.requestOpcode();
switch (opcode) {
case WebSocketMsg::WebSocketPkt::OpcodeType_Close:
closeClient(item->id_);
return;
case WebSocketMsg::WebSocketPkt::OpcodeType_Ping:
{
WebSocketMsg msg;
std::string data = msg.toFrameDataPkt("", WebSocketMsg::WebSocketPkt::OpcodeType_Pong);
writeFrameData(item->id_, data);
}
return;
case WebSocketMsg::WebSocketPkt::OpcodeType_Binary:
case WebSocketMsg::WebSocketPkt::OpcodeType_Text:
if (item != nullptr) {
ws_controller_->doWork(item);
}
return;
default:
return ;
}
}
如果是数据类型，则派发给controller处理，其余的在此处处理。
我们会给controller传递写数据的回调函数，当controller有数据写入时可直接调用
writeFrameData:
void Server::writeFrameData(int64_t id, const std::string &data)
{
ClientItem *item = client(id);
if (item == nullptr) {
return ;
}
uv_handle_t *handle = (uv_handle_t *)item->client_;
if (handle == nullptr) {
closeClient(id);
ws_controller_->setItem(nullptr);
}
write_response_t *response = (write_response_t*)malloc(sizeof(write_response_t));
int size = data.size();
alloc_buffer(handle, size, &response->buf_);
for (int i = 0; i < size; ++i) {
response->buf_.base[i] = data.at(i);
}
uv_write((uv_write_t *)response, (uv_stream_t *)handle,
&response->buf_, 1, write_msg_ret);
}
接下来我们看下定时器里做的工作：
void Server::timer_out(uv_timer_t *handle)
{
Server *s = (Server *)handle->data;
const std::map<int64_t, ClientItem> &clientMap = s->clientMap();
if (clientMap.size() == 0) {
return ;
}
auto iter = clientMap.cbegin();
for (;iter != clientMap.cend(); iter++) {
const ClientItem &item = iter->second;
if (item.isDead()) {
s->closeClient(item.id_);
continue ;
}
if (item.isToPing()) {
WebSocketMsg msg;
std::string frame = msg.toFrameDataPkt("", WebSocketMsg::WebSocketPkt::OpcodeType_Ping);
s->writeFrameData(item.id_, frame);
}
}
}
遍历保存客户端实例的map来查看客户端是已经不再存活还是需要我们去ping他，维持心跳。
3
至此我们把大致的代码结构讲解完了，我们最后看些ClientItem的结构
#ifndef __CLIENTITEM_H__
#define __CLIENTITEM_H__
#include <memory>
#include "uv.h"
#include "base/time.h"
#include "WebSocketMsg.h"
struct ClientItem
{
ClientItem(int64_t id, uv_tcp_t *client,
int64_t pong_time = 0, int64_t ping_time = 0) :
id_(id),
client_(client),
pong_time_(pong_time),
ping_time_(ping_time),
is_connected_(false),
user_data_(nullptr) {}
ClientItem() {
reset();
}
bool isDead() const {
if (ping_time_ == 0 || pong_time_ == 0) {
return false;
}
if (ping_time_ - pong_time_ > 10) {
return true;
}
return false;
}
bool isToPing() const {
using namespace base;
base::Time t = base::Time::Now();
int64_t nowSeconds = (int64_t)t.ToDoubleT();
if (nowSeconds - pong_time_ > 5) {
return true;
}
return false;
}
void close();
void reset();
int64_t id_;
uv_tcp_t *client_;
int64_t pong_time_; // s
int64_t ping_time_; // s
bool is_connected_;
void *user_data_;
WebSocketMsg msg_;
};
#endif // __CLIENTITEM_H__
好了，由于业务逻辑那里可以自己定制，我就不再赘述了，篇幅有点长，感谢有时间读完。吐槽csdn的编辑器，让我搞了七八遍
最后附代码下载连接
https://download.csdn.net/download/leapmotion/10835888
