项目：即时群聊通信系统

浅浅的花香味﹌ 2023-06-09 15:24 4阅读 0赞

## 项目简介 ##

● 首先，使用开源**websocket框架mongoose编写网页版本的群聊即时通信工具**；  
● 然后，先完成基本的聊天逻辑,再能够让我们访问数据库，访问我们之前所建立的表；  
● 最后，完成登录逻辑。其中，还要涉及到对**cookie和session的理解**以及**http+mongoose+session+mysql+jsoncpp的技术**的构成，在代码中进行添加，完成IM工具。

## 项目技术点 ##

*  C++11 STL
 *  http协议
 *  **websocket协议**
 *  **session和cookie理解**
 *  mysql c connect
 *  登录注册，session管理
 *  **mongoose框架理解**
 *  **jsoncpp**

--------------------

#### http && websocket协议： ####

*  **HTTP只能被动接受用户的请求**，而**WebSocket可以主动向服务器推送消息**。
 *  WebSocket是**应用层协议**，是**TCP/IP协议的子集**，可实现全双工双向通信，此功能需要浏览器与服务器的支持。
 *  WebSocket协议的建立需要先借助**HTTP协议**，在服务器返回101状态码之后，就可以进行websocket全双工双向通信了，就没有HTTP协议什么事情了。

#### **客户端请求** ####

Get / HTTP/1.1
       Upgrade:websocket
       //Upgrade必须设置为WebSocket，表示在取得服务器响应之后，使用HTTP升级将HTTP协议转换（升级）为WebSocket协议
       Connection:Upgrade
       //Connection必须设置为Upgrade，表示客户端希望连接升级
       Host:example.com
       origin:http://example.com
       sec-WebSocket-Key:sN9cRrP/n9NdMgdcy2VJFQ==
       //随机字符串，用于验证协议是否为WebSocket协议而非HTTP协议
       sec-WebSocket-Version:13

#### **服务器回应** ####

HTTP/1.1 101 Switching Protocols
       //101状态码表示升级协议，在返回101状态码后，HTTP协议完成工作，转换为WebSocket协议。此时就可以进行全双工双向通信
       Upgrade：websocket
       Connection:Upgrade
       sec-WebSocket-Accept:fFBooB7FAkLlXgRSzOBT3v4hq5s=
       //根据Sec-WebSocket-Accept和特殊字符串计算，验证协议是否为WebSocket协议 
       sec-Web

#### websocket框架mongoose:嵌入式Web服务器/嵌入式网络库 ####

●**定义**：

*  **Mongoose是c语言写成的网络库**
 *  它为TCP、UDP、HTTP、WebSocket、CoAP、MQTT实现了**事件驱动型的非阻塞 api**。

● **特性：**

*  具有跨平台、原生支持PicoTCP的嵌入式**TCP/IP协议栈**、支持LWIP嵌入式TCP/IP协议栈；
 *  单线程、异步、非阻塞核心与简单的基于事件的**API特性**。
 *  使**嵌入式网络编程**快速，健壮，轻松。

## 代码实现 ##

#### 1.mongoose基本使用 ####

