WiFi: ARP gratuitous API for wifi station mode (#6889)

d-a-v · web-flow · commit bc170e6d635b · 2020-04-09T16:19:15.000+02:00
* wifi: ARP gratuitous API for wifi station mode

* fix with lwip1

* update comment

* update API to allow changing interval on the fly

* update API

* remove debug lines

* mock lwIP's etharp_request()

* unsigned interval

* use scheduled ticker

* ticker: +attach_ms_scheduled_accurate
ticker: +comment
gratuitous: use attach_ms_scheduled_accurate

* move to experimental namespace

* fix for lwIP-v1.4

* attempt to make pio happy

* use directly ETSTimer instead of Ticker
diff --git a/libraries/ESP8266WiFi/keywords.txt b/libraries/ESP8266WiFi/keywords.txt
@@ -26,6 +26,7 @@ PublicKey	KEYWORD1
 CertStoreSPIFFSBearSSL	KEYWORD1
 CertStoreSDBearSSL	KEYWORD1
 Session	KEYWORD1
+ESP8266WiFiGratuitous	KEYWORD1
 
 
 #######################################
@@ -108,6 +109,9 @@ psk	KEYWORD2
 BSSID	KEYWORD2
 BSSIDstr	KEYWORD2
 RSSI	KEYWORD2
+stationKeepAliveSetIntervalMs	KEYWORD2
+stationKeepAliveStop	KEYWORD2
+stationKeepAliveNow	KEYWORD2
 enableInsecureWEP	KEYWORD2
 getListenInterval	KEYWORD2
 isSleepLevelMax		KEYWORD2
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiGratuitous.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiGratuitous.cpp
@@ -0,0 +1,94 @@
+/*
+ ESP8266WiFiGratuitous.cpp - esp8266 Wifi support
+ copyright esp8266/arduino
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+extern "C"
+{
+#include "lwip/init.h" // LWIP_VERSION_*
+#if LWIP_VERSION_MAJOR == 1
+#include "netif/wlan_lwip_if.h" // eagle_lwip_getif()
+#include "netif/etharp.h" // gratuitous arp
+#include "user_interface.h"
+#else
+#include "lwip/etharp.h" // gratuitous arp
+#endif
+} // extern "C"
+
+#include <Schedule.h>
+
+#include "ESP8266WiFiGratuitous.h"
+
+namespace experimental
+{
+
+ETSTimer* ESP8266WiFiGratuitous::_timer = nullptr;
+
+void ESP8266WiFiGratuitous::stationKeepAliveNow ()
+{
+    for (netif* interface = netif_list; interface != nullptr; interface = interface->next)
+        if (
+               (interface->flags & NETIF_FLAG_LINK_UP)
+            && (interface->flags & NETIF_FLAG_UP)
+#if LWIP_VERSION_MAJOR == 1
+            && interface == eagle_lwip_getif(STATION_IF) /* lwip1 does not set if->num properly */
+            && (!ip_addr_isany(&interface->ip_addr))
+#else
+            && interface->num == STATION_IF
+            && (!ip4_addr_isany_val(*netif_ip4_addr(interface)))
+#endif
+        )
+        {
+            etharp_gratuitous(interface);
+            break;
+        }
+}
+
+void ESP8266WiFiGratuitous::scheduleItForNextYieldOnce (void*)
+{
+    schedule_recurrent_function_us([]()
+    {
+        ESP8266WiFiGratuitous::stationKeepAliveNow();
+        return false;
+    }, 0);
+}
+
+bool ESP8266WiFiGratuitous::stationKeepAliveSetIntervalMs (uint32_t ms)
+{
+    if (_timer)
+    {
+        os_timer_disarm(_timer);
+        _timer = nullptr;
+    }
+
+    if (ms)
+    {
+        // send one now
+        stationKeepAliveNow();
+
+        _timer = (ETSTimer*)malloc(sizeof(ETSTimer));
+        if (_timer == nullptr)
+            return false;
+
+        os_timer_setfn(_timer, ESP8266WiFiGratuitous::scheduleItForNextYieldOnce, nullptr);
+        os_timer_arm(_timer, ms, true);
+    }
+
+    return true;
+}
+
+}; // experimental::
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiGratuitous.h b/libraries/ESP8266WiFi/src/ESP8266WiFiGratuitous.h
@@ -0,0 +1,54 @@
+/*
+ ESP8266WiFiGratuitous.h - esp8266 Wifi support
+ copyright esp8266/arduino
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef ESP8266WIFIGRATUITOUS_H_
+#define ESP8266WIFIGRATUITOUS_H_
+
+#include <stdint.h>  // uint32_t
+#include <ets_sys.h> // ETSTimer
+
+namespace experimental
+{
+
+class ESP8266WiFiGratuitous
+{
+public:
+
+    // disable(0) or enable/update automatic sending of Gratuitous ARP packets.
+    // A gratuitous ARP packet is immediately sent when calling this function, then
+    // based on a time interval in milliseconds, default = 1s
+    // return value: true when started, false otherwise
+    static bool stationKeepAliveSetIntervalMs (uint32_t ms = 1000);
+
+    // request for stopping arp gratuitous packets
+    static void stationKeepAliveStop () { (void)stationKeepAliveSetIntervalMs(0); }
+
+    // immediately send one gratuitous ARP from STA
+    static void stationKeepAliveNow ();
+
+protected:
+
+    static void scheduleItForNextYieldOnce (void*);
+
+    static ETSTimer* _timer;
+};
+
+}; // experimental::
+
+#endif // ESP8266WIFIGRATUITOUS_H_
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.cpp
@@ -89,7 +89,7 @@ static bool sta_config_equal(const station_config& lhs, const station_config& rh
             return false;
         }
     }
-    
+
     if(lhs.threshold.rssi != rhs.threshold.rssi) {
         return false;
     }
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.h b/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.h
@@ -41,8 +41,8 @@ class ESP8266WiFiSTAClass {
         wl_status_t begin(const String& ssid, const String& passphrase = emptyString, int32_t channel = 0, const uint8_t* bssid = NULL, bool connect = true);
         wl_status_t begin();
 
-        //The argument order for ESP is not the same as for Arduino. However, there is compatibility code under the hood 
-        //to detect Arduino arg order, and handle it correctly. Be aware that the Arduino default value handling doesn't 
+        //The argument order for ESP is not the same as for Arduino. However, there is compatibility code under the hood
+        //to detect Arduino arg order, and handle it correctly. Be aware that the Arduino default value handling doesn't
         //work here (see Arduino docs for gway/subnet defaults). In other words: at least 3 args must always be given.
         bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = (uint32_t)0x00000000, IPAddress dns2 = (uint32_t)0x00000000);
 
diff --git a/libraries/Ticker/src/Ticker.h b/libraries/Ticker/src/Ticker.h
@@ -35,75 +35,94 @@ class Ticker
     typedef void (*callback_with_arg_t)(void*);
     typedef std::function<void(void)> callback_function_t;
 
+    // callback will be called at following loop() after ticker fires
     void attach_scheduled(float seconds, callback_function_t callback)
     {
         _callback_function = [callback]() { schedule_function(callback); };
         _attach_ms(1000UL * seconds, true);
     }
 
+    // callback will be called in SYS ctx when ticker fires
     void attach(float seconds, callback_function_t callback)
     {
         _callback_function = std::move(callback);
         _attach_ms(1000UL * seconds, true);
     }
 
+    // callback will be called at following loop() after ticker fires
     void attach_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
     {
         _callback_function = [callback]() { schedule_function(callback); };
         _attach_ms(milliseconds, true);
     }
 
+    // callback will be called at following yield() after ticker fires
+    void attach_ms_scheduled_accurate(uint32_t milliseconds, callback_function_t callback)
+    {
+        _callback_function = [callback]() { schedule_recurrent_function_us([callback]() { callback(); return false; }, 0); };
+        _attach_ms(milliseconds, true);
+    }
+
+    // callback will be called in SYS ctx when ticker fires
     void attach_ms(uint32_t milliseconds, callback_function_t callback)
     {
         _callback_function = std::move(callback);
         _attach_ms(milliseconds, true);
     }
 
+    // callback will be called in SYS ctx when ticker fires
     template<typename TArg>
     void attach(float seconds, void (*callback)(TArg), TArg arg)
     {
         static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
         _attach_ms(1000UL * seconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
     }
 
+    // callback will be called in SYS ctx when ticker fires
     template<typename TArg>
     void attach_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)
     {
         static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
         _attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
     }
 
+    // callback will be called at following loop() after ticker fires
     void once_scheduled(float seconds, callback_function_t callback)
     {
         _callback_function = [callback]() { schedule_function(callback); };
         _attach_ms(1000UL * seconds, false);
     }
 
+    // callback will be called in SYS ctx when ticker fires
     void once(float seconds, callback_function_t callback)
     {
         _callback_function = std::move(callback);
         _attach_ms(1000UL * seconds, false);
     }
 
+    // callback will be called at following loop() after ticker fires
     void once_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
     {
         _callback_function = [callback]() { schedule_function(callback); };
         _attach_ms(milliseconds, false);
     }
 
+    // callback will be called in SYS ctx when ticker fires
     void once_ms(uint32_t milliseconds, callback_function_t callback)
     {
         _callback_function = std::move(callback);
         _attach_ms(milliseconds, false);
     }
 
+    // callback will be called in SYS ctx when ticker fires
     template<typename TArg>
     void once(float seconds, void (*callback)(TArg), TArg arg)
     {
         static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
         _attach_ms(1000UL * seconds, false, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
     }
 
+    // callback will be called in SYS ctx when ticker fires
     template<typename TArg>
     void once_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)
     {
diff --git a/tests/host/common/MocklwIP.cpp b/tests/host/common/MocklwIP.cpp
@@ -26,4 +26,11 @@ const ip_addr_t* sntp_getserver(u8_t)
     return IP_ADDR_ANY;
 }
 
+err_t etharp_request(struct netif *netif, const ip4_addr_t *ipaddr)
+{
+    (void)netif;
+    (void)ipaddr;
+    return ERR_OK;
+}
+
 } // extern "C"

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ static bool sta_config_equal(const station_config& lhs, const station_config& rh`
`89`	`89`	`return false;`
`90`	`90`	`}`
`91`	`91`	`}`
`92`		`-`
	`92`	`+`
`93`	`93`	`if(lhs.threshold.rssi != rhs.threshold.rssi) {`
`94`	`94`	`return false;`
`95`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,75 +35,94 @@ class Ticker`
`35`	`35`	`typedef void (callback_with_arg_t)(void);`
`36`	`36`	`typedef std::function<void(void)> callback_function_t;`
`37`	`37`
	`38`	`+ // callback will be called at following loop() after ticker fires`
`38`	`39`	`void attach_scheduled(float seconds, callback_function_t callback)`
`39`	`40`	`{`
`40`	`41`	`_callback_function = [callback]() { schedule_function(callback); };`
`41`	`42`	`_attach_ms(1000UL * seconds, true);`
`42`	`43`	`}`
`43`	`44`
	`45`	`+ // callback will be called in SYS ctx when ticker fires`
`44`	`46`	`void attach(float seconds, callback_function_t callback)`
`45`	`47`	`{`
`46`	`48`	`_callback_function = std::move(callback);`
`47`	`49`	`_attach_ms(1000UL * seconds, true);`
`48`	`50`	`}`
`49`	`51`
	`52`	`+ // callback will be called at following loop() after ticker fires`
`50`	`53`	`void attach_ms_scheduled(uint32_t milliseconds, callback_function_t callback)`
`51`	`54`	`{`
`52`	`55`	`_callback_function = [callback]() { schedule_function(callback); };`
`53`	`56`	`_attach_ms(milliseconds, true);`
`54`	`57`	`}`
`55`	`58`
	`59`	`+ // callback will be called at following yield() after ticker fires`
	`60`	`+ void attach_ms_scheduled_accurate(uint32_t milliseconds, callback_function_t callback)`
	`61`	`+ {`
	`62`	`+ _callback_function = [callback]() { schedule_recurrent_function_us([callback]() { callback(); return false; }, 0); };`
	`63`	`+ _attach_ms(milliseconds, true);`
	`64`	`+ }`
	`65`	`+`
	`66`	`+ // callback will be called in SYS ctx when ticker fires`
`56`	`67`	`void attach_ms(uint32_t milliseconds, callback_function_t callback)`
`57`	`68`	`{`
`58`	`69`	`_callback_function = std::move(callback);`
`59`	`70`	`_attach_ms(milliseconds, true);`
`60`	`71`	`}`
`61`	`72`
	`73`	`+ // callback will be called in SYS ctx when ticker fires`
`62`	`74`	`template<typename TArg>`
`63`	`75`	`void attach(float seconds, void (*callback)(TArg), TArg arg)`
`64`	`76`	`{`
`65`	`77`	`static_assert(sizeof(TArg) <= sizeof(void), "attach() callback argument size must be <= sizeof(void)");`
`66`	`78`	`_attach_ms(1000UL * seconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));`
`67`	`79`	`}`
`68`	`80`
	`81`	`+ // callback will be called in SYS ctx when ticker fires`
`69`	`82`	`template<typename TArg>`
`70`	`83`	`void attach_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)`
`71`	`84`	`{`
`72`	`85`	`static_assert(sizeof(TArg) <= sizeof(void), "attach() callback argument size must be <= sizeof(void)");`
`73`	`86`	`_attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));`
`74`	`87`	`}`
`75`	`88`
	`89`	`+ // callback will be called at following loop() after ticker fires`
`76`	`90`	`void once_scheduled(float seconds, callback_function_t callback)`
`77`	`91`	`{`
`78`	`92`	`_callback_function = [callback]() { schedule_function(callback); };`
`79`	`93`	`_attach_ms(1000UL * seconds, false);`
`80`	`94`	`}`
`81`	`95`
	`96`	`+ // callback will be called in SYS ctx when ticker fires`
`82`	`97`	`void once(float seconds, callback_function_t callback)`
`83`	`98`	`{`
`84`	`99`	`_callback_function = std::move(callback);`
`85`	`100`	`_attach_ms(1000UL * seconds, false);`
`86`	`101`	`}`
`87`	`102`
	`103`	`+ // callback will be called at following loop() after ticker fires`
`88`	`104`	`void once_ms_scheduled(uint32_t milliseconds, callback_function_t callback)`
`89`	`105`	`{`
`90`	`106`	`_callback_function = [callback]() { schedule_function(callback); };`
`91`	`107`	`_attach_ms(milliseconds, false);`
`92`	`108`	`}`
`93`	`109`
	`110`	`+ // callback will be called in SYS ctx when ticker fires`
`94`	`111`	`void once_ms(uint32_t milliseconds, callback_function_t callback)`
`95`	`112`	`{`
`96`	`113`	`_callback_function = std::move(callback);`
`97`	`114`	`_attach_ms(milliseconds, false);`
`98`	`115`	`}`
`99`	`116`
	`117`	`+ // callback will be called in SYS ctx when ticker fires`
`100`	`118`	`template<typename TArg>`
`101`	`119`	`void once(float seconds, void (*callback)(TArg), TArg arg)`
`102`	`120`	`{`
`103`	`121`	`static_assert(sizeof(TArg) <= sizeof(void), "attach() callback argument size must be <= sizeof(void)");`
`104`	`122`	`_attach_ms(1000UL * seconds, false, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));`
`105`	`123`	`}`
`106`	`124`
	`125`	`+ // callback will be called in SYS ctx when ticker fires`
`107`	`126`	`template<typename TArg>`
`108`	`127`	`void once_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)`
`109`	`128`	`{`