关于在tcp或udp上搭载私有协议

最新推荐文章于 2022-11-18 09:22:59 发布
最新推荐文章于 2022-11-18 09:22:59 发布
阅读量3.7k 收藏 4
点赞数 2
分类专栏： 下东西 文章标签： c语言 linux 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014304806/article/details/52799625
版权

很多人都碰到这个问题，需要在tcp或者udp上面搭载私有协议，比如xmodem，和telnet一样，和服务器进行交互。此协议经过测试可以实现32k文件传输。

可以进行再扩充，但是 工作时30k大小足够，所以就没对协议进行修改。

以下是协议内容：

协议相关的控制符：

    SOH             0x01     //包头
    STX             0x02 //开始传输数据
    EOT             0x04
    ACK             0x06
    NAK             0x15
    CAN             0x18
    CTRLZ             0x1A

每个包的长度为

 ___________________________________________________________________________________
|     |            |                  

|  1   |      1  |   1 |   1    |    1    |    256b    |      1   |
| SOH | 剩余包数 | 信息包序号 | 包类别 |   包长度|  数据区段  |  校验和   |
|_____|____________|___________________|__________|____________|___________________


说明：

SOH： 帧的开头字节，代表信息包中的第一个字节；

剩余包数：这个包一共还有几个包未接收。

信息包序号： 对 256取模所得到当前包号，第一个信息包的序号为 1，而信息包序号范围 0~255；

包类别：属于那种类型的数据包

包长度：当前包中有效数据的长度；

　　数据区段： 数据区段的长度固定为 128字节(属于消息内容);

  校验和： 使用的是异或校验；


接收过程：

接收一个包的内容，接收后进行处理（数据校验），处理成功后发送ACK（一个字节）给发送方.否则发送NAK给发送方。

若还存在着包，继续接收这个包。

发送过程：

若发送包的数据小于256b时，多余部分用CTRLZ 进行填充

 发送一个包的内容，等待接收方ACK确认，若没有收到ACK，则重新发送。

若包的内容没有发完，继续发送包。

以下就是源码：我将发送的内容封装成一个包进行发送，，以下是一个包

packet.h,和packet.c

#ifndef _PACKET_H_
#define _PACKET_H_

这个是我定义的协议包类别：
typedef enum _packet_type_t{
    DP_TYPE_SN=0,            /*S 桌牌标号*/
    DP_TYPE_CARD=1,            /*R 桌牌名片*/
    DP_TYPE_SUMMARY=2,        /*R 会议概要(与会人员 会议单位，会议标题 系统时间等)*/
    DP_TYPE_CONTENT_PIC=3,    /*R 会议内容,以图片形式发送*/
    DP_TYPE_CHAPT_PIC=4,    /*R 会议议程，以图片形式*/
    DP_TYPE_SIGN_MSG=5,     /*S 签到消息*/
    DP_TYPE_SCROLL_MSG=6,    /*R 滚动消息*/
    DP_TYPE_SERVER=7,        /*S 发送呼叫服务消息*/
    DP_TYPE_MESSAGE=8,        /*R 服务器下发短信息*/
    DP_TYPE_VOTE_CMD=9,        /*R 服务器发起投票*/
    DP_TYPE_VOTE_RESULT=10,    /*S 发送投票结果*/
    DP_TYPE_UPDAT_DESKCARD =12,//更新桌排
    DP_TYPE_CMD_DOWNLOAD_MESSAGE,//=100,    /*下载系统消息*/
    DP_TYPE_CMD_DOWNLOAD_MEETING_DATA,    /*下载会议数据包*/
    DP_TYPE_CMD_DOWNLOAD_DESK_LOGO,//桌牌名片
    DP_TYPE_CMD_DOWNLOAD_UPG_FW,//下载固件
    DP_TYPE_CMD_HEARTBEAT_PACKET_REQUEST =99,//请求发送一个心跳包
    DP_TYPE_CMD_HEARTBEAT_PACKET_RECEIVE =100,
}T_Packet_Type,*PT_Packet_Type;

enum{
//1代表茶水，2代表纸笔，3代表麦克风，4代表服务人员
    SERVICE_DRINKS=1,
    SERVICE_PEN,
    SERVICE_MIC,
    SERVICE_WAITER
};


