Revolver源码解析之——RUDP Socket类实现解析

最新推荐文章于 2024-07-21 11:08:24 发布
最新推荐文章于 2024-07-21 11:08:24 发布
阅读量1.5k 收藏 4
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40825228/article/details/81006925
版权

1、类间关系类图。

【1】类间关系。


【2】类图。


2、Socket的完成的概功能解析。

2.1、模仿TCP绑定端口并监听端口。

void RUDPSocket::reset()
{
    if(state_ != RUDP_IDLE)
    {
        RUDP_DEBUG("state = RUDP_IDLE, rudp id = " << rudp_id_);
        state_ = RUDP_IDLE; 
    }

    rudp_id_ = -1;
    local_index_ = INVALID_ADAPTER_INDEX;
    local_title_ = 0;

    remote_rudp_id_ = INVALID_RUDP_HANDLE;

    heart_ts_ = CBaseTimeValue::get_time_value().msec();
    keeplive_intnal_ = DEFAULT_KEEPLIVE;
    keeplive_count_ = 0;
    timeout_count_ = DEFAULT_TIMEOUT_COUNT;

    event_handler_ = NULL;

    error_code_ = RUDP_SUCCESS;

    send_count_ = 0;

    cancel_timer();

    ccc_.reset();

    send_buffer_.reset();
    recv_buffer_.reset();

    check_sum_ = 0;
}

[1].重置rudp_socket类的各个成员变量。

[2].打开socket。

int32_t RUDPSocket::open(int32_t rudp_id)
{
    reset();

    rudp_id_ = rudp_id;

    return 0;
}

[3].绑定。

int32_t RUDPSocket::bind(uint8_t index, uint8_t title)
{
    if(rudp_id_ == -1 || state_ != RUDP_IDLE)
    {
        RUDP_FATAL("rudp socket bind failed!");
        error_code_ = RUDP_BIND_FAIL;
        return -1;
    }

    local_index_ = index;
    local_title_ = title;

    return 0;
}

[4].与远端建立连接。

int32_t RUDPSocket::connect(const Inet_Addr& remote_addr)
{
    if(rudp_id_ == INVALID_RUDP_HANDLE || state_ != RUDP_IDLE 
        || local_index_ == 255 || remote_rudp_id_ != INVALID_RUDP_HANDLE)
    {
        RUDP_FATAL("rudp connect failed! rudp socket id = " << rudp_id_);
        error_code_ = RUDP_CONNECT_FAIL;
        return -1;
    }

    remote_addr_ = remote_addr;
    check_sum_ = rand() % 65536; //产生一个会话的CHECK SUM

    RUDP_INFO("state = RUDP_CONNECTING, rudp id = " << rudp_id_ << ", remote addr = " << remote_addr_);
    set_state(RUDP_CONNECTING);

    RUDP_DEBUG("send syn, rudp socket id = " << rudp_id_);
    send_syn();
    ccc_.init(send_buffer_.get_buffer_seq() - 1);
    set_timer(CONNECT_DELAY);
    send_count_ ++;

    return 0;
}

主动建立连接的一端向被动接受连接的一端发送SYN包（主动建立连接包）。

[5].被动接受连接的一端处理SYN包。

