Websocket协议原理及Ws服务器代码实现

简介: Websocket协议原理及Ws服务器代码实现

一、什么是 WebSocket

WebSocket 是 HTML5 开始提供的一种,建立在单个 TCP 连接上的全双工的网络通信协议。WebSocket 协议在2008年诞生,2011年成为国际标准。现在最新版本浏览器都已经支持了。

它的最大特点就是,服务器可以主动向客户端推送信息,客户端也可以主动向服务器发送信息,是真正的双向平等对话,属于服务器推送技术的一种。

熟悉计算机网络协议的人都知道:HTTP 协议是一种无状态的、无连接的、单向的应用层协议。它采用了请求/响应模型。这种通信模型有一个弊端:HTTP 协议无法实现服务器主动向客户端发起消息。

二、WebSocket 应用场景

  • 即时聊天通信
  • 在线协同编辑/编辑
  • 实时数据流的拉取与推送
  • 实时地图位置

三、WebSocket 协议原理及与 HTTP 的关系

WebSocket 协议(以下简称,ws协议),与http协议一样,需要通过已建立的TCP连接来传输数据。具体实现上是先通过http协议建立通道,然后在此基础上用真正ws协议进行通信,所以ws协议和http协议是有一定的交叉关系的。

3.1 ws和Http区别:

相对于 HTTP 这种非持久的协议来说, ws协议是一个持久化协议。举个例子:

HTTP 的生命周期通过 Request 来界定,也就是一个 Request 一个 Response ,那么在 HTTP1.0 中,这次 HTTP 请求就结束了。

在 HTTP1.1 中进行了改进,加了一个 keep-alive。也就是说,在一个 HTTP 连接中,可以发送多个 Request,接收多个 Response。但是,时刻扣住一个点:在 HTTP 中永远是一个 Request 对应一个 Response。而且这个 Response 也是被动的,服务端不能主动发起。

3.2 ws和Http联系:

WebSocket 是基于 HTTP 协议的,或者说借用了 HTTP 协议来完成一部分握手。

四、WebSocket 通信过程

首先我们来看个典型的 WebSocket 握手

4.1 客户端发送ws握手的请求信息如下:

熟悉 HTTP 的道友可能发现了,这段类似 HTTP 协议的握手请求中,多了Upgrade:websocketSec-WebSocket-VersionSec-WebSocket-Key等。这些就是ws协议的核心部分,告诉服务器我发起的请求要用ws协议。其中:

  1. Upgrade:websocket:表示我要用ws协议通信
  2. Sec-WebSocket-Version:是ws版本号。
  3. Sec-WebSocket-Key 是一个 Base64 encode 的值,由浏览器随机生成。
4.2 服务器响应报文示例:

我们先来了解一下,服务器在收到ws握手报文要干什么吧:

4.3 小结:

客户端发起http请求,经过3次握手后,建立起TCP连接(注意:ws在发送握手前,Tcp的连接已经建立,也就是说Tcp的三次握手已经成功)。 ws握手报文里存放ws支持的版本号等信息,如:Upgrade、Connection、WebSocket-Version等;然后,服务器收到客户端的握手请求后,同样采用HTTP协议回馈数据;最后,客户端收到连接成功的消息后,开始借助于TCP传输信道进行全双工通信。

五、Websocket的优缺点

优点:

WebSocket协议一旦建议后,互相沟通所消耗的请求头是很小的

服务器可以向客户端推送消息了

缺点:

少部分浏览器不支持,浏览器支持的程度与方式有区别(IE10)

六、总结

WebSocket 是为了在 web 应用上进行双通道通信而产生的协议,相比于轮询HTTP请求的方式,WebSocket 有节省服务器资源,效率高等优点。

WebSocket 中的掩码是为了防止早期版本中存在中间缓存污染攻击等问题而设置的,客户端向服务端发送数据需要掩码,服务端向客户端发送数据不需要掩码。

WebSocket 中 Sec-WebSocket-Key 的生成算法是拼接服务端和客户端生成的字符串,进行SHA1哈希算法,再用base64编码。WebSocket 协议握手是依靠 HTTP 协议的,依靠于 HTTP 响应101进行协议升级转换。

七、完整代码实现