extern  int sockfd;
int send_data(T_Packet_Type type,unsigned char *data,int len);
int receive_data(T_Packet_Type *type,unsigned char *data,int *len);

//#define     packet_debug            printf
#define     packet_debug(...)

//使用4 字节的头
#define     USE_HEAD_4

#endif//_PACKET_H_

以下是packet.c的内容:

#include "packet.h"
#include "config.h"

#define            SOH             0x01
#define            STX             0x02
#define            EOT             0x04
#define            ACK             0x06
#define            NAK             0x15
#define            CAN             0x18
#define            CTRLZ           0x1A

#define    PACKET_DATA_LEN            128

#define    RETRY_TIMES                (1)

//一个包的结构体定义，接收时按这个结构体进行接收
typedef struct packet_t{
    unsigned char packet_head;
    unsigned char left_packet_num;
    unsigned char packet_num;
    unsigned char packet_type;
    unsigned char packet_data_len;
    unsigned char data[PACKET_DATA_LEN];
    unsigned char check_sum;
}T_Packet,*PT_Packet;

//进行分包服务的
typedef struct service_list_t{
    T_Packet packet;
    struct service_list_t *next;
}T_Service_List,*PT_Service_List;

//是否是包头
#define  isPacketHead(phead)    (*phead==STX)   

//设置为包头

#define  set_packet_Head(phead) (*(phead))=STX

//调试信息
void debug_print_packet(PT_Packet packet)
{

    printf( "head %d %d %d %d %d ",packet->packet_head,packet->left_packet_num,\
        packet->packet_num,packet->packet_type,packet->packet_data_len);
    printf("   checksum =%d \r\n", packet->check_sum);

}

//最基础的一个发送数据，按发送数据大小进行发送。

int client_tcp_send(unsigned char *buf , int size)
{
    int len;
    int ret = 0,  retry =0;
    do{
        len = send(sockfd, buf, size, 0);
        if(len < 0)
        {
            if(errno == EAGAIN)//无数据读
            {
                ret = 0;
                break ;
            }
            else if(errno == EINTR)//由于信号中断没有读到数据
            {
                ret = 0;
                break ;
            }else
            {
                ret = -1;
                return ret;
            }
        }else if(len == 0)
        {    
            ret = -1;
            return ret;
        }        
        buf += len;
        size -= len;
        ret += len;
    }while(size > 0);

    return ret;
}

//这个fd是否具有可读属性
int sock_can_read(int fd)
{
    int rc;
    fd_set fds;
    static struct timeval out={0,40000};
    FD_ZERO(&fds);
    FD_SET(fd,&fds);

    out.tv_sec  = 0;
    out.tv_usec = 40000;//0.1s
    
    rc = select(fd+1, &fds, NULL, NULL, &out);
    if (rc < 0)   //error
        return -1;    

    return FD_ISSET(fd,&fds) ? 1 : 0;
}

//最基础的一个接收数据，按接收数据大小进行接收。

//返回0 表示 无数据 返回-1 网络错误 返回>0 读取的字节数
int client_tcp_recv(unsigned char *buf, int size)
{    
    int len;
    int ret = 0;
    do{
        if(sock_can_read(sockfd) != 1){
            //printf("no data ret =%d\r\n",ret);
            ret =0;
            break;
        }
        len = recv(sockfd, buf, size, 0);
        if(len < 0)
        {
            if(errno == EAGAIN)//无数据读
            {
                ret = 0;
                break ;
            }
            else if(errno == EINTR)//由于信号中断没有读到数据
            {
                ret = 0;
                break;
            }else
            {
                ret = -1;
                return ret;
            }
        }else if(len == 0)        
        {    
            return ret;
        }        
        buf += len;
        size -= len;
        ret += len;
    }while(size > 0);

    return ret;
}

//每个接收服务都是一个单链表，在接收过程或发送过程中是动态分配的，需要手动释放
static int free_one_service(PT_Service_List list)
{
    if(list)
    {
        free(list);
        list = NULL;
        //list->next = NULL;
    }
}
//添加一个服务包
static int _addOneService(PT_Service_List *phead, PT_Service_List list)
{

    if(list == NULL && phead == NULL)
        return 0;

    PT_Service_List head = *phead;

    if(head == NULL){
        *phead = list;//修改下
        list->next =NULL;
        return 1;
    }

//不是同一个类别不添加
#if 0
    if(head->packet.packet_type != list->packet.packet_type){
        printf("not same type\r\n");
        return 0;
    }
#endif
    while(head->next)
    {
        //printf("next\r\n");
        head = head->next;
    }

    list->next =NULL;
    head->next = list;
    
    return 1;
}