void RUDPSocket::process_syn(RUDPSynPacket& syn, const Inet_Addr& remote_addr)
{
    RUDP_INFO("recv syn from " << remote_addr << ", rudp id = " << rudp_id_);

    if(state_ == RUDP_IDLE && rudp_id_ != INVALID_RUDP_HANDLE)
    {
        uint64_t now_timer = CBaseTimeValue::get_time_value().msec();
        //初始化接收SEQ
        recv_buffer_.set_first_seq(syn.start_seq_);
        recv_buffer_.set_send_last_ack_ts(now_timer);

        ccc_.init(send_buffer_.get_buffer_seq() - 1);
        //设置连接信息
        remote_addr_ = remote_addr;
        remote_rudp_id_ = syn.local_rudp_id_;

        RUDP_INFO("sart seq = " << syn.start_seq_ << ", remote_rudp_id = " << remote_rudp_id_);

        RUDP_DEBUG("send syn2, rudp socket id = " << rudp_id_);
        send_syn2(0, syn.local_ts_);

        RUDP_INFO("state = RUDP_CONNECTED, rudp id = " << rudp_id_);
        set_state(RUDP_CONNECTED);

        //发送一个KEEPLIVE
        RUDP_DEBUG("send keeplive, rudp socket id =" << rudp_id_);
        send_keeplive(now_timer);
    }
    else if(state_ == RUDP_CONNECTING || state_ == RUDP_CONNECTED)
    {
        RUDP_INFO("send syn2, rudp socket id = " << rudp_id_);
        send_syn2(0, syn.local_ts_);
    }
    else
    {
        RUDP_DEBUG("send syn2(ERROR_SYN_STATE), rudp socket id = " << rudp_id_);
        send_syn2(ERROR_SYN_STATE, syn.local_ts_);
        RUDP_INFO("state = RUDP_CLOSE, rudp id = " << rudp_id_);
        set_state(RUDP_CLOSE);
    }
}

[6].被动接受连接的一端发送SYN对应的返回包，即SYN2包。

void RUDPSocket::send_syn2(uint8_t result, uint64_t remote_ts)
{
    RUDPHeadPacket head;
    head.msg_id_ = RUDP_SYN2;
    head.remote_rudp_id_ = remote_rudp_id_;
    head.check_sum_ = check_sum_;

    RUDPSyn2Packet syn2;
    syn2.version_ = RUDP_VERSION;
    syn2.local_rudp_id_ = rudp_id_;
    syn2.local_ts_ = CBaseTimeValue::get_time_value().msec();
    syn2.remote_ts_ = remote_ts;
    syn2.syn2_result_ = result;
    syn2.max_segment_size_ = MAX_SEGMENT_SIZE;
    syn2.start_seq_ = send_buffer_.get_buffer_seq();

    strm_.rewind(true);
    strm_ << local_title_ << head << syn2;

    for(uint8_t i = 0; i < 3; ++i)
        RUDP()->send_udp(local_index_, strm_, remote_addr_);
}

[7].主动建立连接的一端处理SYN2包。

void RUDPSocket::process_syn2(BinStream& strm, const Inet_Addr& remote_addr)
{
    RUDP_INFO("recv syn2 from " << remote_addr << ", rudp id = " << rudp_id_);

    PARSE_RUDP_MESSAGE(strm, RUDPSyn2Packet, syn2, "parse syn2 failed!");
    if(state_ == RUDP_CONNECTING)
    {
        if(syn2.syn2_result_ != 0x00) //连接异常
        {
            RUDP_INFO("syn failed! syn2.syn2_result_ = " << (uint16_t)syn2.syn2_result_);

            if(event_handler_ != NULL)
            {
                RUDP_INFO("state = RUDP_FIN2_STATE, rudp id = " << rudp_id_);
                set_state(RUDP_FIN2_STATE);
                event_handler_->rudp_exception_event(rudp_id_);
            }
            else
            {
                RUDP_INFO("state = RUDP_CLOSE, rudp id = " << rudp_id_);
                set_state(RUDP_CLOSE);
            }

            return ;
        }
        //设置接收BUFF的初始化
        //ccc_.init(syn2.start_seq_ - 1);
        recv_buffer_.set_first_seq(syn2.start_seq_);
        //设置连接信息
        remote_addr_ = remote_addr;
        remote_rudp_id_ = syn2.local_rudp_id_;

        //计算RTT
        uint64_t now_ts = CBaseTimeValue::get_time_value().msec();
        uint32_t rtt = static_cast<uint32_t>(now_ts > syn2.remote_ts_ ? (now_ts - syn2.remote_ts_) : 5);
        recv_buffer_.set_send_last_ack_ts(now_ts);
        ccc_.set_rtt(rtt);

        RUDP_INFO("syn succ, sart seq = " << syn2.start_seq_ << ", remote_rudp_id = " << remote_rudp_id_ << ", rtt = " << rtt);

        RUDP_INFO("state = RUDP_CONNECTED, rudp id = " << rudp_id_);
        set_state(RUDP_CONNECTED);

        RUDP_DEBUG("send syn ack, rudp socket id = " << rudp_id_);
        send_syn_ack(0, syn2.local_ts_);

        //触发一个写事件
        if(event_handler_ != NULL)
            event_handler_->rudp_output_event(rudp_id_);

        heart_ts_ = now_ts;
    }
    else if(state_ == RUDP_CONNECTED)
    {
        RUDP_DEBUG("send syn ack, rudp socket id = " << rudp_id_);
        send_syn_ack(0, syn2.local_ts_);
    }
}

