基于socket简单通信协议实现（c/c++）

最新推荐文章于 2023-10-27 14:35:11 发布
最新推荐文章于 2023-10-27 14:35:11 发布
阅读量2.3k 收藏 6
点赞数
分类专栏： C++
1 场景 
当用socket进行进程通信，传输数据的时候，会出现以下一些情况： 

（1）完整的一条消息被系统拆分成几条发送，例如要发送一条消息：Hello World ，却被系统分成两条消息发送，分别为：Hello 和 World。 

（2）几条独立的消息被系统合成一条消息发送，例如要发送两条消息分别为：a memory from my past和it’s been a year，却被系统和成一条消息发送：a memory from my pastit’s been a year。 

这个时候，需要为socket通信设计一种通信协议，以保证数据的准确性。 

2 协议格式 
通信协议设计如下： 

 
Head：帧头，2个字节，此处为0xa5a5 

Type：通信类型，1个字节，范围0x00~0xff    

Data Length：数据长度，1个字节，即Data的字节总数， 

Data：实际传输的数据，长度不定 

CS：校验值，1个字节，type、data length、data三个域所有字节的异或值，实际中并没用到校验 

End：帧尾，2个字节，此处为0xbeef 



3 程序设计 

3.1    解析思路 
假设socket客户端C和服务端S通信，C向S发送消息M1。 

1、  S收到消息M1。S把消息M1拷贝到缓存Q中，Q为循环队列。假如M1的长度大于Q的剩余空间，则只拷贝剩余空间大小的字节到Q。 

2、  从Q的当前指针开始，查找帧头<Head>。如果找到，则当前指针向后移2个字节位置，继续查找<Type>；如果没找到，则删除前1个字节，当前指针向后移1个字节位置，继续查找<Head> 

3、  从Q的当前指针开始，查找<Type>。如果Q中至少还剩一个字节，则表示找到，当前指针向后移1个字节位置，否则退出解析。 

4、  从Q的当前指针开始，查找<DataLength>。如果Q中至少还剩一个字节，则表示找到，当前指针向后移1个字节位置，否则退出解析。 

5、  从Q的当前指针开始，向后移DataLength个字节位置，查找<End>。如果找到，则从Q中取出一条完整的消息P1，并从Q中删除此消息空间，调用外部的回调函数；否则删除帧头的第一个字节a5，当前指针指向帧头第二个字节a5位置，从步骤2开始，重新一轮解析。 



3.2    数据结构 

查找策略枚举，用于查找时判断查找帧结构的哪个部位： 
C代码   收藏代码
  1. typedef enum{  
  2.     SEARCH_HEAD,  
  3.     SEARCH_TYPE,  
  4.     SEARCH_LEN,  
  5.     //SEARCH_CS,  
  6.     SEARCH_END,  
  7.     SEARCH_NONE  
  8. }cache_strategy;  

消息结构体，用于存储从缓存中解析出的数据： 
C代码   收藏代码
  1. typedef struct{  
  2.     unsigned char data[SOCKET_MSG_SIZE];            //data  
  3.     int len;  
  4.     unsigned char type;  
  5. }socket_msg;  

回调函数，用于从缓存中解析出消息时调用： 
C代码   收藏代码
  1. typedef void (*tp_socket_msg_handle)(int fd, socket_msg *msg,void *args);  

循环队列，用于缓存接收到的数据： 
C代码   收藏代码
  1. typedef struct{  
  2.     unsigned char buf[SOCKET_MSG_CACHE_SIZE]; //buffer for storing data read from client  
  3.     int front;  
  4.     int rear;  
  5.     int current;      
  6.     int len;  
  7.     int tag;            //mark that whether the cache is full,1-full,0-not full  
  8.     cache_strategy strategy;  
  9.     tp_socket_msg_handle handle;//callback function to invoke when a message is parsed out        
  10.     void* args;                                 //external parameter  
  11.     socket_msg recv_msg;                            //parsed message  
  12.       
  13. }socket_cache;  

