C/C++ implement IPEndPoint

已于 2022-01-27 10:50:01 修改
阅读量459 收藏 2
点赞数
分类专栏： C/C++ 文章标签： c语言 c++ 开发语言
于 2022-01-27 10:44:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/122713652
版权

关于C/C++语言上面对于IP地址转换及包装方面的。

IPEndPoint.h

#pragma once

#include <Server/Environment.h>
#include <boost/asio/ip/basic_endpoint.hpp>

namespace Server {
    namespace Net {
        enum AddressFamily {
            InterNetwork                                                        = AF_INET,
            InterNetworkV6                                                      = AF_INET6,
        };                      

        struct IPEndPoint {                      
        private:                        
            mutable Byte                                                        _AddressBytes[sizeof(struct in6_addr)]; // 16
            AddressFamily                                                       _AddressFamily;

        public:                                                 
            const int                                                           Port;

        public:                 
            static const int MinPort                                            = 0;
            static const int MaxPort                                            = UINT16_MAX;
            static const UInt32 NoneAddress                                     = INADDR_NONE;

        public:
            inline IPEndPoint()
                : IPEndPoint(NoneAddress, 0) {
            
            }
            inline IPEndPoint(UInt32 address, int port)
                : _AddressFamily(AddressFamily::InterNetwork)
                , Port(port) {
                *(UInt32*)this->_AddressBytes = address;
            }
            IPEndPoint(const char* address, int port);
            IPEndPoint(AddressFamily af, const void* address_bytes, int address_size, int port);

        public:
            inline bool                                                         IsNone() {
                if (AddressFamily::InterNetwork != this->_AddressFamily) {
                    return false;
                }
                else {
                    UInt32 dw = this->GetAddress();
                    return dw == IPEndPoint::NoneAddress;
                }
            }
            inline std::string                                                  GetAddressBytes() const {
                int datalen;
                Byte* data = this->GetAddressBytes(datalen);
                return std::string((char*)data, datalen); 
            }  
            inline Byte*                                                        GetAddressBytes(int& len) const {
                if (this->_AddressFamily == AddressFamily::InterNetworkV6) {
                    len = sizeof(this->_AddressBytes);
                    return this->_AddressBytes;
                }
                else {
                    len = sizeof(UInt32);
                    return this->_AddressBytes;
                }
            }
            inline UInt32                                                       GetAddress() const {
                return *(UInt32*)this->_AddressBytes;
            }
            inline AddressFamily                                                GetAddressFamily() const {
                return this->_AddressFamily;
            }
            inline bool                                                         Equals(const IPEndPoint& value) const {
                IPEndPoint* right = (IPEndPoint*)&reinterpret_cast<const char&>(value);
                if ((IPEndPoint*)this == (IPEndPoint*)right){
                    return true;
                }
                if ((IPEndPoint*)this == (IPEndPoint*)NULL || 
                    (IPEndPoint*)right == (IPEndPoint*)NULL || 
                    this->Port != value.Port) {
                    return false;
                }
                return *this == value;
            }
            inline bool                                                         operator == (const IPEndPoint& right) const {
                if (this->_AddressFamily != right._AddressFamily) {
                    return false;
                }

                Byte* x = this->_AddressBytes;
                Byte* y = right._AddressBytes;
                if (x == y) {
                    return true;
                }

                if (this->_AddressFamily == AddressFamily::InterNetworkV6) {
                    UInt64* qx = (UInt64*)x;
                    UInt64* qy = (UInt64*)y;
                    return qx[0] == qy[0] && qx[1] == qy[1];
                }
                return *(UInt32*)x == *(UInt32*)y;
            }
            inline bool                                                         operator != (const IPEndPoint& right) const {
                bool b = (*this) == right;
                return !b;
            }
            inline IPEndPoint&                                                  operator = (const IPEndPoint& right) { 
                this->_AddressFamily = right._AddressFamily;
                const_cast<int&>(this->Port) = right.Port;

                int address_bytes_size;
                Byte* address_bytes = right.GetAddressBytes(address_bytes_size);
                memcpy(this->_AddressBytes, address_bytes, address_bytes_size);

                return *this;
            }
            inline std::string                                                  ToAddressString() noexcept {
                int address_bytes_size;
                Byte* address_bytes = GetAddressBytes(address_bytes_size);
                return ToAddressString(this->_AddressFamily, address_bytes, address_bytes_size);
            }
            std::string                                                         ToString() noexcept;