[8].主动建立连接的端发送SYN2的ACK包。

void RUDPSocket::send_syn_ack(uint8_t result , uint64_t remote_ts)
{
    RUDPHeadPacket head;
    head.msg_id_ = RUDP_SYN_ACK;
    head.remote_rudp_id_ = remote_rudp_id_;
    head.check_sum_ = check_sum_;

    RUDPSyn2AckPacket syn_ack;
    syn_ack.result_ = result;
    syn_ack.remote_ts_ = remote_ts;

    strm_.rewind(true);
    strm_ << local_title_ << head << syn_ack;

    RUDP()->send_udp(local_index_, strm_, remote_addr_);
}

经历了上述步骤，一个RUDP连接正式建立。

2.2 发送数据与心跳包。

[1].发送数据。

int32_t RUDPSocket::send(const uint8_t* data, int32_t data_size)
{
    if(state_ != RUDP_CONNECTED || data_size <= 0)
    {
		RUDP_FATAL("send failed! state_ != RUDP_CONNECTED or data size = 0, rudp id = " << rudp_id_ << ", state =" << state_);
        error_code_ = RUDP_SEND_ERROR;
        return -1;
    }

    int32_t ret = send_buffer_.send(data, data_size);
    if(ret <= 0)
    {
        RUDP_INFO("send buffer is full, rudp socket id = " << rudp_id_);
        error_code_ = RUDP_SEND_EAGIN;
    }

    return ret;
}

[2].处理接收的数据片。

void RUDPSocket::process_data(BinStream& strm, const Inet_Addr& remote_addr)
{
    if(state_ != RUDP_CONNECTED)
    {
        RUDP_WARNING("process data, state != RUDP_CONNECTED");
        return ;
    }

    RUDPData data;
    strm >> data;

    ccc_.on_ack(data.ack_seq_id_);
    send_buffer_.on_ack(data.ack_seq_id_);

    uint32_t data_size  = 0;
    strm >> data_size;

    recv_buffer_.on_data(data.cur_seq_id_, (const uint8_t *)strm.get_rptr(), data_size);
}
void RUDPSocket::send_nack(uint64_t base_seq_id, const LossIDArray& ids)
{
    if(state_ != RUDP_CONNECTED || remote_rudp_id_ < 0)
    {
        RUDP_WARNING("send nack failed! rudp socket id = " << rudp_id_);
        return ;
    }

    RUDPHeadPacket head;
    head.msg_id_ = RUDP_DATA_NACK;
    head.remote_rudp_id_ = remote_rudp_id_;
    head.check_sum_ = check_sum_;

    RUDPDataNack nack;
    nack.base_seq_ = base_seq_id;
    nack.loss_ids_ = ids;

    strm_.rewind(true);
    strm_ << local_title_ << head << nack;

    RUDP()->send_udp(local_index_, strm_, remote_addr_);
}

[3].发送可靠数据的确认。

void RUDPSocket::process_data_ack(BinStream& strm, const Inet_Addr& remote_addr)
{
    if(state_ != RUDP_CONNECTED)
    {
        RUDP_WARNING("process_data_ack, state_ != RUDP_CONNECTED");
        return ;
    }

    //RUDP_DEBUG("on recv data ack, remote_addr = " << remote_addr);
    RUDPDataAck ack;
    strm >> ack;

    ccc_.on_ack(ack.ack_seq_id_);
    send_buffer_.on_ack(ack.ack_seq_id_);
}