3.3 关键实现 
1、把接收到的数据存储到缓冲中，并准备解析： 
C代码   收藏代码
  1. //copy the unparsed data to cache, and parsed them  
  2. int socket_msg_pre_parse(  
  3. int fd,   
  4. socket_cache *cache,  
  5. unsigned char *buf,   
  6. int len,   
  7. void *args)  
  8. {  
  9.     int n = 0;  
  10.     unsigned char *p = buf;  
  11.     //when reading buffer's length is greater than cache's left length,  
  12.     //we should copy many times.  
  13.     cache->args = args;  
  14.     while(1){  
  15.         n = socket_msg_cpy_in(cache, p, len);  
  16.         if(n == 0){  
  17.             return FALSE;//cache is full      
  18.         }  
  19.         //parse and handle socket message from cache  
  20.         socket_msg_parse(fd, cache);  
  21.           
  22.         if(n == len){  
  23.             return TRUE; //copy completed  
  24.         }  
  25.         //move the pointer  
  26.         p   = p + n;  
  27.         len = len - n;  
  28.     }  
  29.       
  30.     return TRUE;  
  31.           
  32. }  


2、递归解析消息： 
C代码   收藏代码
  1. //parsed the packaged data, and invoke callback function  
  2. void socket_msg_parse(int fd, socket_cache *cache)  
  3. {  
  4.     int current_len;  
  5.     int p, q;  
  6.     int i;  
  7.     int find;  
  8.       
  9.     if(cache->front == cache->rear && cache->tag == 0){  
  10.         //D("socket cache is empty!\n");  
  11.         return;   
  12.     }  
  13.       
  14.     //calculate the current length of cache  
  15.     if(cache->current >= cache->front){  
  16.         current_len = cache->len - (cache->current - cache->front);  
  17.     }  
  18.     else{  
  19.         current_len = cache->rear - cache->current;     
  20.     }  
  21.       
  22.     switch(cache->strategy){  
  23.         case SEARCH_HEAD://to find a Head format in cache  
  24.             if(current_len < SOCKET_MSG_HEAD_SIZE){  
  25.                 return;   
  26.             }  
  27.             find = FALSE;  
  28.             for(i = 0; i < current_len - 1; i++){  
  29.                 p = cache->current;  
  30.                 q = (cache->current + 1) % SOCKET_MSG_CACHE_SIZE;  
  31.                 if( (cache->buf[p] == (SOCKET_MSG_HEAD >> 8))&&  
  32.                     (cache->buf[q] == (SOCKET_MSG_HEAD & 0xff))){  
  33.                       
  34.                     find = TRUE;  
  35.                     break; //exit for loop  
  36.                 }  
  37.                 else{  
  38.                     //current pointer move to next  
  39.                     cache->current = q;  
  40.                     //delete one item  
  41.                     cache->front = cache->current;  
  42.                     cache->len --;  
  43.                     cache->tag = 0;  
  44.                 }  
  45.             }  
  46.               
  47.             if(find == TRUE){     
  48.                 //move 2 items towards next  
  49.                 cache->current = (cache->current + 2) % SOCKET_MSG_CACHE_SIZE;      
  50.                 //we found the head format, go on to find Type byte  
  51.                 cache->strategy = SEARCH_TYPE;         
  52.             }  
  53.             else{  
  54.                 //if there is no head format ,delete previouse items  
  55.                 LOGE("socket message without head: %x!\n",SOCKET_MSG_HEAD);  
  56.                 //go on to find Head format  
  57.                 cache->strategy = SEARCH_HEAD;     
  58.             }  
  59.             break;  
  60.               
  61.         case SEARCH_TYPE://to find the type byte in cache  
  62.             if(current_len < SOCKET_MSG_TYPE_SIZE){  
  63.                 return ;      
  64.             }  
  65.             //get the value of type  
  66.             //cache->type = cache->buf[cache->current];  
  67.             cache->recv_msg.type = cache->buf[cache->current];  
  68.             cache->current = (cache->current + 1) % SOCKET_MSG_CACHE_SIZE;  
  69.             //we found Type byte, go on to find Datalen format  
  70.             cache->strategy = SEARCH_LEN;  
  71.             break;  
  72.               
  73.         case SEARCH_LEN://to find the datalen byte in cache  
  74.             if(current_len < SOCKET_MSG_LEN_SIZE){  
  75.                 return ;      
  76.             }  
  77.             if(cache->buf[cache->current] > SOCKET_MSG_DATA_SIZE){  
  78.                 LOGE("the data len of message out of size: %d!\n",SOCKET_MSG_DATA_SIZE);  
  79.                 //delete the frist item 'a5'  
  80.                 //move back 2 items  
  81.                 cache->current = cache->current >= 2 ? (cache->current - 2) : (SOCKET_MSG_CACHE_SIZE - 2 + cache->current);  
  82.                 cache->front = cache->current;  
  83.                 //length sub 2  
  84.                 cache->len -= 2;  
  85.                 cache->tag = 0;  
  86.                 //go on to find Head format  
  87.                 cache->strategy = SEARCH_HEAD;  
  88.             }  
  89.             else{  
  90.                 //get the value of datalen  
  91.                 //cache->data_len = cache->buf[cache->current];  
  92.                 cache->recv_msg.len = cache->buf[cache->current];  
  93.                 cache->current = (cache->current + 1) % SOCKET_MSG_CACHE_SIZE;  
  94.                 //we found datalen byte, go on to find End format  
  95.                 cache->strategy = SEARCH_END;  
  96.             }  
  97.             break;  
  98.               
  99.           
  100.               
  101.         case SEARCH_END:  
  102.             if(current_len < (cache->recv_msg.len + SOCKET_MSG_END_SIZE)){  
  103.                 return;   
  104.             }  
  105.             //because we have known the data bytes' len, so we move the very    
  106.             //distance of datalen to see if there is End format.   
  107.             p = (cache->current + cache->recv_msg.len) % SOCKET_MSG_CACHE_SIZE;   
  108.             q = (cache->current + cache->recv_msg.len + 1) % SOCKET_MSG_CACHE_SIZE;   
  109.             if( (cache->buf[p] == (SOCKET_MSG_END >> 8))&&  
  110.                 (cache->buf[q] == (SOCKET_MSG_END & 0xff)) ){  
  111.                 socket_msg_cpy_out(cache, cache->recv_msg.data, cache->current, cache->recv_msg.len);  
  112.                 if(cache->handle != NULL){  
  113.                     //cache->handle(fd, cache->buf + cache->data_index, cache->data_len);  
  114.                     cache->handle(fd, &cache->recv_msg, cache->args);    
  115.                 }  
  116.                 //delete all previous items  
  117.                 cache->current = (q + 1) % SOCKET_MSG_CACHE_SIZE;  
  118.                 cache->front = cache->current;  
  119.                 cache->len -= (cache->recv_msg.len + SOCKET_MSG_FORMAT_SIZE);  
  120.                 cache->tag =0;  
  121.                   
  122.             }  
  123.             else{  
  124.                 LOGE("socket message without end: %x!\n",SOCKET_MSG_END);  
  125.                 //delete the frist item 'a5'  
  126.                 //move back 3 items  
  127.                 cache->current = cache->current >= 3 ? (cache->current - 3) : (SOCKET_MSG_CACHE_SIZE - 3 + cache->current);  
  128.                 cache->front = cache->current;  
  129.                 //length sub 3  
  130.                 cache->len -= 3;  
  131.                 cache->tag = 0;  
  132.                       
  133.             }  
  134.             //go on to find Head format  
  135.             cache->strategy = SEARCH_HEAD;  
  136.             break;  
  137.               
  138.         default:  
  139.                 break;  
  140.                   
  141.                   
  142.     }  
  143.       
  144.     //parse new socket message  
  145.     socket_msg_parse(fd,cache);  
  146. }  
