• C/C++ P2P自定义发现协议 Xndp。

    Xndp.h

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. namespace frp {
    9.     namespace discover {
    10.         /* X Network Discovery Protocol. */
    11.         class Xndp : public IDisposable { /* Apply to P2P(peer-to-peer) is based on NAT/UDP put holes.*/
    12. #pragma pack(push,1)
    13.             struct XndpPacket {
    14.                 Byte                                                            kf;
    15.                 UInt16                                                          len; /* Packet size. */
    16.                 UInt16                                                          checksum; /* Check sum. */
    17.                 UInt32                                                          id;
    18.                 Byte                                                            cmd;
    19.             };
    20.             struct XndpRegisterEntryRequestPacket  : XndpPacket {
    21.                 Byte                                                            type; /* frp::configuration::MappingType */
    22.                 UInt16                                                          port;
    23.             };                                     
    24.             struct XndpReisterReplyPacket          : XndpPacket {
    25.                 Byte                                                            err;
    26.             };                                     
    27.             struct XndpQueryEntryReplyPacket       : XndpReisterReplyPacket {
    28.                 Byte                                                            type; /* frp::configuration::MappingType */
    29.                 UInt16                                                          port;
    30.                 Byte                                                            af;
    31.                 UInt16                                                          dst_port;
    32.                 Byte                                                            dst_addr[16];
    33.             };                                     
    34.             typedef XndpRegisterEntryRequestPacket XndpQueryEntryRequestPacket;
    35. #pragma pack(pop)
    36.             enum {
    37.                 XNDP_KF = 0x7E,
    38.                 XNDP_REGST_ENTRY = 0x2A, /* Registry entry. */
    39.                 XNDP_QUERY_ENTRY = 0x2E, /* Query entry. */
    40.                 XNDP_PUSH_MESSAGE = 0x2C,
    41.                 XNDP_ENTRY_TIMEOUT = 10000,
    42.                 XNDP_CALLER_TIMEOUT = 3000,
    43.                 XNDP_ERROR_SUCCESS = 0,
    44.                 XNDP_ERROR_INVALID_ENTRY_TYPE = 1,
    45.                 XNDP_ERROR_INVALID_ENTRY_PORT = 2,
    46.                 XNDP_ERROR_NOT_FOUND_ENTRY = 3,
    47.             };
    48.             typedef boost::asio::ip::udp::endpoint                              XNDP_ENDPOINT;
    49.             struct XndpEntry {
    50.                 XNDP_ENDPOINT                                                   destinationEP; /* Mapped to a public address. */
    51.                 UInt64                                                          last;          /* Last activity times. */
    52.                 Byte                                                            type;
    53.                 UInt16                                                          port;
    54.             };
    55.             /* s mode. */
    56.             typedef std::shared_ptr                                  XndpEntryPtr;
    57.             typedef std::unordered_map                    XndpEntry2LevelTable;
    58.             typedef std::unordered_map              XndpEntry1LevelTable;
    59.  
    60.         public:
    61.             typedef std::function<void(
    62.                 UInt32                                                          id,
    63.                 Byte*                                                           buffer, 
    64.                 int                                                             length, 
    65.                 boost::asio::ip::udp::endpoint&                                 remoteEP)> MessageEventHandler;
    66.             MessageEventHandler                                                 MessageEvent;
    67.  
    68.         public:
    69.             Xndp(const std::shared_ptr& hosting) noexcept;
    70.             Xndp(const std::shared_ptr& hosting, int bindport) noexcept;
    71.  
    72.         public:
    73.             boost::asio::ip::udp::endpoint                                      GetLocalEndPoint() noexcept;
    74.             boost::asio::ip::udp::socket&                                       GetSocket() noexcept;
    75.             std::shared_ptr                            GetContext() noexcept;
    76.             std::shared_ptr                            GetHosting() noexcept;
    77.  
    78.         public:
    79.             virtual bool                                                        IsAvailable() noexcept;
    80.             virtual bool                                                        Open() noexcept;
    81.             void                                                                Close() noexcept;
    82.             virtual void                                                        Dispose() noexcept override;
    83.  
    84.         public:
    85.             typedef std::function<void(bool)>                                   RegisterAsyncCallback;
    86.             typedef std::function<void(bool, boost::asio::ip::udp::endpoint&)>  QueryAsyncCallback;
    87.             virtual bool                                                        RegisterAsync(
    88.                 frp::configuration::MappingType                                 mapping_type, 
    89.                 int                                                             mapping_port,
    90.                 RegisterAsyncCallback                                           callback,
    91.                 const boost::asio::ip::udp::endpoint&                           destinationEP) noexcept;
    92.             virtual bool                                                        QueryAsync(
    93.                 frp::configuration::MappingType                                 mapping_type,
    94.                 int                                                             mapping_port,
    95.                 QueryAsyncCallback                                              callback,
    96.                 const boost::asio::ip::udp::endpoint&                           destinationEP) noexcept;
    97.             virtual bool                                                        PushAsync(
    98.                 UInt32                                                          id, 
    99.                 const void*                                                     message,
    100.                 const int                                                       message_size,
    101.                 const boost::asio::ip::udp::endpoint&                           destinationEP) noexcept;
    102.             static boost::asio::ip::udp::endpoint                               ToEndPoint(const std::string host, int port) noexcept;
    103.  
    104.         protected:
    105.             virtual void                                                        Timeout(UInt64 now) noexcept;
    106.  
    107.         private:
    108.             bool                                                                SetTimeout() noexcept;
    109.             int                                                                 PacketSerializeMini(XndpPacket* packet) noexcept;
    110.             bool                                                                OnXndpProc() noexcept;
    111.             bool                                                                OnRegisterEntryServer(XndpPacket* packet, const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
    112.             bool                                                                OnQueryEntryServer(XndpPacket* packet, const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
    113.             bool                                                                ReplyToDestination(XndpPacket* packet, const boost::asio::ip::udp::endpoint& remoteEP) noexcept;
    114.             void                                                                ProcessEntryTimeout(UInt64 now) noexcept;
    115.  
    116.         private:
    117.             /* c mode. */
    118.             struct XndpCallerContext { /* rpc, stop wait ARQ. */
    119.                 std::shared_ptr                                           message;
    120.                 int                                                             message_size;
    121.                 int                                                             retry_count;
    122.                 UInt64                                                          initial_time;
    123.                 XNDP_ENDPOINT                                                   destination;
    124.                 UInt32                                                          id;
    125.                 QueryAsyncCallback                                              query_ac;
    126.                 RegisterAsyncCallback                                           register_ac;
    127.             };
    128.             typedef std::unordered_map               XndpCallerContextTable;
    129.             bool                                                                OnRegisterEntryClient(XndpPacket* packet) noexcept;
    130.             bool                                                                OnQueryEntryClient(XndpPacket* packet) noexcept;
    131.             bool                                                                PopCallerContext(UInt32 id, XndpCallerContext& context) noexcept;
    132.             void                                                                ProcessCallerTimeout(UInt64 now) noexcept;
    133.             template<typename TCallback>
    134.             bool                                                                RequireArgument(
    135.                 frp::configuration::MappingType                                 mapping_type,
    136.                 int                                                             mapping_port,
    137.                 TCallback&                                                      callback,
    138.                 const boost::asio::ip::udp::endpoint&                           destinationEP) noexcept;
    139.             UInt32                                                              NewId() noexcept;
    140.             template<typename TXndpRequestPacket>
    141.             bool                                                                AddXndpCaller(
    142.                 Byte                                                            command,
    143.                 Byte                                                            mapping_type, 
    144.                 int                                                             mapping_port, 
    145.                 const QueryAsyncCallback&                                       qac, 
    146.                 const RegisterAsyncCallback&                                    rac,
    147.                 const boost::asio::ip::udp::endpoint&                           destinationEP) noexcept;
    148.             void                                                                OnTimeoutError(XndpCallerContext& context) noexcept;
    149.  
    150.         private:
    151.             std::atomic<bool>                                                   disposed_;
    152.             std::atomic                                                 aid_;
    153.             int                                                                 bindport_;
    154.             std::shared_ptr                            hosting_;
    155.             std::shared_ptr                            context_;
    156.             std::shared_ptr                                               buffer_;
    157.             boost::asio::ip::udp::socket                                        socket_;
    158.             boost::asio::ip::udp::endpoint                                      localEP_;
    159.             boost::asio::ip::udp::endpoint                                      endpoint_;
    160.             boost::asio::deadline_timer                                         timeout_;
    161.             XndpEntry1LevelTable                                                entries_;
    162.             XndpCallerContextTable                                              callers_;
    163.         };
    164.     }
    165. }

    Xndp.cpp

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. using frp::configuration::MappingType;
    8. using frp::net::AddressFamily;
    9. using frp::net::Ipep;
    10. using frp::net::IPEndPoint;
    11. using frp::net::Socket;
    12. using frp::collections::Dictionary;
    13.  
    14. namespace frp {
    15.     namespace discover {
    16.         Xndp::Xndp(const std::shared_ptr& hosting) noexcept
    17.             : Xndp(hosting, IPEndPoint::MinPort) {
    18.  
    19.         }
    20.  
    21.         Xndp::Xndp(const std::shared_ptr& hosting, int bindport) noexcept
    22.             : disposed_(false)
    23.             , aid_(0)
    24.             , bindport_(bindport)
    25.             , hosting_(hosting)
    26.             , context_(hosting->GetContext())
    27.             , buffer_(hosting->GetBuffer())
    28.             , socket_(*context_)
    29.             , timeout_(*context_) {
    30.             if (bindport < IPEndPoint::MinPort || bindport > IPEndPoint::MaxPort) {
    31.                 bindport = IPEndPoint::MinPort;
    32.             }
    33.  
    34.             if (!Socket::OpenSocket(socket_, boost::asio::ip::address_v6::any(), bindport)) {
    35.                 bindport = IPEndPoint::MinPort;
    36.             }
    37.             else {
    38.                 bindport = Socket::LocalPort(socket_);
    39.             }
    40.  
    41.             boost::system::error_code ec;
    42.             if (bindport) {
    43.                 boost::asio::ip::udp::endpoint localEP = socket_.local_endpoint(ec);
    44.                 if (!ec) {
    45.                     localEP_ = localEP;
    46.                 }
    47.             }
    48.         }
    49.  
    50.         boost::asio::ip::udp::endpoint Xndp::GetLocalEndPoint() noexcept {
    51.             return localEP_;
    52.         }
    53.  
    54.         std::shared_ptr Xndp::GetContext() noexcept {
    55.             return context_;
    56.         }
    57.  
    58.         std::shared_ptr Xndp::GetHosting() noexcept {
    59.             return hosting_;
    60.         }
    61.  
    62.         bool Xndp::IsAvailable() noexcept {
    63.             return !disposed_ && socket_.is_open();
    64.         }
    65.  
    66.         void Xndp::Close() noexcept {
    67.             Dispose();
    68.         }
    69.  
    70.         void Xndp::Dispose() noexcept {
    71.             if (!disposed_.exchange(true)) {
    72.                 /* Releases the socket and timer held. */
    73.                 Socket::Closesocket(socket_);
    74.                 frp::threading::Hosting::Cancel(timeout_);
    75.  
    76.                 /* Releases all managed table member data. */
    77.                 entries_.clear();
    78.                 Dictionary::ReleaseAllPairs(callers_,
    79.                     [this](XndpCallerContext& context) noexcept {
    80.                         OnTimeoutError(context);
    81.                     });
    82.  
    83.                 /* Deletes the message event listener bound to the current class instance object. */
    84.                 MessageEvent = MessageEventHandler();
    85.             }
    86.         }
    87.  
    88.         bool Xndp::Open() noexcept {
    89.             if (!IsAvailable()) {
    90.                 return false;
    91.             }
    92.  
    93.             return SetTimeout() && OnXndpProc();
    94.         }
    95.  
    96.         bool Xndp::SetTimeout() noexcept {
    97.             if (disposed_) {
    98.                 return false;
    99.             }
    100.  
    101.             std::shared_ptr reference = GetReference();
    102.             timeout_.expires_from_now(boost::posix_time::milliseconds(1000));
    103.             timeout_.async_wait(
    104.                 [reference, this](const boost::system::error_code& ec) noexcept {
    105.                     if (!ec) {
    106.                         Timeout(hosting_->CurrentMillisec());
    107.                         SetTimeout();
    108.                     }
    109.                 });
    110.             return true;
    111.         }
    112.  
    113.         void Xndp::Timeout(UInt64 now) noexcept {
    114.             ProcessEntryTimeout(now);
    115.             ProcessCallerTimeout(now);
    116.         }
    117.  
    118.         void Xndp::ProcessEntryTimeout(UInt64 now) noexcept {
    119.             XndpEntry1LevelTable::iterator tail = entries_.begin();
    120.             XndpEntry1LevelTable::iterator endl = entries_.end();
    121.             if (tail != endl) {
    122.                 std::vector releases;
    123.                 for (; tail != endl; tail++) {
    124.                     XndpEntry2LevelTable::iterator tail2 = tail->second.begin();
    125.                     XndpEntry2LevelTable::iterator endl2 = tail->second.end();
    126.                     for (; tail2 != endl2; tail2++) {
    127.                         XndpEntryPtr& entry = tail2->second;
    128.                         if (entry->last > now) {
    129.                             releases.push_back(std::move(entry));
    130.                         }
    131.                         else {
    132.                             UInt64 diff = now - entry->last;
    133.                             if (diff >= XNDP_ENTRY_TIMEOUT) {
    134.                                 releases.push_back(std::move(entry));
    135.                             }
    136.                         }
    137.                     }
    138.                 }
    139.  
    140.                 for (std::size_t index = 0, length = releases.size(); index < length; index++) {
    141.                     XndpEntryPtr& entry = releases[index];
    142.                     if (entry) {
    143.                         Dictionary::TryRemove2Layer(entries_, entry->type, entry->port);
    144.                     }
    145.                 }
    146.             }
    147.         }
    148.  
    149.         void Xndp::ProcessCallerTimeout(UInt64 now) noexcept {
    150.             XndpCallerContextTable::iterator tail = callers_.begin();
    151.             XndpCallerContextTable::iterator endl = callers_.end();
    152.             if (tail != endl) {
    153.                 std::vector releases;
    154.                 for (; tail != endl; tail++) {
    155.                     XndpCallerContext& context = tail->second;
    156.                     if (!IsAvailable()) {
    157.                         releases.push_back(context.id);
    158.                         continue;
    159.                     }
    160.  
    161.                     UInt64 initial_time = context.initial_time;
    162.                     if (initial_time > now) {
    163.                         releases.push_back(context.id);
    164.                         continue;
    165.                     }
    166.  
    167.                     UInt64 diff = now - initial_time;
    168.                     if (diff >= XNDP_CALLER_TIMEOUT) {
    169.                         releases.push_back(context.id);
    170.                         continue;
    171.                     }
    172.  
    173.                     UInt32 retry_count = ++context.retry_count;
    174.                     if (retry_count >= 3) {
    175.                         releases.push_back(context.id);
    176.                         continue;
    177.                     }
    178.  
    179.                     boost::system::error_code ec;
    180.                     socket_.send_to(boost::asio::buffer(context.message.get(), context.message_size), context.destination, 0, ec);
    181.                 }
    182.  
    183.                 for (std::size_t index = 0, length = releases.size(); index < length; index++) {
    184.                     XndpCallerContext context;
    185.                     if (Dictionary::TryRemove(callers_, releases[index], context)) {
    186.                         OnTimeoutError(context);
    187.                     }
    188.                 }
    189.             }
    190.         }
    191.  
    192.         void Xndp::OnTimeoutError(XndpCallerContext& context) noexcept {
    193.             if (context.register_ac) {
    194.                 context.register_ac(false);
    195.             }
    196.  
    197.             if (context.query_ac) {
    198.                 boost::asio::ip::udp::endpoint nanoEP;
    199.                 context.query_ac(false, nanoEP);
    200.             }
    201.         }
    202.  
    203.         bool Xndp::OnXndpProc() noexcept {
    204.             if (!IsAvailable()) {
    205.                 return false;
    206.             }
    207.  
    208.             std::shared_ptr reference = GetReference();
    209.             socket_.async_receive_from(boost::asio::buffer(buffer_.get(), frp::threading::Hosting::BufferSize), endpoint_,
    210.                 [reference, this](const boost::system::error_code& ec, std::size_t sz) noexcept {
    211.                     /* If it is an Xndp packet, the packet is processed; otherwise, the packet is displayed. */
    212.                     int length = std::max<int>(ec ? -1 : sz, -1);
    213.                     if (length >= sizeof(XndpPacket)) {
    214.                         XndpPacket* packet = (XndpPacket*)buffer_.get();
    215.                         do {
    216.                             /* The key frame is inconsistent. */
    217.                             if (packet->kf != XNDP_KF) {
    218.                                 break;
    219.                             }
    220.  
    221.                             /* Check frame length validity. */
    222.                             int len = ntohs(packet->len);
    223.                             if (len != length) {
    224.                                 break;
    225.                             }
    226.  
    227.                             /* Check packet checksum. */
    228.                             int checksum = frp::messages::inet_chksum(packet, len);
    229.                             if (checksum != 0) {
    230.                                 break;
    231.                             }
    232.     
    233.                             /* This is a malicious external attack. */
    234.                             if (packet->cmd != XNDP_REGST_ENTRY && packet->cmd != XNDP_QUERY_ENTRY && packet->cmd != XNDP_PUSH_MESSAGE) {
    235.                                 break;
    236.                             }
    237.  
    238.                             /* Converts data from network byte order to local byte order. */
    239.                             packet->len = len;
    240.                             packet->id = ntohl(packet->id);
    241.  
    242.                             /* The action of processing the request. */
    243.                             switch (packet->cmd) {
    244.                             case XNDP_REGST_ENTRY:
    245.                                 if (bindport_) {
    246.                                     OnRegisterEntryServer(packet, endpoint_);
    247.                                 }
    248.                                 else {
    249.                                     OnRegisterEntryClient(packet);
    250.                                 }
    251.                                 break;
    252.                             case XNDP_QUERY_ENTRY:
    253.                                 if (bindport_) {
    254.                                     OnQueryEntryServer(packet, endpoint_);
    255.                                 }
    256.                                 else {
    257.                                     OnQueryEntryClient(packet);
    258.                                 }
    259.                                 break;
    260.                             case XNDP_PUSH_MESSAGE:
    261.                                 /* If the packets are not Xndp packets, they belong to other protocols that pass through the Intranet. */
    262.                                 int message_size = len - sizeof(XndpPacket);
    263.                                 if (message_size > 0) {
    264.                                     MessageEventHandler handler = MessageEvent;
    265.                                     if (handler) {
    266.                                         handler(packet->id, (Byte*)(packet + 1), message_size, endpoint_);
    267.                                     }
    268.                                 }
    269.                                 break;
    270.                             };
    271.                         } while (0);
    272.                     }
    273.                     OnXndpProc();
    274.                 });
    275.             return true;
    276.         }
    277.  
    278.         bool Xndp::OnRegisterEntryServer(XndpPacket* packet, const boost::asio::ip::udp::endpoint& remoteEP) noexcept {
    279.             XndpRegisterEntryRequestPacket* request = (XndpRegisterEntryRequestPacket*)packet;
    280.             if (request->len < sizeof(XndpRegisterEntryRequestPacket)) {
    281.                 return false;
    282.             }
    283.             else {
    284.                 request->port = ntohs(request->port);
    285.             }
    286.  
    287.             XndpReisterReplyPacket reply;
    288.             reply.checksum = 0;
    289.             reply.id = packet->id;
    290.             reply.cmd = packet->cmd;
    291.             reply.len = sizeof(reply);
    292.             reply.err = XNDP_ERROR_SUCCESS;
    293.  
    294.             if (request->type < MappingType::MappingType_TCP || request->type >= MappingType::MappingType_MaxType) {
    295.                 reply.err = XNDP_ERROR_INVALID_ENTRY_TYPE;
    296.             }
    297.             elif(request->port <= IPEndPoint::MinPort || request->port > IPEndPoint::MaxPort) {
    298.                 reply.err = XNDP_ERROR_INVALID_ENTRY_PORT;
    299.             }
    300.             else {
    301.                 XndpEntryPtr& entry = entries_[request->type][request->port];
    302.                 if (!entry) {
    303.                     entry = make_shared_object();
    304.                 }
    305.  
    306.                 entry->destinationEP = IPEndPoint::ToEndPoint(IPEndPoint::V6ToV4(IPEndPoint::ToEndPoint(remoteEP)));
    307.                 entry->port = request->port;
    308.                 entry->type = request->type;
    309.                 entry->last = hosting_->CurrentMillisec();
    310.             }
    311.             return ReplyToDestination(&reply, remoteEP);
    312.         }
    313.  
    314.         bool Xndp::OnQueryEntryServer(XndpPacket* packet, const boost::asio::ip::udp::endpoint& remoteEP) noexcept {
    315.             XndpQueryEntryRequestPacket* request = (XndpQueryEntryRequestPacket*)packet;
    316.             if (request->len < sizeof(XndpQueryEntryRequestPacket)) {
    317.                 return false;
    318.             }
    319.             else {
    320.                 request->port = ntohs(request->port);
    321.             }
    322.  
    323.             XndpQueryEntryReplyPacket reply;
    324.             reply.checksum = 0;
    325.             reply.id = packet->id;
    326.             reply.cmd = packet->cmd;
    327.             reply.len = sizeof(reply);
    328.             reply.err = XNDP_ERROR_SUCCESS;
    329.             reply.type = IPEndPoint::MinPort;
    330.             reply.port = MappingType::MappingType_TCP;
    331.  
    332.             if (request->type < MappingType::MappingType_TCP || request->type >= MappingType::MappingType_MaxType) {
    333.                 reply.err = XNDP_ERROR_INVALID_ENTRY_TYPE;
    334.             }
    335.             elif(request->port <= IPEndPoint::MinPort || request->port > IPEndPoint::MaxPort) {
    336.                 reply.err = XNDP_ERROR_INVALID_ENTRY_PORT;
    337.             }
    338.             else {
    339.                 XndpEntryPtr entry;
    340.                 if (!Dictionary::TryGetValue2Layer(entries_, request->type, request->port, entry) || !entry) {
    341.                     reply.err = XNDP_ERROR_NOT_FOUND_ENTRY;
    342.                 }
    343.                 else {
    344.                     boost::asio::ip::address address = entry->destinationEP.address();
    345.                     if (address.is_v4()) {
    346.                         boost::asio::ip::address_v4::bytes_type address_bytes = address.to_v4().to_bytes();
    347.                         memcpy(reply.dst_addr, address_bytes.data(), address_bytes.size());
    348.                         reply.af = AddressFamily::InterNetwork;
    349.                     }
    350.                     else {
    351.                         boost::asio::ip::address_v6::bytes_type address_bytes = address.to_v6().to_bytes();
    352.                         memcpy(reply.dst_addr, address_bytes.data(), address_bytes.size());
    353.                         reply.af = AddressFamily::InterNetworkV6;
    354.                     }
    355.                     reply.type = entry->type;
    356.                     reply.port = htons(entry->port);
    357.                     reply.dst_port = htons(entry->destinationEP.port());
    358.                 }
    359.             }
    360.             return ReplyToDestination(&reply, remoteEP);
    361.         }
    362.  
    363.         template<typename TCallback>
    364.         bool Xndp::RequireArgument(
    365.             frp::configuration::MappingType       mapping_type,
    366.             int                                   mapping_port,
    367.             TCallback&                            callback,
    368.             const boost::asio::ip::udp::endpoint& destinationEP) noexcept {
    369.             typedef frp::net::IPEndPoint IPEndPoint;
    370.             typedef frp::configuration::MappingType MappingType;
    371.  
    372.             if (!IsAvailable()) {
    373.                 return false;
    374.             }
    375.             elif(!callback) {
    376.                 return false;
    377.             }
    378.             elif(mapping_type < MappingType::MappingType_TCP || mapping_type >= MappingType::MappingType_MaxType) {
    379.                 return false;
    380.             }
    381.             elif(mapping_port <= IPEndPoint::MinPort || mapping_port > IPEndPoint::MaxPort) {
    382.                 return false;
    383.             }
    384.  
    385.             boost::asio::ip::address address = destinationEP.address();
    386.             if (address.is_multicast() || address.is_unspecified()) {
    387.                 return false;
    388.             }
    389.             return true;
    390.         }
    391.  
    392.         template<typename TXndpRequestPacket>
    393.         bool Xndp::AddXndpCaller(
    394.             Byte                                  command,
    395.             Byte                                  mapping_type,
    396.             int                                   mapping_port,
    397.             const QueryAsyncCallback&             qac,
    398.             const RegisterAsyncCallback&          rac,
    399.             const boost::asio::ip::udp::endpoint& destinationEP) noexcept {
    400.             typedef frp::net::IPEndPoint IPEndPoint;
    401.  
    402.             int message_size = sizeof(TXndpRequestPacket);
    403.             std::shared_ptr message = make_shared_alloc(message_size);
    404.             if (!message) {
    405.                 return false;
    406.             }
    407.  
    408.             UInt32 id = NewId();
    409.             TXndpRequestPacket* request = (TXndpRequestPacket*)message.get();
    410.             request->checksum = 0;
    411.             request->cmd = command;
    412.             request->id = id;
    413.             request->len = message_size;
    414.             request->type = mapping_type;
    415.             request->port = htons(mapping_port);
    416.             if (PacketSerializeMini(request) < 1) {
    417.                 return false;
    418.             }
    419.  
    420.             XNDP_ENDPOINT remoteEP = IPEndPoint::ToEndPoint(IPEndPoint::V4ToV6(IPEndPoint::ToEndPoint(destinationEP)));
    421.             XndpCallerContext& context = callers_[id];
    422.             context.id = id;
    423.             context.destination = remoteEP;
    424.             context.initial_time = hosting_->CurrentMillisec();
    425.             context.query_ac = qac;
    426.             context.register_ac = rac;
    427.             context.retry_count = 0;
    428.             context.message = message;
    429.             context.message_size = message_size;
    430.  
    431.             boost::system::error_code ec;
    432.             socket_.send_to(boost::asio::buffer(request, message_size), remoteEP, 0, ec);
    433.             return ec ? false : true;
    434.         }
    435.  
    436.         int Xndp::PacketSerializeMini(XndpPacket* packet) noexcept {
    437.             int length = packet->len;
    438.             if (length < sizeof(XndpPacket)) {
    439.                 return 0;
    440.             }
    441.  
    442.             packet->kf = XNDP_KF;
    443.             packet->checksum = 0;
    444.             packet->id = htonl(packet->id);
    445.             packet->len = htons(length);
    446.  
    447.             UInt16 checksum = frp::messages::inet_chksum(packet, length);
    448.             if (checksum == 0) {
    449.                 checksum = 0xffff;
    450.             }
    451.             packet->checksum = htons(checksum);
    452.             return length;
    453.         }
    454.  
    455.         bool Xndp::ReplyToDestination(XndpPacket* packet, const boost::asio::ip::udp::endpoint& remoteEP) noexcept {
    456.             if (!IsAvailable()) {
    457.                 return false;
    458.             }
    459.  
    460.             int length = PacketSerializeMini(packet);
    461.             if (length < 1) {
    462.                 return false;
    463.             }
    464.  
    465.             boost::system::error_code ec;
    466.             socket_.send_to(boost::asio::buffer(packet, length), remoteEP, 0, ec);
    467.             return ec ? false : true;
    468.         }
    469.  
    470.         bool Xndp::RegisterAsync(MappingType mapping_type, int mapping_port, RegisterAsyncCallback callback, const boost::asio::ip::udp::endpoint& destinationEP) noexcept {
    471.             if (!RequireArgument(mapping_type, mapping_port, callback, destinationEP)) {
    472.                 return false;
    473.             }
    474.  
    475.             return AddXndpCaller(XNDP_REGST_ENTRY,
    476.                 mapping_type, mapping_port, NULL, callback, destinationEP);
    477.         }
    478.  
    479.         bool Xndp::QueryAsync(MappingType mapping_type, int mapping_port, QueryAsyncCallback callback, const boost::asio::ip::udp::endpoint& destinationEP) noexcept {
    480.             if (!RequireArgument(mapping_type, mapping_port, callback, destinationEP)) {
    481.                 return false;
    482.             }
    483.  
    484.             return AddXndpCaller(XNDP_QUERY_ENTRY,
    485.                 mapping_type, mapping_port, callback, NULL, destinationEP);
    486.         }
    487.  
    488.         bool Xndp::PushAsync(UInt32 id, const void* message, const int message_size, const boost::asio::ip::udp::endpoint& destinationEP) noexcept {
    489.             if (!message || message_size < 1) {
    490.                 return false;
    491.             }
    492.  
    493.             int chunk_size = sizeof(XndpPacket) + message_size;
    494.             std::shared_ptr chunk = make_shared_alloc(chunk_size);
    495.             if (!message) {
    496.                 return false;
    497.             }
    498.  
    499.             XndpPacket* packet = (XndpPacket*)chunk.get();
    500.             packet->checksum = 0;
    501.             packet->cmd = XNDP_PUSH_MESSAGE;
    502.             packet->id = id;
    503.             packet->len = chunk_size;
    504.             memcpy(packet + 1, message, message_size);
    505.  
    506.             if (PacketSerializeMini(packet) < 1) {
    507.                 return false;
    508.             }
    509.  
    510.             boost::system::error_code ec;
    511.             socket_.send_to(boost::asio::buffer(packet, chunk_size), destinationEP, 0, ec);
    512.             return ec ? false : true;
    513.         }
    514.  
    515.         UInt32 Xndp::NewId() noexcept {
    516.             for (;;) {
    517.                 int id = aid_++;
    518.                 if (!id) {
    519.                     continue;
    520.                 }
    521.  
    522.                 if (!Dictionary::ContainsKey(callers_, id)) {
    523.                     return id;
    524.                 }
    525.             }
    526.         }
    527.  
    528.         boost::asio::ip::udp::socket& Xndp::GetSocket() noexcept {
    529.             return socket_;
    530.         }
    531.  
    532.         bool Xndp::PopCallerContext(UInt32 id, XndpCallerContext& context) noexcept {
    533.             return Dictionary::TryRemove(callers_, id, context);
    534.         }
    535.  
    536.         bool Xndp::OnRegisterEntryClient(XndpPacket* packet) noexcept {
    537.             XndpReisterReplyPacket* reply = (XndpReisterReplyPacket*)packet;
    538.             if (reply->len < sizeof(XndpReisterReplyPacket)) {
    539.                 return false;
    540.             }
    541.  
    542.             XndpCallerContext caller;
    543.             if (!PopCallerContext(reply->id, caller)) {
    544.                 return false;
    545.             }
    546.  
    547.             caller.register_ac(reply->err == XNDP_ERROR_SUCCESS);
    548.             return true;
    549.         }
    550.  
    551.         bool Xndp::OnQueryEntryClient(XndpPacket* packet) noexcept {
    552.             XndpQueryEntryReplyPacket* reply = (XndpQueryEntryReplyPacket*)packet;
    553.             if (reply->len < sizeof(XndpQueryEntryReplyPacket)) {
    554.                 return false;
    555.             }
    556.  
    557.             XndpCallerContext caller;
    558.             if (!PopCallerContext(reply->id, caller)) {
    559.                 return false;
    560.             }
    561.  
    562.             if (reply->err != XNDP_ERROR_SUCCESS) {
    563.                 boost::asio::ip::udp::endpoint noneEP;
    564.                 caller.query_ac(false, noneEP);
    565.             }
    566.             else {
    567.                 boost::asio::ip::address address;
    568.                 if (reply->af == AddressFamily::InterNetwork) {
    569.                     address = boost::asio::ip::address_v4(*(boost::asio::ip::address_v4::bytes_type*)reply->dst_addr);
    570.                 }
    571.                 else {
    572.                     address = boost::asio::ip::address_v6(*(boost::asio::ip::address_v6::bytes_type*)reply->dst_addr);
    573.                 }
    574.  
    575.                 boost::asio::ip::udp::endpoint destinationEP(address, ntohs(reply->dst_port));
    576.                 caller.query_ac(true, destinationEP);
    577.             }
    578.             return true;
    579.         }
    580.  
    581.         boost::asio::ip::udp::endpoint Xndp::ToEndPoint(const std::string host, int port) noexcept {
    582.             return IPEndPoint::ToEndPoint(Ipep::GetEndPoint(host, port));
    583.         }
    584.     }
    585. }

  • 相关阅读:
    matplotlib制图初级篇
    音视频 SDL vs2017配置
    力扣—最长回文子串
    C++ 二叉树非递归先/后序 + 实战力扣题
    CSS 清除浮动
    navicat升级后，失效，重新ok，navicat彻底卸载
    Ant-design中表单多级对象做嵌套表单校验
    【笔试题】【day7】
    PTV Vissim学习
    硬链接和软链接的区别
  • 原文地址：https://blog.csdn.net/liulilittle/article/details/126868692