[4].发送nack包。

void RUDPSocket::send_nack(uint64_t base_seq_id, const LossIDArray& ids)
{
    if(state_ != RUDP_CONNECTED || remote_rudp_id_ < 0)
    {
        RUDP_WARNING("send nack failed! rudp socket id = " << rudp_id_);
        return ;
    }

    RUDPHeadPacket head;
    head.msg_id_ = RUDP_DATA_NACK;
    head.remote_rudp_id_ = remote_rudp_id_;
    head.check_sum_ = check_sum_;

    RUDPDataNack nack;
    nack.base_seq_ = base_seq_id;
    nack.loss_ids_ = ids;

    strm_.rewind(true);
    strm_ << local_title_ << head << nack;

    RUDP()->send_udp(local_index_, strm_, remote_addr_);
}

[5].处理nack包。

void RUDPSocket::process_data_nack(BinStream& strm, const Inet_Addr& remote_addr)
{
    if(state_ != RUDP_CONNECTED)
    {
        RUDP_WARNING("process_data_nack, state_ != RUDP_CONNECTED");
        return ;
    }

    RUDPDataNack nack;
    strm >> nack;

    send_buffer_.on_nack(nack.base_seq_, nack.loss_ids_);
    ccc_.on_loss(nack.base_seq_, nack.loss_ids_);

    ccc_.on_ack(nack.base_seq_);
    send_buffer_.on_ack(nack.base_seq_);
}

