ipv6: now compiles and links

esp8266 · d-a-v · Nov 27, 2018 · Aug 22, 2018 · Aug 22, 2018 · Aug 22, 2018
commit b26701a08fe32f67385cb74ceb0987c9402330ac
diff --git a/cores/esp8266/IPAddress.cpp b/cores/esp8266/IPAddress.cpp
@@ -22,22 +22,22 @@
 #include <Print.h>
 
 IPAddress::IPAddress() {
-    _address.dword = 0;
+    ipv4() = 0;
 }
 
 IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet) {
-    _address.bytes[0] = first_octet;
-    _address.bytes[1] = second_octet;
-    _address.bytes[2] = third_octet;
-    _address.bytes[3] = fourth_octet;
+    (*this)[0] = first_octet;
+    (*this)[1] = second_octet;
+    (*this)[2] = third_octet;
+    (*this)[3] = fourth_octet;
 }
 
 IPAddress::IPAddress(uint32_t address) {
-    _address.dword = address;
+    ipv4() = address;
 }
 
 IPAddress::IPAddress(const uint8_t *address) {
-    memcpy(_address.bytes, address, sizeof(_address.bytes));
+    ipv4() = *reinterpret_cast<const uint32_t*>(address);
 }
 
 bool IPAddress::fromString(const char *address) {
@@ -63,7 +63,7 @@ bool IPAddress::fromString(const char *address) {
                 // Too much dots (there must be 3 dots)
                 return false;
             }
-            _address.bytes[dots++] = acc;
+            (*this)[dots++] = acc;
             acc = 0;
         }
         else
@@ -77,38 +77,38 @@ bool IPAddress::fromString(const char *address) {
         // Too few dots (there must be 3 dots)
         return false;
     }
-    _address.bytes[3] = acc;
+    (*this)[3] = acc;
     return true;
 }
 
 IPAddress& IPAddress::operator=(const uint8_t *address) {
-    memcpy(_address.bytes, address, sizeof(_address.bytes));
+    ipv4() = *reinterpret_cast<const uint32_t*>(address);
     return *this;
 }
 
 IPAddress& IPAddress::operator=(uint32_t address) {
-    _address.dword = address;
+    ipv4() = address;
     return *this;
 }
 
 bool IPAddress::operator==(const uint8_t* addr) const {
-    return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
+    return ipv4() == *reinterpret_cast<const uint32_t*>(addr);
 }
 
 size_t IPAddress::printTo(Print& p) const {
     size_t n = 0;
     for(int i = 0; i < 3; i++) {
-        n += p.print(_address.bytes[i], DEC);
+        n += p.print((*this)[i], DEC);
         n += p.print('.');
     }
-    n += p.print(_address.bytes[3], DEC);
+    n += p.print((*this)[3], DEC);
     return n;
 }
 
 String IPAddress::toString() const
 {
     char szRet[16];
-    sprintf(szRet,"%u.%u.%u.%u", _address.bytes[0], _address.bytes[1], _address.bytes[2], _address.bytes[3]);
+    sprintf(szRet,"%u.%u.%u.%u", (*this)[0], (*this)[1], (*this)[2], (*this)[3]);
     return String(szRet);
 }
 

diff --git a/cores/esp8266/IPAddress.h b/cores/esp8266/IPAddress.h
@@ -24,23 +24,27 @@
 #include <WString.h>
 #include <Printable.h>
 