        public:                 
            static std::string                                                  GetHostName() noexcept;
            static std::string                                                  ToAddressString(AddressFamily af, const Byte* address_bytes, int address_size) noexcept;
            inline static std::string                                           ToAddressString(UInt32 address) noexcept {
                return ToAddressString(AddressFamily::InterNetwork, (Byte*)&address, sizeof(address));
            }
            inline static std::string                                           ToAddressString(AddressFamily af, const std::string& address_bytes) noexcept {
                return ToAddressString(af, (Byte*)address_bytes.data(), address_bytes.size());
            }
            inline static UInt32                                                PrefixToNetmask(int prefix) {
                UInt32 mask = prefix ? (~0 << (32 - prefix)) : 0;
                return htonl(mask);
            }
            inline static int                                                   NetmaskToPrefix(UInt32 mask) {
                unsigned char* bytes    = (unsigned char*)&mask;
                unsigned int bitLength  = 0;
                unsigned int idx        = 0;

                // find beginning 0xFF
                for (; idx < sizeof(mask) && bytes[idx] == 0xff; idx++);
                bitLength = 8 * idx;

                if (idx < sizeof(mask)) {
                    switch (bytes[idx]) {
                        case 0xFE: bitLength += 7; break;
                        case 0xFC: bitLength += 6; break;
                        case 0xF8: bitLength += 5; break;
                        case 0xF0: bitLength += 4; break;
                        case 0xE0: bitLength += 3; break;
                        case 0xC0: bitLength += 2; break;
                        case 0x80: bitLength += 1; break;
                        case 0x00: break;
                        default: // invalid bitmask
                            return ~0;
                    }
                    // remainder must be 0x00
                    for (unsigned int j = idx + 1; j < sizeof(mask); j++) {
                        unsigned char x = bytes[j];
                        if (x != 0x00) {
                            return ~0;    
                        }
                    }
                }
                return bitLength;
            }