static unsigned char _calculate_check_sum(PT_Packet packet)
{
    unsigned char i =0;
    unsigned check_sum = 0;
    
    check_sum = packet->left_packet_num;
    check_sum ^=packet->packet_num;
    check_sum ^=packet->packet_type;
    check_sum ^=packet->packet_data_len;

    for(i=0;i < PACKET_DATA_LEN ;i++)
    {
        check_sum ^= packet->data[i];
    }

    return check_sum;
}    

static int _free_all_service_list(PT_Service_List list_head)
{
    PT_Service_List phead = list_head,pnext;

    packet_debug("enter _free_all_service_list\r\n");
    if(phead == NULL)
        return 0;
    
    while(phead)
    {
        pnext = phead->next;
        free_one_service(phead);
        phead = pnext;
    }

    packet_debug("exit _free_all_service_list\r\n");
}



//准备一个发送列表包
static PT_Service_List _prepare_send_packet(T_Packet_Type type,unsigned char *data,int len)
{
    if(data == NULL)
        return;
    //int len = strlen(data);
    int index=0;
    int max_index = (len / PACKET_DATA_LEN) + 1;

    PT_Service_List head =NULL ,service_list =NULL;

    packet_debug("max_index =%d \r\n",max_index);
    while(max_index)
    {
        service_list = (PT_Service_List)malloc(sizeof(T_Service_List));
        set_packet_Head(&service_list->packet.packet_head);
        //service_list->packet.packet_head = STX;
        service_list->packet.left_packet_num = max_index-1;
        service_list->packet.packet_num  = index+1;
        service_list->packet.packet_type = (unsigned char)type;
        
        if(max_index == 1)
        {
            memset(service_list->packet.data, CTRLZ, PACKET_DATA_LEN);
            service_list->packet.packet_data_len = len%PACKET_DATA_LEN;
            memcpy(service_list->packet.data , data+index*PACKET_DATA_LEN,service_list->packet.packet_data_len);
        }else{
            service_list->packet.packet_data_len = PACKET_DATA_LEN;
            memcpy(service_list->packet.data , data+index*PACKET_DATA_LEN,PACKET_DATA_LEN);
        }
//计算校验和    
        service_list->packet.check_sum   = _calculate_check_sum(&service_list->packet);
        service_list->next =NULL;
        //debug_print_packet(service_list);
        _addOneService(&head,service_list);
        index++;
        max_index--;
    }

    return head;
}

//等待ack确认 返回值为-1  网络错误
// 返回值为 1  收到ack
//返回值为2 收到nak,
//否则接收失败

//就是发送一个ACK 字符

//发送成功 返回1  发送错误返回0  网络错误返回-1
int _send_packet(PT_Packet  packet)
{
    int ret,retry = RETRY_TIMES;
send_again:
    ret = client_tcp_send((unsigned char*)packet , sizeof(T_Packet));
    if(ret < 0)
        return ret;
    else
    if(ret == sizeof(T_Packet))
        return 1;

    if(retry > 0)
    {
        retry--;
        goto send_again;
    }else{
        
        return 0;//发送失败
    }

    //ack 1
    return 1;
}


static int _send_service_list(PT_Service_List list)
{
    int ret =1;

    while(list){
        //debug_print_packet(&list->packet);
        ret = _send_packet(&list->packet);
        if(ret <= 0)
            break;
        list = list->next;
    }

    return ret;
}


//进行数据包的校验，校验成功返回1 否则返回0
//异或校验
static int _checkSum(PT_Packet packet)
{
    unsigned char i =0;
    unsigned check_sum = 0;

    if(packet ==0 || !isPacketHead(&packet->packet_head)){
    //if(packet ==0 || packet->packet_head != STX){
        //printf("packet =%d packet->packet_head =%d\r\n",packet,packet->packet_head);
        return 0;
    }

    check_sum = packet->left_packet_num;
    check_sum ^=packet->packet_num;
    check_sum ^=packet->packet_type;
    check_sum ^=packet->packet_data_len;

    for(i=0;i < PACKET_DATA_LEN ;i++)
    {
        check_sum ^= packet->data[i];
    }

    //
    if(check_sum == packet->check_sum)
        return 1;
    else{
        printf("check_sum =%d , packet->check_sum =%d \r\n",check_sum,packet->check_sum);
        return 0;
    }
}