#include "mongoose.h" 
    static sig_atomic_t s_signal_received = 0; 
    static const char *s_http_port = "8000"; 
    static struct mg_serve_http_opts s_http_server_opts; 
     
    static void signal_handler(int sig_num) {    
    signal(sig_num, signal_handler);  // Reinstantiate signal handler 
    s_signal_received = sig_num; 
    } 
     
    static int is_websocket(const struct mg_connection *nc) {  
     return nc->flags & MG_F_IS_WEBSOCKET; //检测链接是否是websocket的长链接 
     }
     static void broadcast(struct mg_connection *nc, const struct mg_str msg) { 
     //将消息msg通过链接*nc发送出去。 
     struct mg_connection *c;   
     char buf[500];   
     char addr[32];   
     mg_sock_addr_to_str(&nc->sa, addr, sizeof(addr),MG_SOCK_STRINGIFY_IP | MG_SOCK_STRINGIFY_PORT);//我们不用 
     
     snprintf(buf, sizeof(buf), "%s %.*s", addr, (int) msg.len, msg.p);//字符串格式化输出 
     printf("%s\n", buf); /* Local echo. */   
     for (c = mg_next(nc->mgr, NULL); c != NULL; c = mg_next(nc->mgr, c)) { 
     //遍历事件管理器链接的头部 
     //if (c == nc) continue; //这里是不会发给自己，我们要将消息推送给自己，注释掉即可 
     mg_send_websocket_frame(c, WEBSOCKET_OP_TEXT, buf, strlen(buf));   
     } 
     } 
     
    static void ev_handler(struct mg_connection *nc/*那个链接有事件*/,\
                            int ev/*什么事件*/, \ 
                            void *ev_data/*对应事件相关的数据*/) {    
     switch (ev) {      
      case MG_EV_WEBSOCKET_HANDSHAKE_DONE: {  //websocket握手事件完成 
      /* New websocket connection. Tell everybody. */       
      broadcast(nc, mg_mk_str("++ joined")); //给所有链接广播消息 
      break;     
      }     
      case MG_EV_WEBSOCKET_FRAME: {  //正常的websocket数据 
      struct websocket_message *wm = (struct websocket_message *) ev_data;       
      /* New websocket message. Tell everybody. */       
      struct mg_str d = { (char *) wm->data, wm->size};       
      broadcast(nc, d);
      break;     
      }     
      case MG_EV_HTTP_REQUEST: {  //正常的http请求 
      mg_serve_http(nc, (struct http_message *) ev_data, s_http_server_opts);       
      break;     
      }     
      case MG_EV_CLOSE: {        /* Disconnect. Tell everybody. */       
      if (is_websocket(nc)) {          
      broadcast(nc, mg_mk_str("-- left"));       
      }       
      break;     
      }   
      }
    } 
     
    int main(void) {    
    struct mg_mgr mgr; //事件管理器 
    struct mg_connection *nc;
    //捕捉退出信号，程序退出 
    signal(SIGTERM, signal_handler);    
    signal(SIGINT, signal_handler);
    mg_mgr_init(&mgr, NULL); //创建并初始化事件管理器 
     
     nc = mg_bind(&mgr, s_http_port, ev_handler);//绑定端口号，设置回调函数，生成监听链接，类比 
     //listen socket,只不过框架将链接(fd)进行了封装 
     //所有后续链接，共享同一 ev_handler 
     mg_set_protocol_http_websocket(nc);//设置监听链接，支持websocket 
     s_http_server_opts.document_root = ".";  //设置服务器当前工作目录 
     s_http_server_opts.enable_directory_listing = "yes"; 
     
      printf("Started on port %s\n", s_http_port);   
      while (s_signal_received == 0) {      
      mg_mgr_poll(&mgr, 200); //进入事件监听，底层采用select进行事件监听，我们只要知道，有IO事件到来
    //时，会触发我们之前设置的回调函数ev_handler 
    }   
      mg_mgr_free(&mgr); 
      return 0; 
      }

#### 2.理解mongoose框架 ####

**struct mg\_mgr**

//关于事件管理器，我们只要知道它是将所有mg_connection使用链表链接起来即可 
      struct mg_mgr {           
        struct mg_connection *active_connections;//可以理解成链表头部 
      #if MG_ENABLE_HEXDUMP 
        const char *hexdump_file; /* Debug hexdump file path */  
      #endif 
      #if MG_ENABLE_BROADCAST 
        sock_t ctl[2]; /* Socketpair for mg_broadcast() */  
      #endif 
        void *user_data; /* User data */  
        int num_ifaces;   
        int num_calls;  
        struct mg_iface **ifaces; /* network interfaces */  
        const char *nameserver;   /* DNS server to use */  
      };

**struct mg\_connection**

struct mg_connection {  
       struct mg_connection *next, *prev; /* 双链表组织所有链接 */ 
       struct mg_connection *listener;    /* 指向监听链接 */ 
       struct mg_mgr *mgr;                /* 指向事件管理器，可以理解成指向链表头部 */ 
       