        public:
            template<class TProtocol>
            inline static boost::asio::ip::basic_endpoint<TProtocol>            ToEndPoint(const IPEndPoint& endpoint) {
                AddressFamily af = endpoint.GetAddressFamily();
                if (af == AddressFamily::InterNetwork) {
                    return WrapAddress<TProtocol>(endpoint.GetAddress(), endpoint.Port);
                }
                else {
                    int len;
                    const Byte* address = endpoint.GetAddressBytes(len);
                    return WrapAddressV6<TProtocol>(address, len, endpoint.Port);
                }
            }
            template<class TProtocol>
            inline static IPEndPoint                                            ToEndPoint(const boost::asio::ip::basic_endpoint<TProtocol>& endpoint) {
                boost::asio::ip::address address = endpoint.address();
                if (address.is_v4()) {
                    return IPEndPoint(ntohl(address.to_v4().to_ulong()), endpoint.port());
                }
                else {
                    boost::asio::ip::address_v6::bytes_type bytes = address.to_v6().to_bytes();
                    return IPEndPoint(AddressFamily::InterNetworkV6, bytes.data(), bytes.size(), endpoint.port());
                }
            }
            template<class TProtocol>   
            inline static boost::asio::ip::basic_endpoint<TProtocol>            NewAddress(const char* address, int port) {
                if (NULL == address || *address == '\x0') {
                    address = "0.0.0.0";
                }

                if (port < IPEndPoint::MinPort || port > IPEndPoint::MaxPort) {
                    port = IPEndPoint::MinPort;
                }

                boost::system::error_code ec;
                boost::asio::ip::address ba = boost::asio::ip::address::from_string(address, ec);
                if (ec) {
                    ba = boost::asio::ip::address_v4(IPEndPoint::NoneAddress);
                }

                boost::asio::ip::basic_endpoint<TProtocol> defaultEP(ba, port);
                return defaultEP;
            }
            template<class TProtocol>   
            inline static boost::asio::ip::basic_endpoint<TProtocol>            WrapAddress(UInt32 address, int port) {
                typedef boost::asio::ip::basic_endpoint<TProtocol> protocol_endpoint;

                return protocol_endpoint(boost::asio::ip::address_v4(ntohl(address)), port);
            }
            template<class TProtocol>               
            inline static boost::asio::ip::basic_endpoint<TProtocol>            WrapAddressV6(const void* address, int size, int port) {
                typedef boost::asio::ip::basic_endpoint<TProtocol> protocol_endpoint;

                if (size < 0) {
                    size = 0;
                }

                boost::asio::ip::address_v6::bytes_type address_bytes;
                unsigned char* p = &address_bytes[0];
                memcpy(p, address, size);
                memset(p, 0, address_bytes.size() - size);

                return protocol_endpoint(boost::asio::ip::address_v6(address_bytes), port);
            }
            template<class TProtocol>               
            inline static boost::asio::ip::basic_endpoint<TProtocol>            AnyAddress(int port) {
                 return NewAddress<TProtocol>("\x0", port);
            }
            template<class TProtocol>               
            inline static boost::asio::ip::basic_endpoint<TProtocol>            LocalAddress(boost::asio::ip::basic_resolver<TProtocol>& resolver, int port) {
                return GetAddressByHostName<TProtocol>(resolver, GetHostName(), port);
            }
            template<class TProtocol>               
            inline static boost::asio::ip::basic_endpoint<TProtocol>            GetAddressByHostName(boost::asio::ip::basic_resolver<TProtocol>& resolver, const std::string& hostname, int port) {
                typedef boost::asio::ip::basic_resolver<TProtocol> protocol_resolver;
                
                typename protocol_resolver::query q(hostname.c_str(), std::to_string(port).c_str());
#ifndef _WIN32
                typename protocol_resolver::iterator i = resolver.resolve(q);
                typename protocol_resolver::iterator l;

                if (i == l) {
                    return AnyAddress<TProtocol>(port);
                }
#else
                typename protocol_resolver::results_type results = resolver.resolve(q);
                if (results.empty()) {
                    return AnyAddress<TProtocol>(port);
                }

                typename protocol_resolver::iterator i = results.begin();
                typename protocol_resolver::iterator l = results.end();
#endif
                for (; i != l; ++i) {
                    boost::asio::ip::basic_endpoint<TProtocol> localEP = *i;
                    if (!localEP.address().is_v4()) {
                        continue;
                    }
    
                    return localEP;
                }
    
                return AnyAddress<TProtocol>(port);
            }
            template<class TProtocol>               
            inline static bool                                                  Equals(const boost::asio::ip::basic_endpoint<TProtocol>& x, const boost::asio::ip::basic_endpoint<TProtocol>& y) {
                if (x != y) {
                    return false;
                }

                if (x.address() != y.address()) {
                    return false;
                }

                return x.port() == y.port();
            }
        };
    }
}

IPEndPoint.cpp

#include <stdio.h>
#include <stdint.h>
#include <string.h>
#ifdef _WIN32
#include <WS2tcpip.h>
#else
#include <sys/socket.h>
#include <arpa/inet.h>
 #include <netinet/in.h>
#endif

#include <string>
#include <boost/asio.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/ip/tcp.hpp>

#include "Ipep.h"
#include "IPEndPoint.h"

#define IP_END_POINT_USE_BOOST_INET_PTON