aiYuqiong
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
paddle 56 将图像分类模型嵌入到目标检测中并实现端到端的部署（用图像分类模型进行目标检测切片分类）
a486259的博客
12-24 1387
目标检测在功能上一直是涵盖了图像分类的，其包含目标切片检测，目标切片分类。由于某些原因，需要将目标检测的功能退化为检测，忽略其切片分类，使用外部的分类模型。然而这样操作会使得其与原始的部署代码不兼容，为此博主实现将图像分类模型嵌入到目标检测中，并实现端到端的部署。这里以ppyoloe模型为改造案例，关于图像分类模型可以使用任意PaddleClas支持的模型。关于构造PaddleClas模型可以查阅。
TF-IDF算法解析与Python实现
热门推荐
白马负金羁
05-23 5万+
TF-IDF是一种用于信息检索与文本挖掘的常用加权技术。例如当手头有一些文章时，我们希望计算机能够自动地进行关键词提取。而TF-IDF就是可以帮我们完成这项任务的一种统计方法。它能够用于评估一个词语对于一个文集或一个语料库中一份文档的重要性。本文基于自然语言处理中的一些方法，利用Python实现 TF-IDF算法，并讨论Scikit-Learn中的相关函数。
RUDP源码
05-26
一个rup协议,能解决如下问题: 1. lost; never delivered 2. partially destroyed (data corruption) 3. delivered out of order 4. duplicated 参看http://www.codeplex.com/RUDP/SourceControl/ListDownloadableCommits.aspx
简单的可靠udp的实现（RUDP）
qq_37200329的博客
08-25 1551
可靠的概念 在实时通信过程中，不同的需求场景对可靠的需求是不一样的，我们在这里总体归纳为三类定义： 尽力可靠：通信的接收方要求发送方的数据尽量完整到达，但业务本身的数据是可以允许缺失的。例如：音视频数据、幂等性状态数据。 无序可靠：通信的接收方要求发送方的数据必须完整到达，但可以不管到达先后顺序。例如：文件传输、白板书写、图形实时绘制数据、日志型追加数据等。 有序可靠：通信接收...
【网络】socket和udp协议
最新发布
m0_70088010的博客
07-21 1027
socket和udp协议
可靠协议RUDP源码
05-15
UDP实现的可靠通信协议，仿照TCP可靠性的JAVA实现
一个老外写的RUDP的源代码
06-29
http://blog.csdn.net/u014630768/article/details/34929689 系列文章的源代码
C++高性能服务框架revolver：RUDP(可靠UDP)算法详解
互联网
03-19 847
上一篇BLOG已经介绍了revolver RUDP的传输性能、基本的框架和接口，这篇文章我重点讲述RUDP的实现细节。在RUDP的模块中最为重要的是其收发缓冲控制和CCC发送窗口控制、CCC发送慢启动控制、CCC快恢复控制等几个过程。（关于RUDP源代码实现在revolver开源项目的RUDP目录:点击打开链接） 数据块定义 在RUDP模块中，所有发送的数据被定义成RUDPRecvSeg...
blue_revolver
09-02
blue_revolver
Revolver Tabs - Kangal Edition-crx插件
04-03
语言:English 左轮手枪标签-Kangal版 使用“ Kangal”功能自动旋转打开的标签。 此版本特别为Yiğido制作。 每个小时的第58分钟，您可以显示一个有关Sivas或Kangal的网站。 会议纪要和网站可以自定义。...
DM - Tab Revolver-crx插件
04-03
dm - tab revolver是一个最先进的选项卡切换器，允许您设置选择的选项卡的幻灯片 dm - tab revolver是一种状态 - - 艺术选项卡切换器，允许您设置您选择的选项卡的幻灯片。它是高度可定制的功能将满足您的个人需求...
RUDP源代码
09-10
RUDP源代码 很不错
rudp 高性能，可靠性传输UDP网络库（远胜TCP）
01-19
rudp 高性能，可靠性传输UDP网络库（远胜TCP）
RUDP C++协议
06-27
借鉴其他版本的RUDP协议，模仿写了C++版的，水平有限，自己还在改善中
RUDP－基于UDP的点对点协议代码
09-20
基于UDP的点对点协议代码，逻辑比较清楚，但还有很多bug。可用作参考学习。
Java RUDP(Reliable UDP)
05-17
RUDP:可靠性数据报协议，代码版本1.2.3，亲测可用，解压之后有源代码和api文档，分享给各位需要的朋友，记得好评哦
Reliability and Flow Control
缥缈的云 专栏
06-18 1192
原文地址：http://gafferongames.com/networking-for-game-programmers/reliability-and-flow-control/ Introduction 大家好，我是Glenn Fiedler，欢迎阅读我的网上电子书《游戏程序的网络设计》第四章。 在上一章中，我们基于UDP建立了自己的虚链接的观念。 现在我们在我们的链接中添加可靠性和
RUDP详解
weixin_45750967的博客
05-29 323
最近和很多实时音视频领域的朋友交流中都有谈论到RUDP(Reliable UDP)，这其实是个老生常谈的问题，RUDP在很多著名的项目上都有使用，例如google的QUIC和webRTC。在UDP之上做一层可靠，很多朋友认为这是很不靠谱的事情，也有朋友认为这是一个大杀器，可以解决实时领域里大部分问题。作为在教育公司来说，学霸君在很多实时场景下确实使用RUDP技术来解决我们的问题，不同场景我们采用的RUDP方式也不一样。先来看看学霸君哪些场景使用了RUDP: 1） 全局250毫秒延迟的实时1V1答疑，采用的是
Revolver源码解析之——RUDP发送速率控制器
Martian的博客
07-11 711
1、功能：实现带宽评估、发送窗口决策、RTT与RTC的计算。2、成员函数解析。[1].处理接收到的ACK。void RUDPCCCObject::on_ack(uint64_t ack_seq) { if(ack_seq &lt;= last_ack_id_) { return; } uint32_t space = (uint32_t)(ack_seq - last_ack_i...
C++高性能服务框架revover:rudp总体介绍（可靠UDP传输）
paradox_1_0的博客
03-30 1525
在revolver框架中实现了一个高效可靠的RUDP通信方式，这个通信方式是基于UDP实现一种模拟TCP传输数据的行为。在很多实际应用中,udp/TCP都不是最好的通信方式，例如:点对点文件传输、视频数据高速传输、服务器之间大数据备份同步、高实时rts操作类网游等。TCP和UDP在一定程度上是无法满足此类要求。故revolver实现了一套可靠UDP的传输方式。我们先来看看它的传输效率，以下是WIN...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值