       sock_t sock; /* 封装的该链接对应的socket */ 
       int err; 
       union socket_address sa; /* Remote peer address */ 
       size_t recv_mbuf_limit;  /* Max size of recv buffer */ 
       struct mbuf recv_mbuf;   /* 链接的接收缓冲区 */ 
       struct mbuf send_mbuf;   /* 链接的发送缓冲区 */ 
       time_t last_io_time;     /* Timestamp of the last socket IO */ 
       double ev_timer_time;    /* 链接的相关时间事件，后面会使用 */ 
     #if MG_ENABLE_SSL 
       void *ssl_if_data; /* SSL library data. */ 
     #endif 
       mg_event_handler_t proto_handler; /* Protocol-specific event handler */ 
       void *proto_data;                 /* Protocol-specific data */ 
       void (*proto_data_destructor)(void *proto_data); 
       mg_event_handler_t handler; /* 链接事件发生之后对应的回调函数 */ 
       void *user_data;            /* 用户数据 */ 
       union {  122     void *v; 
         /* * the C standard is fussy about fitting function pointers into * void pointers, since some archs might have fat pointers for functions. */ 
         mg_event_handler_t f; 
       } priv_1; 
       void *priv_2; 
       void *mgr_data; /* Implementation-specific event manager's data. */ 
       struct mg_iface *iface; 
       unsigned long flags; //链接特性，注意，这些所有细节全部都是mongoose框架主动或被动设置的 
     /* Flags set by Mongoose , 全都是宏，使用时设置，我们不关心设置*/ 
     #define MG_F_LISTENING (1 << 0) /* This connection is listening */ 
     #define MG_F_UDP (1 << 1) /* This connection is UDP */ 
     #define MG_F_RESOLVING (1 << 2) /* Waiting for async resolver */ 
     #define MG_F_CONNECTING (1 << 3) /* connect() call in progress */ 
     #define MG_F_SSL (1 << 4) /* SSL is enabled on the connection */ 
     #define MG_F_SSL_HANDSHAKE_DONE (1 << 5) /* SSL hanshake has completed */ 
     #define MG_F_WANT_READ (1 << 6) /* SSL specific */ 
     #define MG_F_WANT_WRITE (1 << 7) /* SSL specific */ 
     #define MG_F_IS_WEBSOCKET (1 << 8) /* Websocket 标记，注意！!*/ 
     #define MG_F_RECV_AND_CLOSE (1 << 9) /* Drain rx and close the connection. */ 
       
     /* Flags that are settable by user */ 
     #define MG_F_SEND_AND_CLOSE (1 << 10) /* 发送剩余数据，然后关闭链接 */ 
     #define MG_F_CLOSE_IMMEDIATELY (1 << 11) /* Disconnect */ 
     #define MG_F_WEBSOCKET_NO_DEFRAG (1 << 12) /* Websocket specific */ 
     #define MG_F_DELETE_CHUNK (1 << 13) /* HTTP specific */ 
     #define MG_F_ENABLE_BROADCAST (1 << 14) /* Allow broadcast address usage */ 
       
     #define MG_F_USER_1 (1 << 20) /* Flags left for application */ 
     #define MG_F_USER_2 (1 << 21) 
     #define MG_F_USER_3 (1 << 22) 
     #define MG_F_USER_4 (1 << 23)
     #define MG_F_USER_5 (1 << 24) 
     #define MG_F_USER_6 (1 << 25) 
     }; 
     
    链接flags：     
      每个链接都有flasg位域。有些flags是由mongoose设置的，例如如果用户使用udp://1.2.3.4:5678创建一个出站
      的UDP链接。mongoose会为此链接设置MG_F_UDP标记。其他标志只能由用户事件处理程序设置，告诉mongoose做何种操 作。下面是由事件处理程序设置的链接flags列表：     
      MG_F_FINISHED_SENDING_DATA:告诉mongoose所有数据已经追加到send_mbuf，只要mongoose将数据写入 socket，此链接就会关闭。      MG_F_BUFFER_BUT_DONT_SEND:告诉mongoose追加数据到send_mbuf，但数据要马上发送，因为此数据稍后会被修 改。然后通过清除MG_F_BUFFER_BUT_DONT_SEND标志将数据发送出去。     
      MG_F_CLOSE_IMMEDIATELY:告诉mongoose立即关闭链接，通常在产生错误后发送此事件。     
      MG_USER_1,MG_USER_2,MG_USER_3,MG_USER_4:开发者可用它来存储特定应用程序的状态 下面是由mongoose设置的flags:        MG_F_SSL_HANDSHAKE_DONE:仅使用ssl,在ssl握手完成时设置     
      MG_F_CONNECTING:在mg_connect()调用后链接处于链接状态但未完成链接时设置。     
      MG_F_LISTENING:设置所有监听链接     
      MG_F_UDP:链接是udp时设置。       
      MG_F_WEBSOCKET:链接是websocket时设置。     
      MG_F_WEBSOCKET_NO_DEFRAG:如果用户想关闭websocket的自动帧碎片整理功能，则由用户设置此标记。