namespace Server {
    namespace Net {
        IPEndPoint::IPEndPoint(const char* address, int port) 
            : _AddressFamily(AddressFamily::InterNetwork)
            , Port(port) {
            if (NULL == address || *address == '\x0') {
                *(UInt32*)this->_AddressBytes = 0;
                this->_AddressFamily = AddressFamily::InterNetwork;
            } 
            else {
#ifndef IP_END_POINT_USE_BOOST_INET_PTON
                struct sockaddr_in6 in6;
                int err = inet_pton(AF_INET6, address, &in6);
                if (err > 0) {
                    this->_AddressFamily = AddressFamily::InterNetworkV6;
                    memcpy(this->_AddressBytes, &in6.sin6_addr, sizeof(this->_AddressBytes));
                }
                else {
                    *(UInt32*)this->_AddressBytes = inet_addr(address);
                    this->_AddressFamily = AddressFamily::InterNetwork;
                }
#else
                boost::system::error_code ec;
                boost::asio::ip::address host;
                try {
                    host = boost::asio::ip::address::from_string(address, ec);
                } 
                catch (std::exception&) {
                    ec = boost::asio::error::invalid_argument;
                }
                
                if (ec) {
                    this->_AddressFamily = AddressFamily::InterNetwork;
                    *(UInt32*)this->_AddressBytes = IPEndPoint::NoneAddress;
                }
                else if (host.is_v6()) {
                    this->_AddressFamily = AddressFamily::InterNetworkV6;
                    boost::asio::ip::address_v6::bytes_type buf = host.to_v6().to_bytes();
                    memcpy(this->_AddressBytes, buf.data(), buf.size());
                }
                else {
                    this->_AddressFamily = AddressFamily::InterNetwork;
                    boost::asio::ip::address_v4::bytes_type buf = host.to_v4().to_bytes();
                    memcpy(this->_AddressBytes, buf.data(), buf.size());
                }
#endif
            }
        }

        IPEndPoint::IPEndPoint(AddressFamily af, const void* address_bytes, int address_size, int port) 
            : _AddressFamily(af)
            , Port(port) {
            int limit_size = 0;
            if (af == AddressFamily::InterNetworkV6) {
                limit_size = sizeof(struct in6_addr);
            }
            else {
                af = AddressFamily::InterNetwork;
                limit_size = sizeof(struct in_addr);
            }
            memset(this->_AddressBytes, 0, limit_size);
            if (NULL != address_bytes && address_size > 0) {
                memcpy(this->_AddressBytes, address_bytes, std::min(address_size, limit_size));
            }
            this->_AddressFamily = af;
        }

        std::string IPEndPoint::GetHostName() noexcept {
            char szz[256]; // 域名规定不超过64字节（但是几乎大部分实现为64-1字节）
            int err = gethostname(szz, 0xff);
            if (err <= 0) {
                return "localhost"; 
            }
            return szz;
        }

        std::string IPEndPoint::ToString() noexcept {
            return Ipep::ToIpepAddress(this);
        }

        std::string IPEndPoint::ToAddressString(AddressFamily af, const Byte* address_bytes, int address_size) noexcept {
            if (NULL == address_bytes || address_size <= 0) {
                return "0.0.0.0";
            }
            
            if (af == AddressFamily::InterNetworkV6) {
                if (address_size < (int)sizeof(struct in6_addr)) {
                    return "0.0.0.0";
                }

                char sz[INET6_ADDRSTRLEN];
                if (!inet_ntop(AF_INET6, (struct in6_addr*)address_bytes, sz, sizeof(sz))) {
                    return "0.0.0.0";
                }
                return sz;
            }
            else {
                if (address_size < (int)sizeof(struct in_addr)) {
                    return "0.0.0.0";
                }

                char sz[INET_ADDRSTRLEN];
                if (!inet_ntop(AF_INET, (struct in_addr*)address_bytes, sz, sizeof(sz))) {
                    return "0.0.0.0";
                }
                return sz; // inet_ntoa(*(struct in_addr*)address);
            }
        }
    }
}