+#include <lwip/init.h>
 #include <lwip/ip_addr.h>
 
 // A class to make it easier to handle and pass around IP addresses
 
 class IPAddress: public Printable {
     private:
-        union {
-                uint8_t bytes[4];  // IPv4 address
-                uint32_t dword;
-        } _address;
+
+        ip_addr_t _ip;
+
+        //uint32_t& ipv4() { return ip_2_ip4(&_ip)->addr; } __attribute__((always_inline));
+
+        u32_t& ipv4()       { return ip_2_ip4(&_ip)->addr; } __attribute__((always_inline));
+        u32_t  ipv4() const { return ip_2_ip4(&_ip)->addr; } __attribute__((always_inline));
 
         // Access the raw byte array containing the address.  Because this returns a pointer
         // to the internal structure rather than a copy of the address this function should only
         // be used when you know that the usage of the returned uint8_t* will be transient and not
         // stored.
         uint8_t* raw_address() {
-            return _address.bytes;
+            return reinterpret_cast<uint8_t*>(ipv4());
         }
 
     public:
@@ -49,30 +53,29 @@ class IPAddress: public Printable {
         IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
         IPAddress(uint32_t address);
         IPAddress(const uint8_t *address);
-        IPAddress(const ip_addr_t* lwip_addr);
 
         bool fromString(const char *address);
         bool fromString(const String &address) { return fromString(address.c_str()); }
 
         // Overloaded cast operator to allow IPAddress objects to be used where a pointer
         // to a four-byte uint8_t array is expected
         operator uint32_t() const {
-            return _address.dword;
+            return ipv4();
         }
         bool operator==(const IPAddress& addr) const {
-            return _address.dword == addr._address.dword;
+            return ipv4() == addr.ipv4();
         }
         bool operator==(uint32_t addr) const {
-            return _address.dword == addr;
+            return ipv4() == addr;
         }
         bool operator==(const uint8_t* addr) const;
 
         // Overloaded index operator to allow getting and setting individual octets of the address
         uint8_t operator[](int index) co
341A
nst {
-            return _address.bytes[index];
+            return (ipv4() >> (index << 3)) & 0xff;
         }
         uint8_t& operator[](int index) {
-            return _address.bytes[index];
+            return *(raw_address() + index);
         }
 
         // Overloaded copy operators to allow initialisation of IPAddress objects from other types
@@ -100,7 +103,8 @@ class IPAddress: public Printable {
         /*
                lwIP address compatibility
         */
-        const ip_addr_t* getLwipAddr() const;
+        IPAddress(const ip_addr_t* lwip_addr) { _ip = *lwip_addr; }
+        const ip_addr_t* getLwipAddr() const { return &_ip; }
 };
 
 extern const IPAddress INADDR_NONE;

diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp
@@ -466,7 +466,7 @@ int ESP8266WiFiGenericClass::hostByName(const char* aHostname, IPAddress& aResul
     DEBUG_WIFI_GENERIC("[hostByName] request IP for: %s\n", aHostname);
     err_t err = dns_gethostbyname(aHostname, &addr, &wifi_dns_found_callback, &aResult);
     if(err == ERR_OK) {
-        aResult = addr.addr;
+        aResult = IPAddress(&addr);
     } else if(err == ERR_INPROGRESS) {
         _dns_lookup_pending = true;
         delay(timeout_ms);
@@ -503,7 +503,7 @@ void wifi_dns_found_callback(const char *name, const ip_addr_t *ipaddr, void *ca
         return;
     }
     if(ipaddr) {
-        (*reinterpret_cast<IPAddress*>(callback_arg)) = ipaddr->addr;
+        (*reinterpret_cast<IPAddress*>(callback_arg)) = IPAddress(ipaddr);
     }
     esp_schedule(); // resume the hostByName function
 }

diff --git a/libraries/ESP8266WiFi/src/WiFiUdp.cpp b/libraries/ESP8266WiFi/src/WiFiUdp.cpp
@@ -94,7 +94,7 @@ uint8_t WiFiUDP::beginMulticast(const IPAddress& interfaceAddr, const IPAddress&
         _ctx = 0;
     }
 
-    if (igmp_joingroup(interfaceAddr.getLwipAddr(), multicast.getLwipAddr())!= ERR_OK) {
+    if (igmp_joingroup(ip_2_ip4(interfaceAddr.getLwipAddr()), ip_2_ip4(multicast.getLwipAddr()))!= ERR_OK) {
         return 0;
     }
 
@@ -158,19 +158,14 @@ int WiFiUDP::beginPacket(const IPAddress& ip, uint16_t port)
 int WiFiUDP::beginPacketMulticast(const IPAddress& multicastAddress, uint16_t port,
     const IPAddress& interfaceAddress, int ttl)
 {
-    ipv4_addr_t mcastAddr;
-    mcastAddr.addr = multicastAddress;
-    ipv4_addr_t ifaceAddr;
-    ifaceAddr.addr = interfaceAddress;
-
     if (!_ctx) {
         _ctx = new UdpContext;
         _ctx->ref();
     }
-    if (!_ctx->connect(mcastAddr, port)) {
+    if (!_ctx->connect(multicastAddress.getLwipAddr(), port)) {
         return 0;
     }
-    _ctx->setMulticastInterface(ifaceAddr);
+    _ctx->setMulticastInterface(interfaceAddress.getLwipAddr());
     _ctx->setMulticastTTL(ttl);
     return 1;
 }

diff --git a/libraries/ESP8266WiFi/src/WiFiUdp.h b/libraries/ESP8266WiFi/src/WiFiUdp.h
@@ -53,7 +53,7 @@ class WiFiUDP : public UDP, public SList<WiFiUDP> {
 
   // Start building up a packet to send to the remote host specific in ip and port
   // Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
-  virtual int beginPacket(IPAddress ip, uint16_t port);
+  virtual int beginPacket(const IPAddress& ip, uint16_t port);
   // Start building up a packet to send to the remote host specific in host and port
   // Returns 1 if successful, 0 if there was a problem resolving the hostname or port
   virtual int beginPacket(const char *host, uint16_t port);

diff --git a/libraries/ESP8266WiFi/src/include/UdpContext.h b/libraries/ESP8266WiFi/src/include/UdpContext.h
@@ -159,13 +159,17 @@ class UdpContext
         return (pos <= _rx_buf->len);
     }
 
+#pragma message "FIXME"
+static ip_addr_t blark;
+
     const ip_addr_t* getRemoteAddress()
     {
         if (!_rx_buf)
             return 0;
 
-        ip_hdr* iphdr = GET_IP_HDR(_rx_buf);
-        return iphdr->src;
+        //ip_hdr* iphdr = GET_IP_HDRs(_rx_buf);
+        //return iphdr->src;
+        return &blark;
     }
 
     uint16_t getRemotePort()
@@ -182,8 +186,9 @@ class UdpContext
         if (!_rx_buf)
             return 0;
 
-        ip_hdr* iphdr = GET_IP_HDR(_rx_buf);
-        return iphdr->dest;
+        //ip_hdr* iphdr = GET_IP_HDR(_rx_buf);
+        //return iphdr->dest;
+        return &blark;
     }
 
     uint16_t getLocalPort()