冷月宫主
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于C++实现（控制台）Socket 接口实现自定义协议通信【100010754】
02-09
实验内容 根据自定义的协议规范，使用 Socket 编程接口编写基本的网络应用软件。 掌握 C 语言形式的 Socket 编程接口用法，能够正确发送和接收网络数据包。 开发一个客户端，实现人机交互界面和与服务器的通信。 开发一个服务端，实现并发处理多个客户端的请求。 程序界面不做要求，使用命令行或最简单的窗体即可。 功能要求如下： 运输层协议采用 TCP 客户端采用交互菜单形式，用户可以选择以下功能： a) 连接：请求连接到指定地址和端口的服务端。 b) 断开连接：断开与服务端的连接。 c)获取时间: 请求服务端给出当前时间。 d)获取名字：请求服务端给出其机器的名称。 e)活动连接列表：请求服务端给出当前连接的所有客户端信息（编号、IP 地址、端口等） f)发消息：请求服务端把消息转发给对应编号的客户端，该客户端收到后显示在屏幕上 g) 退出：断开连接并退出客户端程序 3.服务端接收到客户端请求后，根据客户端传过来的指令完成特定任务： a)向客户端传送服务端所在机器的当前时间。 b)向客户端传送服务端所在机器的名称。 c)向客户端传送当前连接的所有客户端信息。 d)将某客户端发送过来的内容转发给指定编号的其他客户端。 e)采用异步多线程编程模式，正确处理多个客户端同时连接，同时发送消息的情况。 根据上述功能要求，设计一个客户端和服务端之间的应用通信协议。 本实验涉及到网络数据包发送部分不能使用任何的 Socket 封装类，只能使用最底层的 C 语言形式的 Socket API。 本实验可组成小组，服务端和客户端可由不同人来完成。
C实现基于Socket实现自定义协议通信
05-14
掌握C语言形式的Socket编程接又用法，能够正确发送和接收网络数据包; 分为客户端和服务端
C++ 帧封装与帧解析
10-19
花了一周时间做的，网上已经有类似资源，但没有封装，而且本代码跟网上已有资源绝不雷同。
C++基于TCP和UDP的socket通信
12-22
以下是关于socket编程的一个非常经典的例子: 　　服务端： #include #include //windows socket的头文件 #pragma comment( lib， "ws2_32.lib" )// 链接Winsock2.h的静态库文件 void main() { //初始化winsocket WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD( 1， 1 );//第一个参数为低位字节；第二个参数为高位
基于SSL的复制
chunciqin6314的博客
02-24 92
1、将Master服务器自己做成CA服务器 [root@master~]#cd/etc/pki/CA/ [root@masterCA]#(umask077;opensslgenrsa-outprivate/cakey.pem2048) [root@masterCA]#o...
基于socket简单通信协议实现
热门推荐
达闻东的专栏
06-16 2万+
1 场景 当用socket进行进程通信，传输数据的时候，会出现以下一些情况： （1）完整的一条消息被系统拆分成几条发送，例如要发送一条消息：Hello World ，却被系统分成两条消息发送，分别为：Hello 和 World。 （2）几条独立的消息被系统合成一条消息发送，例如要发送两条消息分别为：a memory from my past和it’s been a year，却被系统和成一条
socks协议详解
鸥鹭忘机
07-17 3098
Socks（Socket Secure）协议是一种网络协议，处于会话层，用于管理网络连接并提供安全性和隐私保护。通过使用Socks代理服务器，客户端可以隐藏其真实IP地址和其他身份信息，从而匿名地访问互联网上的资源。这篇文章介绍了Socks协议的基本概念和连接过程。Socks协议是一种网络协议，位于会话层，用于管理网络连接并提供安全性和隐私保护。文章详细介绍了Socks客户端和服务器之间建立连接的步骤。此外，文章还介绍了Socks协议中常用的数据包格式和状态码，以及Socks协议的应用场景和优势。
C++: Socket 定义与数据结构
belien
03-14 432
C++： socket 通讯，从客户端到服务端之间的转换交互总结
使用socket实现简单的客户端和服务端通信(C#语言)
wangjijun0807的专栏
05-17 4203
1.主要思路： (1) 服务端开启监听线程，等待客户端的连接。 每个socket连接放到独立线程中处理。 (2) 服务端和客户端使用约定的消息格式通信。对于比较复杂的消息(如向服务端传递一个实例)，可以使用json封装传输。 (3) 每个连接的客户端，注册唯一的ClientID，在服务端以此来区分消息的来源。 2.代码构成 实现该样例包含两个cs的客户端程序。 分别为 服务
typedef隐藏句柄
qq_43637548的博客
10-27 57
类型来声明变量，而无需了解句柄的具体内容。这样可以有效地隐藏实现细节，提供更好的封装性和抽象性。，并实现了创建句柄、使用句柄和销毁句柄的函数。这些函数内部可以直接访问句柄结构体的成员变量。这样，用户在使用该句柄时只需要知道它是一个指针类型，而无需知道具体的结构体定义。关键字来定义一个句柄类型，以隐藏句柄的具体实现细节。指针，可以在头文件中隐藏具体的结构体定义，只暴露句柄类型给用户。实现文件中，我们定义了一个具体的句柄结构体。下面是一个示例，展示了如何使用。的句柄类型，它被定义为。在C语言中，可以使用。
S/KEY协议的简单模拟（C语言）
04-25
对S/KEY协议的简单模拟（其中的哈希函数都懒的写，直接调用的rand），C语言代码，通过DEV-C++编译，献给写实验报告的童鞋。
Windows下基于socket多线程并发通信的实现
04-07
本文介绍了在Windows 操作系统下基于TCP/IP 协议Socket 套接口的通信机制以及多线程编程知识与技巧，并给出多线程方式实现多用户与服务端(C/S)并发通信模型的详细算法，最后展现了用C++编写的多用户与服务器通信的...
Android开发之Socket通信传输简单示例
01-05
本文实例讲述了Android Socket通信传输实现方法。分享给大家供大家参考，具体如下： 1.开篇简介 Socket本质上就是Java封装了传输层上的TCP协议（注：UDP用的是DatagramSocket类）。要实现Socket的传输，需要构建...
Android——Keymaster安全检测
Leslie_Yu的博客
11-08 9076
Keymaster 概述 &nbsp;&nbsp;&nbsp;工作以来，一直在负责Android系统安全漏洞的跟踪以及修复。最近在处理Android O以上机器的时候遇到了一个坑。当你的升级系统时，如果后一个系统中修改了如：系统版本、系统安全补丁日期等重要信息，系统在未双清升级后，就会处于锁定状态，如下图所示。 &nbsp;&nbsp;&nbsp;遇到这个问题，解决方式只有一个，就是进入reco...
Android 7 Nougat 源码目录结构
ji_yong_cun的博客
02-06 2793
Google 地图 API V3 使用入门1
manbufenglin的专栏
03-04 1502
Hello, World 要开始了解 Google Maps API，最简单的方法就是查看简单的示例。以下网页显示了一张以澳大利亚新南威尔士的悉尼为中心的地图： html { height: 100% } body { height: 100%; margin: 0; padding: 0 } #map_canvas { h
typedef void (*T) (void *);
海涛高软
12-13 2538
typedef void (T) (void );定义了一个指向函数的指针T，其返回值 void 类型把void (T)和(void )等同起来// 网络消息结构体 typedef bool (*msg_handle)(const char* pMsg, int n32MsgLength, INetSession* vthis, int n32MsgID);// 网络消息节点，解析网络数据==>网络
c语言自定义tcp协议实现socket通信(windows版本)
feinifi的博客
03-08 2271
前面一篇博客介绍了mac/linux下通过C语言自定义协议实现socket通信的示例，因为大部分api与windows还有很多区别，这里就特意把windows下的tcp通信实例给介绍一下。 无论是linux，还是windows，其实c语言都是默认小端序，这个需要注意，还有一个就是结构体的内存对齐问题也是存在的，所以协议结构体我们需要注意他的大小就行了，在进行拷贝的时候，不能直接使用sizeof来计算发送数据的长度。 因为是windows，所以我们可以通过网络小助手来模拟一个服务端...
springboot(酒店管理系统)
最新发布
04-25
开发语言：Java JDK版本：JDK1.8（或11） 服务器：tomcat 数据库：mysql 5.6/5.7（或8.0） 数据库工具：Navicat 开发软件：idea 依赖管理包：Maven 代码+数据库保证完整可用，可提供远程调试并指导运行服务（额外付费）～ 如果对系统的中的某些部分感到不合适可提供修改服务，比如题目、界面、功能等等... 声明： 1.项目已经调试过，完美运行 2.需要远程帮忙部署项目，需要额外付费 3.本项目有演示视频，如果需要观看，请联系我 4.调试过程中可帮忙安装IDEA，eclipse，MySQL，JDK，Tomcat等软件 重点： 需要其他Java源码联系我，更多源码任你选，你想要的源码我都有！ 需要加v19306446185
MFC+Winsock实现基于TCP协议的C/S聊天程序C++
04-04
本文将介绍如何使用MFC Winsock库实现基于TCP协议的C/S聊天程序。该程序包括一个服务器端和一个客户端，客户端可以与服务器端进行连接并发送消息，服务器端可以接收客户端发送的消息并将其广播给所有连接的客户端。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值