liulilittle
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IPEndPoint
weixin_30516243的博客
12-07 571
.NET框架用IPEndPoint对象来表示一个特定的IP地址和端口的组合，应用该对象的场景多是在讲socket绑定到本地地址或者将socket绑定到非本地地址。 转载于:https://www.cnblogs.com/hshy/p/7998733.html...
endpoint
我的博客
03-10 294
（1）Your service must be accessible by different languages and platforms. （2）Your service must be able to go through firewalls. Given these requirements, the best solution is to provide a so-called ...
IPEndPoint 和 EndPoint
tianlansedeshijie的博客
07-10 6037
IPEndPoint继承与EndPoint。IPEndPoint引用的时候参数为IP和端口。IPEndPoint iep = new IPEndPoint(IPAddress.Any, 9050); .net中 Bind(EndPoint localEP);方法参数是EndPoint，填入IPEndPoint会按照EndPoint参数执行。 ​EndPoint是IPEndPoint的基类，IP...
IPEndPoint类的使用方法（C#---网络编程）
热门推荐
liyuqian199695的博客
12-14 3万+
IPEndPoint类的使用方法（C#窗体） 1、窗体设计 2、程序设计 using System.Net;   private void button1_Click(object sender, EventArgs e)         {             //实例化IPEndPoint类对象             IPEndPoint IPEPoint =
IPEndPoint类
zhihua_l的专栏
02-18 3134
在C#中，IPEndPoint类包含了应用程序连接到主机上的服务所需的IP地址和端口信息。    　IPEndPoint类常用的构造函数为：　public IPEndPoint(IPAddress, int);   　    其中第一个参数指定IP地址，第二个参数指定端口号。例 :IPAddress类、Dns类、IPHostEntry类和IPEndPoint类的使用方法。 
ngtcp2-main.zip 最新的IETF QUIC协议实现 C/C++ Implement
11-04
描述中提到的“网络传输 http3 QUIC C/C++”，表明这个项目不仅涉及QUIC协议，还与HTTP/3有关。HTTP/3是HTTP协议的最新版本，它基于QUIC协议运行，旨在提高网页加载速度和网络连接的可靠性。C++和C是这个实现所使用...
bcon_implement.rar_网络编程_C/C++_
08-11
标题中的“bcon_implement.rar_网络编程_C/C++_”表明这是一个关于C或C++实现网络编程的项目集合。这个压缩包包含了多个源代码文件（wj.cpp, wj1.cpp, Cpp3.cpp, Cpp8.cpp）以及项目文件（wj.dsp, Cpp3.dsp, wj1.dsp...
implement_oop_using_C.zip_VC书籍_C/C++_
08-12
"implement_oop_using_C.zip"中的"VC书籍 C/C++"标签可能意味着这份资源是关于使用C语言在Visual C++环境下实现OOP的教程。 在C语言中，为了实现面向对象的特性，我们需要模拟以下三个核心概念：类（Class）、对象...
Music App For Tv/Pad implement.zip
10-10
Music App For Tv/Pad implement.zip,simple implement an AV Player & my workmates Animation(DEPRECATED)
matlab集成c代码-arm_compute_library_c_implement:提取ACL算法内核代码，并打包到C/C++API中，从
05-22
14的语法，对于大多数嵌入式工程师来说，往往主要使用的是C语言，对于C++不是很熟悉，对于理解算法需要花费一些 时间，因此才有了创建这个库的念头，目的就是将ACL中算法的核心code，提取出来，封装成一个一个的接口...
IPEndPoint(IPAddress.Any, 0)的意思
farmer_worker的专栏
03-01 1万+
IPEndPoint(IPAddress.Any, 0) If creates an IPEndpoint using any available IP address on the local computer, and any available port number. IPAddress.Any代表本机上的所有IP地址，MSDN上说是“一个 IP 地址，指示服务器应侦听所有网络接口
IPAddress,IPEndPoint,IPHostEntry介绍
菜鸟学编程
10-15 3588
IPAddress,IPEndPoint,IPHostEntry位于命名空间System.Net下，提供对IP地址的操作 IPAddress是.NET封装的IP地址类 常用方法： 1、IPAddress.Parse() public static IPAddress Parse (string ipString)，这个方法得目的就是将一个ipString转换成为IPAddress类型。
C#中的IPAddress和IPEndPoint
weixin_48431030的博客
04-10 3571
IP addresses in C# 在.Net网络库里面最大的优点就是IP地址和端口被成对处理，相比于UNIX中用的方法真是一个巨大的令人欢迎的进步。.NET定义了两个类来处理关于IP地址的问题。 One of the biggest advantages you will notice in the .NET network library is the way IP address/port pairs are handled. It is a fairly straightforward proc.
IPEndPoint类的常用字段、属性及说明
ba_wang_mao的专栏
04-06 3593
IPEndPoint类包含应用程序连接到主机上的服务所需的主机和本地或远程端口信息。通过组合服务的主机IP地址和端口号，IPEndPoint类形成到服务的连接点，它主要用来将网络端点表示为IP地址和端口号。IPEndPoint类的常用字段、属性及说明如下表所示。 表 IPEndPoint类的常用字段、属性及说明 字段及属性 说明 MaxPort字段 指定可以分...
java ipendpoint,客户端IPEndPoint无法使用IPAddress.Any？
weixin_28705579的博客
03-13 495
我一直在学习一些套接字编程，我创建了一个异步服务器，只监听并返回数据 .但我在这里有一个问题，我在IPEndPoint(IPAddress.any，端口)的服务器上使用IPEndPoint，我也在客户端做同样的事情 . 运行服务器和客户端时，我使用try catch，客户端返回它的异常“请求的地址在其上下文0.0.0.0:port中无效”以下是代码：Server.csPublic void Lis...
usb中的endpoint(端点)和传输模式
weixin_34025151的博客
09-21 1907
端点： 端点位于USB 外设内部，所有通信数据的来源或目的都基于这些端点，是一个可寻址的FIFO。 每个USB 外设有一个唯一的地址，可能包含最多十六个端点。主机通过发出器件地址和每次数据传输的端点号，向一个具体端点(FIFO)发送数据。 每个端点的地址为0 到15，一个端点地址对应一个方向。所以，端点2-IN 与端点2-OUT 完全不同。 每个器件有一个默认的双向控制端点0，因此不存在端点...
C#中IPAddress类/Dns类/IPHostEntry类/IPEndPoint用法简介
weixin_30426957的博客
05-16 502
C#中IPAddress类/Dns类/IPHostEntry类/IPEndPoint用法简介 IP是一种普遍应用于因特网、允许不同主机能够相互找到对方的寻址协议。IP地址由4个十进制的数字号码所组成，而每一个号码的值介于0~255之间，它虽然解决了网络上计算机的识别问题，但是IP地址确不容易记，因此域名系统（DNS）被开发出来，它专门用于将IP地址转换成有意义的文字，以方便识别记忆。 　...
C#.NET网络程序开发的基本类（一）（C#---网络编程）
liyuqian199695的博客
12-14 7774
C#.NET网络程序开发的基本类 C#.NET的System.NET命名空间为Internet网络上使用的多种协议提供了便利的编程接口。 1、IPAddress类 IPAddress类提供的是主机的IP地址及相关信息，包括IP回环地址Loopback、IP广播地址Broadcase以及对IPv6协议的支持。 IPAddress的构造函数是publicIPAddress(longad...
matlab taylorwin c/c++
最新发布
03-29
In C/C++, you can implement the Taylor window function using the following code: ```c #include void taylorwin(int M, double beta, double *w) { int n; double sum = 0.0, w0; // Compute the ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值