#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 GUID    "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
enum {
  WS_HANDSHARK = 0,
  WS_TRANMISSION = 1,
  WS_END = 2,
  WS_COUNT
};
struct ws_ophdr {
  unsigned char opcode:4,
        rsv3:1,
        rsv2:1,
        rsv1:1,
        fin:1;
  unsigned char pl_len:7,
          mask:1;
};
#define BUFFER_LENGTH   1024
#define ACCEPT_KEY_LENGTH   64
#define MAX_EPOLL_EVENTS  1024
#define SERVER_PORT     8888
#define PORT_COUNT      1
typedef int NCALLBACK(int ,int, void*);
struct ntyevent {
  int fd;
  int events;
  void *arg;
  int (*callback)(int fd, int events, void *arg);
  int status;
  char buffer[BUFFER_LENGTH]; //request
  int length;
  //long last_active;
  char wbuffer[BUFFER_LENGTH]; //response
  int wlength;
  char sec_accept[ACCEPT_KEY_LENGTH];
  int wsstatus; //0, 1, 2, 3
};
struct eventblock {
  struct eventblock *next;
  struct ntyevent *events;
};
struct ntyreactor {
  int epfd;
  int blkcnt;
  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);
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 ;
}
int nty_event_add(int epfd, int events, struct ntyevent *ev) {
  struct epoll_event ep_ev = {0, {0}};
  ep_ev.data.ptr = ev;
  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;
}
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;
}
// 
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 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;
}
// request
int ws_handshark(struct ntyevent *ev) {
  int idx = 0;
  char sec_data[128] = {0};
  char sec_accept[128] = {0};
  do {
    char linebuf[1024] = {0};
    idx = readline(ev->buffer, idx, linebuf);
    if (strstr(linebuf, "Sec-WebSocket-Key")) {
      strcat(linebuf, GUID);
      SHA1(linebuf+19, strlen(linebuf+19), sec_data);
      base64_encode(sec_data, strlen(sec_data), sec_accept);    
      printf("idx: %d, line: %ld\n",idx, sizeof("Sec-WebSocket-Key: "));
      memcpy(ev->sec_accept, sec_accept, ACCEPT_KEY_LENGTH);
    }
  } while((ev->buffer[idx] != '\r' || ev->buffer[idx+1] != '\n') && idx != -1);
}
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 ws_tranmission(struct ntyevent *ev) {
  struct ws_ophdr *hdr = (struct ws_ophdr *)ev->buffer;
  if (hdr->pl_len < 126) {
    unsigned char *payload = NULL;
    if (hdr->mask) {
      payload = ev->buffer + 6;
      umask(payload, hdr->pl_len, ev->buffer + 2);
    } else {
      payload = ev->buffer + 2;
    }
    printf("payload: %s\n", payload);
  } else if (hdr->pl_len == 126) {
  } else if (hdr->pl_len == 127)  {
  } else {
    //assert(0);
  }
}
int ws_request(struct ntyevent *ev) {
  if (ev->wsstatus == WS_HANDSHARK) {
    ws_handshark(ev);
    ev->wsstatus = WS_TRANMISSION;
  } else if (ev->wsstatus == WS_TRANMISSION) {
    ws_tranmission(ev);
  }
}
int ws_response(struct ntyevent *ev) {
  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);
  return ev->wlength;
}
// connection
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->buffer, BUFFER_LENGTH, 0);
  nty_event_del(reactor->epfd, ev);
  //if (ev->buffer[])
  if (len > 0) {
    ev->length = len;
    ev->buffer[len] = '\0';
    ws_request(ev);
    //printf("recv [%d]:%s\n", fd, ev->buffer);
    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_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;
}
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;
}
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;
  }
  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));
  struct eventblock *block = malloc(sizeof(struct eventblock));
  if (block == NULL) {
    printf("ntyreactor_alloc eventblock failed\n");
    return -3;
  }
  block->events = evs;
  block->next = NULL;
  blk->next = block;
  reactor->blkcnt ++;
  return 0;
}
struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd) {
  if (reactor == NULL) return NULL;
  if (reactor->evblks == NULL) return NULL;
  int blkidx = sockfd / MAX_EPOLL_EVENTS;
  while (blkidx >= reactor->blkcnt) {
    ntyreactor_alloc(reactor);
  }
  int i = 0;
  struct eventblock *blk = reactor->evblks;
  while (i++ != blkidx && blk != NULL) {
    blk = blk->next;
  }
  return &blk->events[sockfd % MAX_EPOLL_EVENTS];
}
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;
}
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;
}
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;
}
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服务期高级架构