● struct mbuf: vim mongoose/mongoose.h +2354  
● struct websocket\_message  
● vim mongoose/mongoose.h +2223  
● vim mongoose/mongoose.c + 4245

#### 3.mongoose基本接口 ####

#define MG_CB(cb, ud) cb, ud 
    //初始化事件管理器 
    void mg_mgr_init(struct mg_mgr *m, void *user_data)； 
    //绑定端口，设置回调 
    struct mg_connection *mg_bind(struct mg_mgr *srv, const char *address,\                                     MG_CB(mg_event_handler_t event_handler, \                                     
    void *user_data)); 
    //设置websocket处理回调函数，我们调用即可 
    void mg_set_protocol_http_websocket(struct mg_connection *nc); 
    //注册对特定页面的处理动作，常见登录和注册 
    void mg_register_http_endpoint(struct mg_connection *nc, const char *uri_path,\           
    MG_CB(mg_event_handler_t handler, void *user_data)); 
    //进入事件循环，事件到来，触发回调，处理事件 
    int mg_mgr_poll(struct mg_mgr *m, int timeout_ms); 
    //释放事件管理器 
    void mg_mgr_free(struct mg_mgr *m); 
    //完成http重定向 
    void mg_http_send_redirect(struct mg_connection *nc, int status_code,\           
    const struct mg_str location,\           
    const struct mg_str extra_headers); //完成http静态网页请求 
    void mg_serve_http(struct mg_connection *nc, struct http_message *hm,\                          
    struct mg_serve_http_opts opts); //返回当前链接的下一个链接 
    struct mg_connection *mg_next(struct mg_mgr *s, struct mg_connection *conn); //发送websocket数据帧 
    void mg_send_websocket_frame(struct mg_connection *nc, int op, const void *data, size_t len); //设置超时闹钟，超时时，特定链接会受到超时事件：
    MG_EV_TIMER double mg_set_timer(struct mg_connection *c, double timestamp);
    //获取当前系统时间戳 
    double mg_time(void); 
    //获取指定http header中的value，比如：Content_Length:1234，可以通过Content_Length，获取1234 
    struct mg_str *mg_get_http_header(struct http_message *hm, const char *name); 
    //解析头部属性信息 
    int mg_http_parse_header2(struct mg_str *hdr, const char *var_name, char **buf,\                           
         size_t buf_size); 
    //返回你想返回的http 
    response int mg_printf(struct mg_connection *conn, const char *fmt, ...);

C++编写mongoose基本框架

*  首先，设计基本框架
 *  然后，先完成基本的聊天逻辑
 *  在能够让我们访问数据库，访问我们之前所建立的表
 *  最后，完成登录逻辑，这里还要涉及到对cookie和session的理解，我们在代码中体现

## 代码实现 ##

[IM相关代码][IM]  
● IM\_Server.hpp IM核心代码  
● ImServer.cc 调用  
● Util.hpp 工具类  
● Makefile  
● 前端代码，寻找模板灵活处理

## 项目功能测试 ##

单元测试：测试每个模块工具是否安装成功，“包名 -v”；文件是否存在  
**功能测试：**

*  **对声音的录入：**

1.  录入时的声源（耳机、麦克风、单/双通道、立体声）
2.  环境影响（室内、室外、回声、安静、嘈杂、雨声等）
3.  距离影响（近场识别、远场识别（待调研人脸与电脑的一般距离范围））
4.  讲话人的语速（快、慢、适中、时快时慢（待调研常人的语速））
5.  音量（大、小、时大时小（待调研常人音量））
6.  音色等（男生、女生、童声（通过对几家语音识别的开放demo进行评测后，发现女声的语音识别准确度要高过于男声））（待调研具体差异和影响）
7.  类型（录音、人声、广播、变声）（待调研具体差异和影响）

*  **识别的内容准确性而言，要考虑：**

1.  语种的覆盖，中文普通话、方言等，英文以及其他的外语、混合方言（就很nice）等
2.  语音的内容覆盖常用词汇、日常对话、衣食住行、新闻资讯等等
3.  不标准的发音(sh和s/ping和pin/L和n/F和H)和吐词等
4.  对话模式，（间隔式、连续式、单人讲话、多人讲话）
5.  关键的指标（识别准确率、转换时间、词库覆盖（比如出了通用词库，是否包含了应用场景比如金融、法律、医疗对应领域的词库训练））

[IM]: https://github.com/jingyu0/Linux_project/commit/39937e734903a169cfb2e06a8ea26e856656473b