//接收 一个数据包接收到了一个数据包返回1  
//网络异常 -1    没有收到一个包，或数据出错返回0
static int _receive_Onepacket(PT_Packet packet)
{
    int ret =0,retry = RETRY_TIMES;
    unsigned char  head;
    unsigned char *ppacket = (unsigned char*)packet;
    ppacket = ppacket + sizeof(head);
read_head:
    ret = client_tcp_recv((unsigned char*)(&head),sizeof(head));
    if(ret < 0)
        return ret;
    
    if(ret != sizeof(head))
        return 0;
    //printf("head =%d\r\n",head);

    if(!isPacketHead(&head)){
        goto read_head;
    }

    packet->packet_head = head;
again:
    ret = client_tcp_recv(ppacket,sizeof(T_Packet)-sizeof(head));

    if(ret < 0)
    {
        return -1;
    }
    
    if(ret != sizeof(T_Packet) - sizeof(head))
        return 0;

    //debug_print_packet( packet);
    if( _checkSum(packet) != 1 ){
        if(retry){
            retry--;
            goto again;
        }else
            return 0;
    }

    return 1;
}

//读取包
/************************************
**************************************
*输入参数: head  设置为空
**************************************
**************************************/
static PT_Service_List receive_service_list(int *err)
{
    PT_Service_List head=NULL,list =NULL;
    static T_Service_List packet;
    int ret;
    unsigned char left_packet_num;
    
    packet.next = NULL;
    ret = _receive_Onepacket(&packet.packet);
    if(ret <= 0){
        head = NULL;
        goto exit;
    }

copy:
    head = (PT_Service_List)malloc(sizeof(T_Service_List));
    if(head)
        memcpy(head,&packet,sizeof(T_Service_List));
    else
        goto exit;
    head->next = NULL;
    //printf("receive_service_list head =%d\r\n",head);
    if(head->packet.left_packet_num <=0)
        goto exit;
//继续进行接收
again:
    list = (PT_Service_List)malloc(sizeof(T_Service_List));
    if(list == NULL){
        _free_all_service_list(head);
        return NULL;
    }
    ret = _receive_Onepacket(&list->packet);
//网络出错  数据出错直接退出。
    if(ret <= 0){
        free(list);
        _free_all_service_list(head);
        head = NULL;
        goto exit;
    }
    else{
        left_packet_num = list->packet.left_packet_num;
        
        //printf("packet data left_packet_num =%d\r\n",left_packet_num);
        //读到了一个包
        if( _addOneService(&head,list) !=1 ){
            printf("add failed\r\n");
        }
        list = NULL;

        if(left_packet_num > 0)
            goto again;
    }
exit:
    *err = ret;
    return head;
}

//成功返回1 失败返回0   网络错误返回 -1
int send_data(T_Packet_Type type,unsigned char *data,int len)
{
    int ret;
    PT_Service_List head = _prepare_send_packet(type,data,len);
    
    ret = _send_service_list(head);
    packet_debug("send_data ret =%d\r\n",ret);
    _free_all_service_list(head);
    
    return ret;
}

int receive_data(T_Packet_Type *type,unsigned char *data,int *len)
{
    int err;
    if(type == NULL || data ==NULL || len == NULL)
        return 0;
    *len = 0;
    int size=0;
    *type = -1;

    PT_Service_List head = receive_service_list(&err);

    if(err < 0)
        return err;
    
    if(head == NULL)
        return 0;

    //printf("head = %d\r\n",head);
    //进行数据的拼接

    *type = head->packet.packet_type;

    while(head)
    {    
        memcpy( data+size ,head->packet.data , head->packet.packet_data_len);
        size += (unsigned char)head->packet.packet_data_len;
        //printf("left_num =%d,len=%d packet_len =%d\r\n",head->packet.left_packet_num,size,head->packet.packet_data_len);
        head = head->next;
    }

    _free_all_service_list(head);

    *len = size;
    return *len;
}

