C/C++ 对于KCP控制协议的封装对象

最新推荐文章于 2024-02-04 21:19:09 发布
最新推荐文章于 2024-02-04 21:19:09 发布
阅读量708 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/126868668
版权
Xtcp是基于FRP框架实现的网络通信库，它使用KCP协议提供快速可靠的数据传输。Xtcp类包括了读写异步回调、拥塞控制、错误处理等功能，并且支持客户端和服务端的创建。XtcpClient作为客户端类，提供了额外的上下文、宿主机和套接字管理。整个库利用Boost.Asio进行IO操作，确保了跨平台的兼容性。
摘要由CSDN通过智能技术生成

Xtcp.h 

#pragma once

#include <frp/IDisposable.h>
#include <frp/net/IPEndPoint.h>
#include <frp/threading/Hosting.h>

namespace frp {
    namespace xtcp {
        class Xtcp : public IDisposable {
        public:
            typedef std::function<void(int)>                        ReadAsyncCallback;
            typedef std::function<void(bool)>                       WriteAsyncCallback;

        private:
            struct message {
                std::shared_ptr<Byte>                               packet;
                int                                                 packet_size;
                WriteAsyncCallback                                  callback;
            };
            typedef std::shared_ptr<message>                        pmessage;
            typedef std::list<pmessage>                             message_queue;

