Expand Up @@ -19,53 +19,87 @@ #include "IPAddress.h" #include "Print.h" #include <cstdint> #include <new> using namespace arduino; IPAddress::IPAddress(): IPAddress(IPv4) {} IPAddress::IPAddress()= default; IPAddress::IPAddress(IPType ip_type) { _type = ip_type; memset(_address.bytes, 0, sizeof(_address.bytes)); } IPAddress::IPAddress(IPType ip_type) : _type(ip_type) {} IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet) { _type = IPv4; memset(_address.bytes, 0, sizeof(_address.bytes)); _address.bytes[IPADDRESS_V4_BYTES_INDEX] = first_octet; _address.bytes[IPADDRESS_V4_BYTES_INDEX + 1] = second_octet; _address.bytes[IPADDRESS_V4_BYTES_INDEX + 2] = third_octet; _address.bytes[IPADDRESS_V4_BYTES_INDEX + 3] = fourth_octet; _address[IPADDRESS_V4_BYTES_INDEX] = first_octet; _address[IPADDRESS_V4_BYTES_INDEX + 1] = second_octet; _address[IPADDRESS_V4_BYTES_INDEX + 2] = third_octet; _address[IPADDRESS_V4_BYTES_INDEX + 3] = fourth_octet; } IPAddress::IPAddress(uint8_t o1, uint8_t o2, uint8_t o3, uint8_t o4, uint8_t o5, uint8_t o6, uint8_t o7, uint8_t o8, uint8_t o9, uint8_t o10, uint8_t o11, uint8_t o12, uint8_t o13, uint8_t o14, uint8_t o15, uint8_t o16) { _type = IPv6; _address.bytes[0] = o1; _address.bytes[1] = o2; _address.bytes[2] = o3; _address.bytes[3] = o4; _address.bytes[4] = o5; _address.bytes[5] = o6; _address.bytes[6] = o7; _address.bytes[7] = o8; _address.bytes[8] = o9; _address.bytes[9] = o10; _address.bytes[10] = o11; _address.bytes[11] = o12; _address.bytes[12] = o13; _address.bytes[13] = o14; _address.bytes[14] = o15; _address.bytes[15] = o16; } IPAddress::IPAddress(uint8_t o1, uint8_t o2, uint8_t o3, uint8_t o4, uint8_t o5, uint8_t o6, uint8_t o7, uint8_t o8, uint8_t o9, uint8_t o10, uint8_t o11, uint8_t o12, uint8_t o13, uint8_t o14, uint8_t o15, uint8_t o16) : _address{o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, o11, o12, o13, o14, o15, o16}, _type(IPv6) {} IPAddress::IPAddress(uint32_t address) // IPv4 only IPAddress::IPAddress(uint32_t address) { // IPv4 only _type = IPv4; memset(_address.bytes, 0, sizeof(_address.bytes)); _address.dword[IPADDRESS_V4_DWORD_INDEX] = address; // memcpy(raw_address(), &address, 4); // This method guarantees a defined behavior. // But lifetime started when: // [basic.life#2] https://eel.is/c++draft/basic.life#2 //(2.1) -- storage with the proper alignment and size for type T is obtained, and //(2.2) -- its initialization (if any) is complete (including vacuous initialization) ([dcl.init]), // // The statement: {#Any pointer conversions to write to ADDRESS storage (as a multibyte integer) // are undefined behavior when the lifetime of the multibyte type has not previously started.#} // only apply to c++17 and earlier. Since C++20 array of bytes implicitly creates the inner objects. // C++20: https://timsong-cpp.github.io/cppwp/n4861/intro.object#13 // 13 An operation that begins the lifetime of an array of char, unsigned char, or std::byte implicitly creates objects within // the region of storage occupied by the array. [ Note: The array object provides storage for these objects. — end note ] // C++23: https://timsong-cpp.github.io/cppwp/n4950/intro.object#13 // 13 An operation that begins the lifetime of an array of unsigned char or std::byte implicitly creates objects within the // region of storage occupied by the array. // [Note 5: The array object provides storage for these objects. — end note] // Current draft: https://eel.is/c++draft/intro.object#14 // 14 Except during constant evaluation, an operation that begins the lifetime of an array of unsigned char or std::byte implicitly // creates objects within the region of storage occupied by the array. // [Note 5: The array object provides storage for these objects. — end note] // *reinterpret_cast<uint32_t*>(_address[IPADDRESS_V4_BYTES_INDEX]) = address; // This valid initialization in the `_address` storage since C++20. // now the pointer `_address[IPADDRESS_V4_BYTES_INDEX]` points to a multibyte int. new (&_address[IPADDRESS_V4_BYTES_INDEX]) uint32_t (address); // But the new-expression is better for understanding and looks nicer (for trivial types, the // new expression only begins its lifetime and does not perform any other actions). // NOTE: https://en.cppreference.com/w/cpp/language/new#Notes // NOTE: new-expression and reinterpret_cast require alignment of the storage, but memcpy does not. // C++ standard draft [basic.life#7](https://eel.is/c++draft/basic.life#7) // Before the lifetime of an object has started but after the storage which the object // will occupy has been allocated or, after the lifetime of an object has ended and // before the storage which the object occupied is reused or released, any pointer that // represents the address of the storage location where the object will be or was // located may be used but only in limited ways. For an object under construction or // destruction, see [class.cdtor]. Otherwise, such a pointer refers to allocated storage // ([basic.stc.dynamic.allocation]), and using the pointer as if the pointer were of // type void* is well-defined. Indirection through such a pointer is permitted but the // resulting lvalue may only be used in limited ways, as described below. // The program has undefined behavior if // --the pointer is used as the operand of a delete-expression, // --the pointer is used as the operand of a static_cast ([expr.static.cast]), except // when the conversion is to pointer to cv void, or to pointer to cv void and subsequently // to pointer to cv char, cv unsigned char, or cv std::byte ([cstddef.syn]), or // C++ standard draft [basic.life#8](https://eel.is/c++draft/basic.life#8) // Similarly, before the lifetime of an object has started but after the storage which // the object will occupy has been allocated or, after the lifetime of an object has // ended and before the storage which the object occupied is reused or released, any // glvalue that refers to the original object may be used but only in limited ways. // For an object under construction or destruction, see [class.cdtor]. Otherwise, such // a glvalue refers to allocated storage ([basic.stc.dynamic.allocation]), and using // the properties of the glvalue that do not depend on its value is well-defined. // The program has undefined behavior if // -- the glvalue is used to access the object, or // NOTE on conversion/comparison and uint32_t: // These conversions are host platform dependent. Expand All @@ -78,15 +112,10 @@ IPAddress::IPAddress(uint32_t address) IPAddress::IPAddress(const uint8_t *address) : IPAddress(IPv4, address) {} IPAddress::IPAddress(IPType ip_type, const uint8_t *address) IPAddress::IPAddress(IPType ip_type, const uint8_t *address) : _type(ip_type) { _type = ip_type; if (ip_type == IPv4) { memset(_address.bytes, 0, sizeof(_address.bytes)); memcpy(&_address.bytes[IPADDRESS_V4_BYTES_INDEX], address, sizeof(uint32_t)); } else { memcpy(_address.bytes, address, sizeof(_address.bytes)); } const size_t copy_size = (ip_type == IPv4) ? sizeof(uint32_t) : sizeof(_address); memcpy(raw_address(), address, copy_size); } IPAddress::IPAddress(const char *address) Expand All @@ -97,18 +126,18 @@ IPAddress::IPAddress(const char *address) String IPAddress::toString4() const { char szRet[16]; snprintf(szRet, sizeof(szRet), "%u.%u.%u.%u", _address.bytes [IPADDRESS_V4_BYTES_INDEX], _address.bytes [IPADDRESS_V4_BYTES_INDEX + 1], _address.bytes [IPADDRESS_V4_BYTES_INDEX + 2], _address.bytes [IPADDRESS_V4_BYTES_INDEX + 3]); snprintf(szRet, sizeof(szRet), "%u.%u.%u.%u", _address[IPADDRESS_V4_BYTES_INDEX], _address[IPADDRESS_V4_BYTES_INDEX + 1], _address[IPADDRESS_V4_BYTES_INDEX + 2], _address[IPADDRESS_V4_BYTES_INDEX + 3]); return String(szRet); } String IPAddress::toString6() const { char szRet[40]; snprintf(szRet, sizeof(szRet), "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x", _address.bytes [0], _address.bytes [1], _address.bytes [2], _address.bytes [3], _address.bytes [4], _address.bytes [5], _address.bytes [6], _address.bytes [7], _address.bytes [8], _address.bytes [9], _address.bytes [10], _address.bytes [11], _address.bytes [12], _address.bytes [13], _address.bytes [14], _address.bytes [15]); _address[0], _address[1], _address[2], _address[3], _address[4], _address[5], _address[6], _address[7], _address[8], _address[9], _address[10], _address[11], _address[12], _address[13], _address[14], _address[15]); return String(szRet); } Expand All @@ -135,7 +164,7 @@ bool IPAddress::fromString4(const char *address) int16_t acc = -1; // Accumulator uint8_t dots = 0; memset(_address.bytes , 0, sizeof(_address.bytes )); memset(_address, 0, sizeof(_address)); while (*address) { char c = *address++; Expand All @@ -157,7 +186,7 @@ bool IPAddress::fromString4(const char *address) /* No value between dots, e.g. '1..' */ return false; } _address.bytes [IPADDRESS_V4_BYTES_INDEX + dots++] = acc; _address[IPADDRESS_V4_BYTES_INDEX + dots++] = acc; acc = -1; } else Expand All @@ -175,7 +204,7 @@ bool IPAddress::fromString4(const char *address) /* No value between dots, e.g. '1..' */ return false; } _address.bytes [IPADDRESS_V4_BYTES_INDEX + 3] = acc; _address[IPADDRESS_V4_BYTES_INDEX + 3] = acc; _type = IPv4; return true; } Expand Down Expand Up @@ -215,8 +244,8 @@ bool IPAddress::fromString6(const char *address) { if (colons == 7) // too many separators return false; _address.bytes [colons * 2] = acc >> 8; _address.bytes [colons * 2 + 1] = acc & 0xff; _address[colons * 2] = acc >> 8; _address[colons * 2 + 1] = acc & 0xff; colons++; acc = 0; } Expand All @@ -233,15 +262,15 @@ bool IPAddress::fromString6(const char *address) { // Too many segments (double colon must be at least one zero field) return false; } _address.bytes [colons * 2] = acc >> 8; _address.bytes [colons * 2 + 1] = acc & 0xff; _address[colons * 2] = acc >> 8; _address[colons * 2 + 1] = acc & 0xff; colons++; if (double_colons != -1) { for (int i = colons * 2 - double_colons * 2 - 1; i >= 0; i--) _address.bytes [16 - colons * 2 + double_colons * 2 + i] = _address.bytes [double_colons * 2 + i]; _address[16 - colons * 2 + double_colons * 2 + i] = _address[double_colons * 2 + i]; for (int i = double_colons * 2; i < 16 - colons * 2 + double_colons * 2; i++) _address.bytes [i] = 0; _address[i] = 0; } _type = IPv6; Expand All @@ -252,8 +281,10 @@ IPAddress& IPAddress::operator=(const uint8_t *address) { // IPv4 only conversion from byte pointer _type = IPv4; memset(_address.bytes, 0, sizeof(_address.bytes)); memcpy(&_address.bytes[IPADDRESS_V4_BYTES_INDEX], address, sizeof(uint32_t)); memset(_address, 0, sizeof(_address)); memcpy(raw_address(), address, sizeof(uint32_t)); return *this; } Expand All @@ -268,35 +299,29 @@ IPAddress& IPAddress::operator=(uint32_t address) // IPv4 conversion // See note on conversion/comparison and uint32_t _type = IPv4; memset(_address.bytes , 0, sizeof(_address.bytes )); _address.dword[IPADDRESS_V4_DWORD_INDEX] = address; memset(_address, 0, sizeof(_address)); new (raw_address()) uint32_t ( address); // See the comments in corresponding constructor. return *this; } bool IPAddress::operator==(const IPAddress& addr) const { return (addr._type == _type) && (memcmp(addr._address.bytes , _address.bytes , sizeof(_address.bytes )) == 0); && (memcmp(addr._address, _address, sizeof(_address)) == 0); } bool IPAddress::operator==(const uint8_t* addr) const { // IPv4 only comparison to byte pointer // Can't support IPv6 as we know our type, but not the length of the pointer return _type == IPv4 && memcmp(addr,&_address.bytes[IPADDRESS_V4_BYTES_INDEX] , sizeof(uint32_t)) == 0; return _type == IPv4 && memcmp(addr,raw_address() , sizeof(uint32_t)) == 0; } uint8_t IPAddress::operator[](int index) const { if (_type == IPv4) { return _address.bytes[IPADDRESS_V4_BYTES_INDEX + index]; } return _address.bytes[index]; return *(raw_address() + index); } uint8_t& IPAddress::operator[](int index) { if (_type == IPv4) { return _address.bytes[IPADDRESS_V4_BYTES_INDEX + index]; } return _address.bytes[index]; return *(raw_address() + index); } size_t IPAddress::printTo(Print& p) const Expand All @@ -310,7 +335,7 @@ size_t IPAddress::printTo(Print& p) const int8_t current_start = -1; int8_t current_length = 0; for (int8_t f = 0; f < 8; f++) { if (_address.bytes [f * 2] == 0 && _address.bytes [f * 2 + 1] == 0) { if (_address[f * 2] == 0 && _address[f * 2 + 1] == 0) { if (current_start == -1) { current_start = f; current_length = 1; Expand All @@ -327,10 +352,10 @@ size_t IPAddress::printTo(Print& p) const } for (int f = 0; f < 8; f++) { if (f < longest_start || f >= longest_start + longest_length) { uint8_t c1 = _address.bytes [f * 2] >> 4; uint8_t c2 = _address.bytes [f * 2] & 0xf; uint8_t c3 = _address.bytes [f * 2 + 1] >> 4; uint8_t c4 = _address.bytes [f * 2 + 1] & 0xf; uint8_t c1 = _address[f * 2] >> 4; uint8_t c2 = _address[f * 2] & 0xf; uint8_t c3 = _address[f * 2 + 1] >> 4; uint8_t c4 = _address[f * 2 + 1] & 0xf; if (c1 > 0) { n += p.print((char)(c1 < 10 ? '0' + c1 : 'a' + c1 - 10)); } Expand All @@ -357,10 +382,10 @@ size_t IPAddress::printTo(Print& p) const // IPv4 for (int i =0; i < 3; i++) { n += p.print(_address.bytes [IPADDRESS_V4_BYTES_INDEX + i], DEC); n += p.print(_address[IPADDRESS_V4_BYTES_INDEX + i], DEC); n += p.print('.'); } n += p.print(_address.bytes [IPADDRESS_V4_BYTES_INDEX + 3], DEC); n += p.print(_address[IPADDRESS_V4_BYTES_INDEX + 3], DEC); return n; } Expand Down