相关文章
|
9天前
|
存储 JavaScript 前端开发
webSocket+Node+Js实现在线聊天(包含所有代码)
文章介绍了如何使用WebSocket、Node.js和JavaScript实现在线聊天功能,包括完整的前端和后端代码示例。
42 0
|
23天前
|
移动开发 JSON Java
Jmeter实现WebSocket协议的接口测试方法
WebSocket协议是HTML5的一种新协议,实现了浏览器与服务器之间的全双工通信。通过简单的握手动作,双方可直接传输数据。其优势包括极小的头部开销和服务器推送功能。使用JMeter进行WebSocket接口和性能测试时,需安装特定插件并配置相关参数,如服务器地址、端口号等,还可通过CSV文件实现参数化,以满足不同测试需求。
106 7
Jmeter实现WebSocket协议的接口测试方法
|
7天前
|
安全 JavaScript 网络协议
WebSocket通信协议基础原理与安全威胁
WebSocket通信协议基础原理与安全威胁
24 7
|
1月前
|
机器学习/深度学习 自然语言处理 网络协议
为什么ChatGPT采用SSE协议而不是WebSocket?
在探讨大型语言模型ChatGPT的技术实现时,一个引人注目的细节是其选择使用SSE(Server-Sent Events)协议而非WebSocket来实现数据的实时推送。这一选择背后,蕴含着对技术特性、应用场景及资源效率的深思熟虑。本文将深入探讨ChatGPT为何偏爱SSE,以及这一决策背后的技术逻辑。
51 2
|
2月前
|
前端开发 网络协议 物联网
Django Web:搭建Websocket服务器(入门篇)
Django Web:搭建Websocket服务器(入门篇)
41 1
|
2月前
|
域名解析 存储 缓存
域名服务器 (DNS):工作原理及其优势
【8月更文挑战第19天】
196 0
|
2月前
|
人工智能 安全 Go
Golang 搭建 WebSocket 应用(八) - 完整代码
Golang 搭建 WebSocket 应用(八) - 完整代码
32 0
|
4月前
|
Java 数据安全/隐私保护
深入剖析:Java Socket编程原理及客户端-服务器通信机制
【6月更文挑战第21天】Java Socket编程用于构建网络通信,如在线聊天室。服务器通过`ServerSocket`监听,接收客户端`Socket`连接请求。客户端使用`Socket`连接服务器,双方通过`PrintWriter`和`BufferedReader`交换数据。案例展示了服务器如何处理每个新连接并广播消息,以及客户端如何发送和接收消息。此基础为理解更复杂的网络应用奠定了基础。
54 13
|
4月前
|
缓存 小程序 前端开发
Java服务器端技术探秘:Servlet与JSP的核心原理
【6月更文挑战第23天】Java Web开发中的Servlet和JSP详解:Servlet是服务器端的Java小程序,处理HTTP请求并响应。生命周期含初始化、服务和销毁。创建Servlet示例代码展示了`doGet()`方法的覆盖。JSP则侧重视图,动态HTML生成,通过JSP脚本元素、声明和表达式嵌入Java代码。Servlet常作为控制器,JSP处理视图,遵循MVC模式。优化策略涉及缓存、分页和安全措施。这些技术是Java服务器端开发的基础。
53 9
|
4月前
|
JSON API 数据库
Python使用Quart作为web服务器的代码实现
Quart 是一个异步的 Web 框架,它使用 ASGI 接口(Asynchronous Server Gateway Interface)而不是传统的 WSGI(Web Server Gateway Interface)。这使得 Quart 特别适合用于构建需要处理大量并发连接的高性能 Web 应用程序。与 Flask 类似,Quart 也非常灵活,可以轻松地构建 RESTful API、WebSockets、HTTP/2 服务器推送等。
下一篇
无影云桌面