        public:
            Xtcp(boost::asio::ip::udp::socket& socket, int channel, const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
            ~Xtcp() noexcept;

        public:
            virtual bool                                            ReadAsync(const void* buffer, int offset, int length, const ReadAsyncCallback& callback) noexcept;
            virtual bool                                            WriteAsync(const void* buffer, int offset, int length, const WriteAsyncCallback& callback) noexcept;
            virtual void                                            Dispose() noexcept override;
            virtual void                                            Update(UInt64 now) noexcept;
            virtual UInt64                                          CurrentMillisec() noexcept;

        public:
            virtual bool                                            IsAvailable() noexcept;
            inline frp::net::AddressFamily                          GetAddressFamily() noexcept { return af_; }
            inline int                                              GetChannel() noexcept { return channel_; }
            inline boost::asio::ip::udp::socket*                    GetSocket() noexcept { return socket_.load(); }
            inline boost::asio::ip::udp::endpoint&                  GetRemoteEndPoint() noexcept { return remoteEP_; }
            Xtcp&                                                   SetRemoteEndPoint(const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
            boost::asio::ip::udp::endpoint                          GetLocalEndPoint() noexcept;

        public:
            virtual bool                                            Listen() noexcept;
            virtual bool                                            Open() noexcept;
            void                                                    Close() noexcept;
            bool                                                    NoDelay(bool value) noexcept;
            int                                                     GetMinRetransmissionTimeout() noexcept;
            bool                                                    SetMinRetransmissionTimeout(int timeout) noexcept;

        public:
            virtual std::shared_ptr<Byte>                           GetBuffer(int& length) = 0;
            virtual bool                                            Input(const void* buffer, int offset, int length, const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
            virtual bool                                            Output(const void* buffer, int offset, int length, const boost::asio::ip::udp::endpoint& destinationEP) noexcept;

        private:
            bool                                                    Timeout() noexcept;
            bool                                                    TryReadNetStack(void* state) noexcept;
            void                                                    TryFlushNetStack(void* state) noexcept;
            void                                                    Finalize() noexcept;
            void                                                    CloseNetStack() noexcept;
            void                                                    CloseSocket() noexcept;
            void                                                    CancelTimeout() noexcept;
            void                                                    CancelReadAsync() noexcept;
            void                                                    ClearAllMessages() noexcept;

        private:
            std::atomic<bool>                                       disposed_;
            std::atomic<bool>                                       open_;
            std::atomic<bool>                                       listen_;
            std::atomic<void*>                                      kcp_;
            std::atomic<boost::asio::ip::udp::socket*>              socket_;
            frp::net::AddressFamily                                 af_;
            int                                                     channel_;  
            boost::asio::ip::udp::endpoint                          sourceEP_;
            boost::asio::ip::udp::endpoint                          remoteEP_;
            boost::asio::deadline_timer                             timeout_;
            message_queue                                           messages_;
            struct {
                char*                                               buffer;
                int                                                 length;
                ReadAsyncCallback                                   callback;
            }                                                       readACB_;
        };

        class XtcpClient : public Xtcp {
        public:
            XtcpClient(const std::shared_ptr<frp::threading::Hosting>& hosting, const std::shared_ptr<boost::asio::io_context>& context, const std::shared_ptr<boost::asio::ip::udp::socket>& socket, int channel, const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
            XtcpClient(const std::shared_ptr<frp::threading::Hosting>& hosting, const std::shared_ptr<boost::asio::io_context>& context, int channel, const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
            XtcpClient(const std::shared_ptr<frp::threading::Hosting>& hosting, const std::shared_ptr<boost::asio::io_context>& context, int channel, const boost::asio::ip::udp::endpoint& localEP, const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
            XtcpClient(const std::shared_ptr<frp::threading::Hosting>& hosting, const std::shared_ptr<boost::asio::io_context>& context, int channel, const std::string& host, int port) noexcept;

        public:
            std::shared_ptr<boost::asio::ip::udp::socket>           GetSocket() noexcept;
            std::shared_ptr<boost::asio::io_context>                GetContext() noexcept;
            std::shared_ptr<frp::threading::Hosting>                GetHosting() noexcept;
            virtual std::shared_ptr<Byte>                           GetBuffer(int& length) noexcept override;

        public:
            static boost::asio::ip::udp::endpoint                   ToEndPoint(const std::string host, int port) noexcept;
            static std::shared_ptr<boost::asio::ip::udp::socket>    CreateSocket(const std::shared_ptr<boost::asio::io_context>& context, const boost::asio::ip::udp::endpoint& localEP) noexcept;

        private:
            std::shared_ptr<frp::threading::Hosting>                hosting_;
            std::shared_ptr<boost::asio::io_context>                context_;
            std::shared_ptr<boost::asio::ip::udp::socket>           socket_;
            std::shared_ptr<Byte>                                   buffer_;
        };
    }
}

Xtcp.cpp

#include <frp/xtcp/Xtcp.h>
#include <frp/xtcp/ikcp.h>
#include <frp/net/Ipep.h>
#include <frp/net/Socket.h>

using frp::net::AddressFamily;
using frp::net::Ipep;
using frp::net::IPEndPoint;

namespace frp {
    namespace xtcp {
        struct IKcpAllocator {
            inline IKcpAllocator() noexcept {
                ikcp_allocator(
                    [](size_t sz) noexcept {
                        return Malloc(sz);
                    },
                    [](void* p) noexcept {
                        Mfree(p);
                    });
            }
        };

        /* Set the default memory allocator for Xtcp globally. */
        static IKcpAllocator __XtcpAllocator__;

        Xtcp::Xtcp(boost::asio::ip::udp::socket& socket, int channel, const boost::asio::ip::udp::endpoint& remoteEP) noexcept
            : disposed_(false)
            , open_(false)
            , listen_(false)
            , kcp_(NULL)
            , channel_(channel)
            , socket_(addressof(socket))
            , timeout_(socket.get_executor()) {
            /* Initialize the Read Async Control Block. */
            readACB_.buffer = NULL;
            readACB_.length = 0;

            /* If the socket is not opened, try opening the socket. */
            if (!socket.is_open()) {
                boost::asio::ip::address address = remoteEP.address(); /* Destination endpoint was incorrect. */
                if (address.is_loopback()) {
                    address = boost::asio::ip::address_v6::loopback();
                }
                else {
                    address = boost::asio::ip::address_v6::any();
                }
                frp::net::Socket::OpenSocket(socket, address, IPEndPoint::MinPort);
            }

            /* Create a KCP-ARQ congestion control network tunnels. */
            ikcpcb* kcp = ikcp_create(channel, this);
            if (kcp) {
                /* Sets the function properties of the KCP protocol stack. */
                ikcp_setmtu(kcp, 1400);
                ikcp_wndsize(kcp, 128, 128);

                /* Sets the field properties of the KCP protocol stack. */
                ikcp_setoutput(kcp,
                    [](const char* buf, int len, ikcpcb* kcp, void* user) noexcept {
                        Xtcp* sender = (Xtcp*)user;
                        return sender->Output(buf, 0, len, sender->GetRemoteEndPoint()) ? -1 : 0;
                    });
            }
            kcp_.exchange(kcp);

            /* Nagle algorithm is turned on by default. */
            NoDelay(false);

            /* Determines the IP protocol cluster type of the current socket. */
            boost::system::error_code ec;
            af_ = AddressFamily::InterNetwork;

            boost::asio::ip::udp::endpoint localEP = socket.local_endpoint(ec);
            if (!ec) {
                boost::asio::ip::address localIP = localEP.address();
                if (localIP.is_v6()) {
                    af_ = AddressFamily::InterNetworkV6;
                }
            }

            /* Marks the current remote endpoint address. */
            SetRemoteEndPoint(remoteEP);
        }

        Xtcp::~Xtcp() noexcept {
            Finalize();
        }

        void Xtcp::Finalize() noexcept {
            CloseNetStack();
            CloseSocket();
            CancelTimeout();
            CancelReadAsync();
            ClearAllMessages();
        }

        void Xtcp::Close() noexcept {
            Dispose();
        }

        void Xtcp::Dispose() noexcept {
            if (!disposed_.exchange(true)) {
                Finalize();
            }
        }

        bool Xtcp::Open() noexcept {
            boost::asio::ip::udp::socket* socket = socket_.load();
            if (!socket) {
                return false;
            }

            if (!socket->is_open()) {
                return false;
            }

            if (disposed_) {
                return false;
            }

            if (open_.exchange(true)) {
                return false;
            }

            return Timeout();
        }

        bool Xtcp::Listen() noexcept {
            boost::asio::ip::udp::socket* socket = socket_.load();
            if (!socket) {
                return false;
            }

            if (!socket->is_open()) {
                return false;
            }

            if (disposed_) {
                return false;
            }

            if (!open_) {
                return false;
            }

            if (listen_.exchange(true)) {
                return false;
            }

            int buffer_size = 0;
            std::shared_ptr<Byte> buffer = GetBuffer(buffer_size);
            std::shared_ptr<Reference> reference = GetReference();

            socket->async_receive_from(boost::asio::buffer(buffer.get(), buffer_size), sourceEP_,
                [reference, this, buffer](const boost::system::error_code& ec, std::size_t sz) noexcept {
                    if (listen_.exchange(false)) {
                        int len = std::max<int>(ec ? -1 : sz, -1);
                        if (len > 0) {
                            Input(buffer.get(), 0, len, sourceEP_);
                        }
                        Listen();
                    }
                });
            return true;
        }

        bool Xtcp::Timeout() noexcept {
            if (!IsAvailable()) {
                return false;
            }

            std::shared_ptr<Reference> reference = GetReference();
            timeout_.expires_from_now(boost::posix_time::milliseconds(1));
            timeout_.async_wait(
                [reference, this](const boost::system::error_code& ec) noexcept {
                    if (!ec) {
                        Update(CurrentMillisec());
                        Timeout();
                    }
                });
            return true;
        }

        bool Xtcp::NoDelay(bool value) noexcept {
            ikcpcb* kcp = (ikcpcb*)kcp_.load();
            if (!kcp) {
                return false;
            }

            int nodelay = value ? 2 : 0;
            int hr = ikcp_nodelay(kcp, nodelay, 10, 2, 1);
            if (hr < 0) {
                return false;
            }

            return true;
        }

        int Xtcp::GetMinRetransmissionTimeout() noexcept {
            ikcpcb* kcp = (ikcpcb*)kcp_.load();
            if (!kcp) {
                return -1;
            }
            return kcp->rx_minrto;
        }

        bool Xtcp::SetMinRetransmissionTimeout(int timeout) noexcept {
            if (timeout < 10) {
                timeout = 10;
            }

            ikcpcb* kcp = (ikcpcb*)kcp_.load();
            if (!kcp) {
                return false;
            }

            kcp->rx_minrto = timeout;
            return true;
        }

        UInt64 Xtcp::CurrentMillisec() noexcept {
            return GetTickCount();
        }

        void Xtcp::Update(UInt64 now) noexcept {
            ikcpcb* kcp = (ikcpcb*)kcp_.load();
            if (kcp) {
                TryReadNetStack(kcp);
                TryFlushNetStack(kcp);
                ikcp_update(kcp, now & 0xfffffffful);
            }
        }

        bool Xtcp::Output(const void* buffer, int offset, int length, const boost::asio::ip::udp::endpoint& destinationEP) noexcept {
            /* Check the validity of the input parameters. */
            if (!buffer || offset < 0 || length < 1) {
                return false;
            }

            /* Atom gets the pointer address of the socket and ret out if null. */
            boost::asio::ip::udp::socket* socket = socket_.load();
            if (!socket) {
                return false;
            }

            if (!socket->is_open()) {
                return false;
            }

            /* Sending data to the extranet. */
            boost::system::error_code ec;
            socket->send_to(boost::asio::buffer((char*)buffer + offset, length), destinationEP, 0, ec);
            return ec ? false : true;
        }

        void Xtcp::CloseNetStack() noexcept {
            ikcpcb* kcp = (ikcpcb*)kcp_.exchange(NULL);
            if (kcp) {
                ikcp_release(kcp);
            }
        }

        void Xtcp::CloseSocket() noexcept {
            boost::asio::ip::udp::socket* socket = socket_.exchange(NULL);
            if (socket) {
                frp::net::Socket::Closesocket(*socket);
            }
        }

        void Xtcp::CancelTimeout() noexcept {
            frp::threading::Hosting::Cancel(timeout_);
        }

        void Xtcp::ClearAllMessages() noexcept {
            std::vector<pmessage> messages;
            message_queue::iterator tail = messages_.begin();
            message_queue::iterator endl = messages_.end();
            for (; tail != endl; tail++) {
                messages.push_back(std::move(*tail));
            }

            messages_.clear();
            for (std::size_t index = 0, length = messages.size(); index < length; index++) {
                pmessage message = std::move(messages[index]);
                if (!message) {
                    continue;
                }

                WriteAsyncCallback& handler = message->callback;
                if (handler) {
                    handler(false);
                }
            }
        }

        void Xtcp::CancelReadAsync() noexcept {
            ReadAsyncCallback handler = std::move(readACB_.callback);
            readACB_.buffer = NULL;
            readACB_.length = 0;
            readACB_.callback = NULL;

            if (handler) {
                handler(-1);
            }
        }

        void Xtcp::TryFlushNetStack(void* state) noexcept {
            /* Check whether the peer address is valid. */
            boost::asio::ip::address destinationAddress = remoteEP_.address();
            if (destinationAddress.is_multicast() || destinationAddress.is_unspecified()) {
                return;
            }

            /* Check whether the peer port is valid. */
            int destinationPort = remoteEP_.port();
            if (destinationPort <= IPEndPoint::MinPort || destinationPort > IPEndPoint::MaxPort) {
                return;
            }

            /* The loop attempts to send segmented data to the peer. */
            ikcpcb* kcp = (ikcpcb*)state;
            while (kcp) { /* FIFO */
                message_queue::iterator tail = messages_.begin();
                message_queue::iterator endl = messages_.end();
                if (tail == endl) {
                    break;
                }

                pmessage& message = *tail;
                if (message) {
                    int hr = ikcp_send(kcp, (char*)message->packet.get(), message->packet_size);
                    if (hr < 0) {
                        break;
                    }

                    WriteAsyncCallback& handler = message->callback;
                    if (handler) {
                        handler(true);
                    }
                }

                messages_.erase(tail);
            }
        }

        bool Xtcp::TryReadNetStack(void* state) noexcept {
            /* The state pointer must be a handle to KCP. */
            ikcpcb* kcp = (ikcpcb*)state;
            if (!kcp) {
                return false;
            }

            /* Check whether an asynchronous retrieval task exists. */
            char* buffer = readACB_.buffer;
            if (!buffer) {
                return false;
            }

            /* Attempts to receive data from the protocol stack cache. */
            int len = ikcp_recv(kcp, buffer, readACB_.length);
            if (len < 0) {
                return true;
            }

            /* Reset the Read Async Control Block. */
            ReadAsyncCallback handler = std::move(readACB_.callback);
            readACB_.buffer = NULL;
            readACB_.length = 0;
            readACB_.callback = NULL;

            /* Callback this asynchronous data acquisition. */
            if (handler) {
                handler(len);
            }
            return true;
        }

        bool Xtcp::Input(const void* buffer, int offset, int length, const boost::asio::ip::udp::endpoint& remoteEP) noexcept {
            if (!buffer || offset < 0 || length < 1) {
                return false;
            }

            ikcpcb* kcp = (ikcpcb*)kcp_.load();
            if (!kcp) {
                return false;
            }

            int hr = ikcp_input(kcp, (char*)buffer + offset, length);
            if (hr < 0) {
                return false;
            }

            /* UDP/IP port mapped by the carrier's network router to the user's dynamic NAT may change, but it does not change for the local broadband user's port. */
            /* So people need to make sure that every time a read Input succeeds they should try to overwrite the original value. */
            SetRemoteEndPoint(remoteEP);

            /* An attempt is made to send segmented data accumulated in the send queue to the peer end. */
            TryReadNetStack(kcp);
            TryFlushNetStack(kcp);
            return true;
        }

        bool Xtcp::IsAvailable() noexcept {
            boost::asio::ip::udp::socket* socket = socket_.load();
            if (!socket) {
                return false;
            }

            if (!socket->is_open()) {
                return false;
            }

            if (disposed_) {
                return false;
            }

            if (!open_) {
                return false;
            }

            return NULL != kcp_.load();
        }

        boost::asio::ip::udp::endpoint Xtcp::GetLocalEndPoint() noexcept {
            boost::asio::ip::udp::socket* socket = socket_.load();
            if (socket) {
                if (socket->is_open()) {
                    boost::system::error_code ec;
                    boost::asio::ip::udp::endpoint localEP = socket->local_endpoint(ec);
                    if (!ec) {
                        return localEP;
                    }
                }
            }
            return IPEndPoint::ToEndPoint<boost::asio::ip::udp>(IPEndPoint());
        }

        Xtcp& Xtcp::SetRemoteEndPoint(const boost::asio::ip::udp::endpoint& remoteEP) noexcept {
            remoteEP_ = IPEndPoint::Transform(af_, remoteEP);
            return *this;
        }

        bool Xtcp::ReadAsync(const void* buffer, int offset, int length, const ReadAsyncCallback& callback) noexcept {
            if (!buffer || offset < 0 || length < 1 || !callback) {
                return false;
            }

            if (!IsAvailable()) {
                return false;
            }

            /* Multiple pending asynchronous reads are not allowed at the same time. */
            if (readACB_.buffer) {
                return false;
            }

            /* Set the control block of the asynchronous read task. */
            readACB_.buffer = (char*)buffer + offset;
            readACB_.length = length;
            readACB_.callback = callback;

            return TryReadNetStack(kcp_.load());
        }

        bool Xtcp::WriteAsync(const void* buffer, int offset, int length, const WriteAsyncCallback& callback) noexcept {
            if (!buffer || offset < 0 || length < 1) {
                return false;
            }

            ikcpcb* kcp = (ikcpcb*)kcp_.load();
            if (!IsAvailable()) {
                return false;
            }

            std::shared_ptr<Byte> messages = make_shared_alloc<Byte>(length);
            memcpy(messages.get(), ((Byte*)buffer) + offset, length);

            /* Insert the flow controlled data segment into the send queues. */
            pmessage message_ = make_shared_object<message>();
            message_->packet = messages;
            message_->packet_size = length;
            message_->callback = callback;
            messages_.push_back(message_);

            /* Attempt to flush all message accumulated in the message queues. */
            TryReadNetStack(kcp);
            TryFlushNetStack(kcp);
            return true;
        }

        XtcpClient::XtcpClient(const std::shared_ptr<frp::threading::Hosting>& hosting, const std::shared_ptr<boost::asio::io_context>& context, const std::shared_ptr<boost::asio::ip::udp::socket>& socket, int channel, const boost::asio::ip::udp::endpoint& remoteEP) noexcept
            : Xtcp(*socket, channel, remoteEP)
            , hosting_(hosting)
            , context_(context)
            , socket_(socket) {
            buffer_ = hosting->GetBuffer();
        }

        XtcpClient::XtcpClient(const std::shared_ptr<frp::threading::Hosting>& hosting, const std::shared_ptr<boost::asio::io_context>& context, int channel, const boost::asio::ip::udp::endpoint& remoteEP) noexcept
            : XtcpClient(hosting, context, make_shared_object<boost::asio::ip::udp::socket>(*context), channel, remoteEP) {

        }

        XtcpClient::XtcpClient(const std::shared_ptr<frp::threading::Hosting>& hosting, const std::shared_ptr<boost::asio::io_context>& context, int channel, const boost::asio::ip::udp::endpoint& localEP, const boost::asio::ip::udp::endpoint& remoteEP) noexcept
            : XtcpClient(hosting, context, CreateSocket(context, localEP), channel, remoteEP) {

        }

        XtcpClient::XtcpClient(const std::shared_ptr<frp::threading::Hosting>& hosting, const std::shared_ptr<boost::asio::io_context>& context, int channel, const std::string& host, int port) noexcept
            : XtcpClient(hosting, context, channel, ToEndPoint(host, port)) {

        }

        std::shared_ptr<boost::asio::io_context> XtcpClient::GetContext() noexcept {
            return context_;
        }

        std::shared_ptr<boost::asio::ip::udp::socket> XtcpClient::GetSocket() noexcept {
            return socket_;
        }

        std::shared_ptr<frp::threading::Hosting> XtcpClient::GetHosting() noexcept {
            return hosting_;
        }

        std::shared_ptr<Byte> XtcpClient::GetBuffer(int& length) noexcept {
            length = frp::threading::Hosting::BufferSize;
            return buffer_;
        }

        boost::asio::ip::udp::endpoint XtcpClient::ToEndPoint(const std::string host, int port) noexcept {
            return IPEndPoint::ToEndPoint<boost::asio::ip::udp>(Ipep::GetEndPoint(host, port));
        }

        std::shared_ptr<boost::asio::ip::udp::socket> XtcpClient::CreateSocket(const std::shared_ptr<boost::asio::io_context>& context, const boost::asio::ip::udp::endpoint& localEP) noexcept {
            if (!context) {
                return NULL;
            }

            std::shared_ptr<boost::asio::ip::udp::socket> socket = make_shared_object<boost::asio::ip::udp::socket>(*context);
            if (socket) {
                boost::asio::ip::address address = localEP.address();
                if (address.is_multicast()) {
                    address = boost::asio::ip::address_v6::any();
                }

                if (!frp::net::Socket::OpenSocket(*socket, address, localEP.port())) {
                    return NULL;
                }
            }
            return socket;
        }
    }
}

liulilittle
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【UVKCP】KCP协议libuv封装库
突围
06-19 696
同mediasoup的libuv封装库 只提供了基本的功能，具体功能在其他模块中实现, nysocks 的 uvkcp库封装的更为集中。 静态变量uv_loop_t 同样的uv_loop_t 都是作为静态变量： 静态变量uv_loop_t static uv_loop_t *kcpuv_loop = NULL; 其实现都只调用一次，放在XXXInit中 都提供一个接口让外部获取到主loop变量 // NOTE: Don't change this while looping. ..
全网最系统最全面的c/c++ Linux服务端开发高级架构师全能体系总结，他来了
m0_58687318的博客
08-19 2910
涵盖了linux C++服务端开发架构师每个阶段所需要学习的知识点。
kcp库代码 c c++
02-20
KCP库代码，github上下载。KCP是一个快速可靠协议。它主要的设计目的是为了解决在网络拥堵的情况下TCP协议网络速度慢的问题，增大网络传输速率，但相当于TCP而言，会相应的牺牲一部分带宽。
C++ KCP异步多线程封装
DefiniteGoal的博客
07-14 1376
KCP线程安全封装
可基于udp的可靠传输协议kcp介绍，C++测试kcp示例
最新发布
weixin_40355471的博客
02-04 2320
KCP是国人开发的开源项目，作者：林伟 (skywind3000)（这个是真大牛）。 开源地址：https://github.com/skywind3000/kcp KCP是快速可靠传输协议，纯算法实现，KCP无任何系统调用，不负责底层协议收发，底层可以使用UDP或其他自定义协议进行收发。
UDP可靠传输协议KCP （Linux C/C++）
C/C++Linux、音视频、DPDK
11-10 585
对于接收方来说，若一个序号为n的分组被正确接收，并且按序，则接收方会为该分组返 回一个ACK给发送方，并将该分组中的数据交付给上层。若该分组是以前没收到的分组，则被缓存。若该分组的序号等于基序号4， 则该分组以及以前缓存的序号连续的分组都交付给上层，然后，接收窗口将向前移动。ARQ模型响应有两种，UNA（此编号前所有包已收到，如TCP）和ACK（该编号包已收到），光用UNA将导致全部重传，光用ACK则丢失成本太高，以往协议都是二选其一，而 KCP协议中，除去单独的 ACK包外，所有包都有UNA信息。
C++学习_udp协议(socket)的封装
aipao8673的博客
05-19 338
C++学习笔记，UDP(socket)协议的封装实现 1.配置QT下的pro文件 1 TEMPLATE = app 2 CONFIG += console 3 CONFIG -= app_bundle 4 CONFIG -= qt 5 6 LIBS += -lWs2_32 ##标示使用window下的Ws2_32.lib，-l表示要链接后面的库 7...
基于KCP协议的P2P服务器和客户端
10-24
客户端则负责初始化KCP会话，设置目标服务器的IP和端口，然后通过KCP协议封装数据并发送。同时，客户端也需要监听端口，接收服务器的响应，并进行相应的处理。在KCP协议下，客户端需要实现数据的分片和重组，以及...
C/C++Linux服务器开发高级架构师/Linux后台开发架构师丨高级进阶学习
Linuxhus的博客
07-22 1805
01 课程介绍 【录播】课程介绍(66分钟) 免费试学 【录播】磁盘存储链式的B树与B+树(131分钟) 免费试学 免费学习视频链接点击：C/C++Linux服务器开发高级架构师/Linux后台架构师 02 数据结构与算法 【回放】面试必聊的排序与KMP(1月7日 20:00-22:00) 【回放】随处可见的红黑树(1月9日 20:00-22:00) 【回放】磁盘存储链式的B树与B+树(1月12日 20:00-22:00) 【回放】海量数据去重的Hash与布隆过滤器，bitmap(1月
网络通信（套接字通信）（C/C++）
weixin_44954230的博客
09-26 575
网络编程基础知识，套接字
kcp 介绍与源代码分析_kcp介绍
weixin_39517859的博客
12-22 641
KCP介绍1 简介KCP是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议(如UDP)的收发，需要使用者自己定义下层数据包的发送方式，以 callback的方式提供给 KCP。 连时钟都需要外部传递进来，内部不会有任何一次系统调用。2 技术特性TCP是为流量设计的(每秒内可以传输多少KB的数...
一个用于协议开发的 C++ 框架 【已翻译100%】
weixin_34220963的博客
06-02 353
前言 欢迎！这里有一个网络基础类的抽象封装，开发者可以构建网络协议的具体实现。它以C++库的形式提供了一套类集，任何人都可以使用它构建程序。 这些抽象的主要好处是便于将这些协议实现集成到程序中我们不想浪费时间实现期望的协议或者使用一个第三方实现的地方。 此外，这些抽象便于员工协同工作，复用他们的工作并且提供其它实现的接口。例如，一些开发者可以致力协议的实...
KCP源码走读
qq_38731735的博客
11-24 711
前言 KCP作为一个比较轻量级的UDP可靠数据传输协议，在参照TCP拥塞控制的基础上实现了ARQ的功能。走读源码了解启动的原理，对于UDP可靠传输设计具有借鉴意义。 1 整体数据流 KCP整体数据流程由四个缓冲队列来完成，数据在缓冲队列进行迁移：其中队列都是排序的，其中接收队列接收的数据必须是联系的，也就是可靠的。 2 接收流程 2.1用户层从KCP接收数据： 用户最终读取一帧数据。 int ikcp_recv(ikcpcb *kcp, char *buffer, int len); { //1. 计算
什么是KCP
qq_23350817的博客
05-19 8786
一、什么是KCP KCP是一种网络传输协议(A Fast and Reliable ARQ Protocol)，可以视它为TCP的代替品，但是它运行于用户空间，它不管底层的发送与接收，只是个纯算法实现可靠传输，它的特点是牺牲带宽来降低延迟。因为TCP协议的大公无私，经常牺牲自己速度来减少网络拥塞，它是从大局上考虑的。而KCP是自私的，它只顾自己的传输效率，从不管整个网络的拥塞情况。举个例子，TCP检测到丢包的时候，首先想到的是网络拥塞了，要放慢自己的速度别让网络更糟，而KCP想到的赶紧重传别耽误事。 TCP
KCP 源码阅读
qq_23350817的博客
05-19 519
简介 KCP是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议（如UDP）的收发，需要使用者自己定义下层数据包的发送方式，以 callback的方式提供给 KCP。 连时钟都需要外部传递进来，内部不会有任何一次系统调用。 主要数据结构 IKCPSEG IKCPSEG是kcp的数据段结构，即储存需要发送的packet的内容。 struct IKCPSEG { struct IQUEUEHEAD
kcp源码走读
好记性不如写博客！
08-16 3767
kcp协议与tcp协议类似，是一种ARQ协议。他的优点在于比tcp的延迟更小30%-40%，但相应的会牺牲一部分的带宽，大该比tcp多浪费10%~20%。tcp的设计目标是增大网络利用率，而kcp的设计目标是增大网络传输速率。因此kcp与tcp对比，kcp有如下机制可以提高传输速度： 1.kcp的RTO每次是增加为1.5倍，相比tcp的2倍，具有更短的超时重传时间 2.无延迟ACK，通过配
1、发布C++实现的TCP网络框架Khala
weixin_30335575的博客
12-15 182
1、Khala简介 　　Khala（卡拉）是用C++实现的TCP网络框架。底层采用muduo网络库作为网络IO+线程模型，并封装实现了网络实现与业务逻辑分离的多线程网络框架，具有超时退出、多设备多事件注册支持、设备生命周期管理、设备间通信等功能。 项目托管地址：https://github.com/moyangvip/khala 2、底层支持 　　Khala底层采用muduo作为网络...
网络传输协议 kcp 原理解析
m0_60259116的博客
04-23 3422
1.概述 对于游戏开发，尤其是 MOBA（多人在线竞技）游戏，延迟是需要控制的。但是对于传统的 TCP（网络友好，很棒），并不利于包的实时性传输，因为他的超时重传和拥塞控制都是网络友好，对于我们包的实时性，没有优势。所以一般都是需要基于 UDP 去实现一套自己的网络协议，保证包的实时，以及可靠。其实就是牺牲 TCP 的友好，牺牲带宽，以空间换时间。基于 UDP，网上有一些优秀的协议，比如 KCP。 2.实现原理 KCP 只是简单的算法实现，并没有涉及到任何的底层调用。我们只需要在 UDP 系统调用的时
「协议」Kcp协议介绍、Demo讲解与工作过程浅谈
_Echo_
04-13 4602
Tcp和Udp 传输控制协议（英语：Transmission Control Protocol，缩写：TCP）是一种面向连接的、可靠的、基于字节流的传输层通信协议，其拥有着相对而言的可靠传输（相对UDP），由于Tcp的相关特性如在连接之前先创建两端的虚拟连接，以及发送数据的超时重传、滑动窗口、流量/拥塞控制等特性保证了其可靠的传输，因而TCP通常会保证数据准确交付。 但由于其在穿输数据之前需要进行虚拟连接的建立，这回消耗一定的传输时间，且在传输过程之中为保证数据正确交付而采用的超时重传、滑动窗口、流量/拥塞
用c++写一个kcp的demo
02-13
好的，下面是一个使用 C 语言编写的 KCP demo 的示例代码： ``` #include #include #include #include "ikcp.h" int main() { // 创建一个 KCP 对象 ikcpcb *kcp = ikcp_create(0x11223344, NULL); // 设置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值