详细参考代码：

看云上有个人
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类TCP/IP私有协议
06-09
将TCP/IP协议从linux内核中摘出来，作为一个独立的模块运行（为与TCP/IP一起运行，我修改了IP协议号和TCP协议号部分，命名为 UCP/UNP，协议簇编号为28，三层协议号修改为0x7800，四层协议号修改为66）。由于时间有限，所以开发出的模块目前只能用于两个主机之间的通信。（我做这项工作最初是考虑用在协议隔离传输上） 测试例子 socketsend.c 发送 sockettest.c接收 其他是模块编译源码 ------------------------------------------------- 使用说明： 编译模块：修改Makefile中的KERNELDIR，指定linux源码路径，然后make 插入模块：insmod my_inet.ko direction=in 另外一端insmod my_inet.ko direction=out 测试：测试采用发文件的方式，请自行修改socketsend.c和sockettest.c中open的文件。编译 然后在out端键入./sockettest 223.255.255.1 在in端键入./socketsend 223.255.255.2 -------------------------------- 模块绑定接口为eth0, 源IP设固定值为223.255.255.1，目的IP设固定值为223.255.255.2。这两个IP地址是虚拟的，与真实的eth0 的IP地址没有任何关系，只要与测试案例中保持一致即可，这两个虚拟IP地址也可以不在同一网段。
私有网络通信协议
08-22
一款用C实现的带协商的私有通信协议, 协议 通信 传输 tcp 服务
python实现一个基于UDP应用层私有协议的通讯，
vera_9的博客
02-01 271
@python。网络应用层协议实现 帮助贴 #python实现一个基于UDP应用层私有协议的通讯，求助大佬指点一二，需要用到什么库，有哪些包环境需要配置和安装。有没有学习资源，学习路径推荐。 主要实现一个基于UDP的工控私有协议，这个协议是应用层协议，有帧结构，跪求资源！ ...
python(42): socket 网络编程自定义私有协议
Python开发分享的博客
07-04 1380
python socket编程（1）
一种基于私有协议的数据传输和解析的方法.pdf
06-09
一种基于私有协议的数据传输和解析的方法.pdf
TCP/UDP网络调试工具
最新发布
01-14
在IT行业中，网络通信是软件开发中的重要环节，TCP（传输控制协议）和UDP（用户数据报协议）作为两种主流的传输层协议，被广泛应用于各种网络应用中。本篇将详细阐述TCP/UDP网络调试工具及其在开发过程中的作用。 ...
TCP/UDP 协议网络调试助手
05-06
TCP/UDP 协议网络调试助手
网络协议调试工具 TCP/UDP测试工具 v2.1.1
11-09
在压缩包"Tcpudp-v2.1.1"中，包含了这个工具的安装文件或者可执行文件。安装或解压后，用户可以根据界面指南或文档指示进行操作，开始进行TCP/UDP的测试和调试工作。 总的来说，TCP/UDP测试工具 v2.1.1是一个强大的...
欧姆龙FinsTCP/UDP模拟器与协议解析文档
09-25
FINS TCP/UDP是FINS协议在网络层面上的应用，它利用了互联网上广泛使用的传输控制协议TCP和用户数据报协议UDP。TCP是一种面向连接的、可靠的传输协议，而UDP则是无连接的、不可靠的数据传输协议。在FINS TCP/UDP中，...
tcp,udp测试工具
12-25
7. 模拟攻击：模拟DDoS（分布式拒绝服务）攻击，测试服务器的抗压能力，评估TCP和UDP协议在受到攻击时的响应。 在实际应用中，了解并掌握TCP和UDP测试工具的使用方法，可以帮助开发者更好地诊断网络问题，优化通信...
海康威视 Ehome协议 Windows 32位 64位 SDK
07-16
Ehome协议是海康威视私有的的设备和服务器通信的一种推模式协议， 适用于支持EHOME协议的网络摄像机、网络球机、DVR、NVR、车载DVR、车载取证系统、单兵、报警主机等设备。 EHOME SDK包含3个组成模块：CMS注册请求模块、预览回放取流模块、报警监听模块。 Windows版32位及64位EHOME协议 V2.1.7.1 包括EHOME SDK使用手册、EHome存储服务器组件集成手册、Demo、头文件、SDK库。
私有RTP协议和标准流媒体协议
hanhan的博客
02-09 1384
先介绍下RTP协议： 实时传输协议RTP（Real-time Transport Protocol）是一个网络传输协议 ，该协议详细说明了在互联网上传递音频和视频的标准数据包格式 。 RTP标准定义了两个子协议 ，RTP和RTCP 数据传输协议RTP，用于实时传输数据。该协议提供的信息包括：时间戳（用于同步）、序列号（用于丢包和重排序检测）、以及负载格式（用于说明数据的编码格式）。 控制协议RTCP，用于QoS反馈和同步媒体流。相对于RTP来说，RTCP所占的带宽非常小，通常只有5%。 TCP会通过超时和重
Netty之私有协议栈开发（五）
青鸟飞鱼
02-02 2988
广义上区分，通信协议可以分为公有协议和私有协议。由于私有协议的灵活性，它往往会在某个公司或者组织内部使用，按需定制，也因为如此，升级起来会非常方便，灵活性好。绝大多数的私有协议传输层都基于TCP/IP，所以利用Netty的NIO/TCP协议栈可以非常方便地进行私有协议的定制和开发。私有协议本质上是厂商内部发展和采用的标准，除非授权，其他厂商一般无权使用该协议。私有协议也称非标准协议，就是未经国际或...
通过修改注册表，实现网页链接中的私有协议启用本地exe进程
weixin_43903378的博客
03-18 476
私有协议为 coffeeclass://xxxxxx.mp4 注册表如下 Windows Registry Editor Version 5.00 [HKEY_CLASSES_ROOT\coffeeclass] @="coffeeClass Protocol" "URL Protocol"="" [HKEY_CLASSES_ROOT\coffeeclass\DefaultIcon] @="D:\\Program Files (x86)\\coffeedrm\\coffeedrmPlayer1.2.8.2
HTTP与私有二进制协议之间的区别
weixin_30722589的博客
08-04 324
简单的文本协议、二进制协议 　　写网络程序躲不过协议，协议其实就是定义了消息的格式，以及消息是如何交换的。协议可简单可复杂，复杂精密如TCP协议，简单奔放如HTTP的协议。这里将我所接触到的协议稍微总结一下，最后抛出一个个人设计的简单通用的文本协议。 　　设计一个协议不是一件很容易的事情，尤其是当对设计的要求包含很好的描述性和可扩展性的时候。如果再将效率考虑在内，则更是件耗脑力的活。在继...
实战Netty！基于私有协议，怎样快速开发网络通信服务？
BASK2311的博客
11-18 490
今天我们一起来来聊聊怎么使用netty，如果对netty感兴趣的小伙伴，可以看看我的Netty专栏。在工作中，我经常使用netty开发一些服务，掌握netty的工作原理，开发一些服务端以及客户端是非常简单，本篇文章，我们就以具体的协议来进行一个简单的服务的开发。
私有通讯协议
博客
03-23 7101
数据包结构 数据包头部：数据包头部是必须的，在粘包的时候可以作为的分隔符进行分包。 数据包长度：数据包长度最好加上，可以判断数据包是否完整。 版本号： 版本号有时也很重要，例如LORA网络中，不同项目之间的数据包可以通过版本号进行甄别。 目的地址：目的地址根据硬件特性决定加不加。例如CAN总线通讯过程中已经有硬件地址，就可以不加。 源地址：源地址根据硬件特性决定加不加。例如CAN总线通讯
TCP通讯socket自定义协议的实现
weixin_34281477的博客
12-04 732
转发(JAVA)：http://blog.csdn.net/u010818425/article/details/53448817 　　　　一个简单的自定义通信协议（socket），http://blog.csdn.net/lincyang/article/details/6109076 　　　　http://vtrtbb.iteye.com/blog/849336 　　　　socket编程...
TCP与UDP：传输层协议解析
"该资源主要探讨了宽带通信网中的IP部分，特别关注TCP和UDP协议。内容涵盖了通信网技术的发展，包括ATM技术、宽带网交换技术、IP网络的QoS支持、网络安全以及MPLS和移动IP技术。在IP网络体系结构与关键技术的讨论中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值