espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-08-05 21:54:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/esp_netif_manual_set_default' into 'master'

Browse Source 
esp_netif: Support for manual set-default-netif

Closes IDFGH-6701

See merge request espressif/esp-idf!17228
This commit is contained in:
David Čermák
2022-03-12 17:21:29 +08:00
parent bfc2fd9d5d fabad2a13a
commit 99d125a06b
3 changed files with 100 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
components/esp_netif/include/esp_netif.h
View File

@@ -350,6 +350,18 @@ void esp_netif_action_add_ip6_address(void *esp_netif, esp_event_base_t base, in
*/
void esp_netif_action_remove_ip6_address(void *esp_netif, esp_event_base_t base, int32_t event_id, void *data);
/**
* @brief Manual configuration of the default netif
*
* This API overrides the automatic configuration of the default interface based on the route_prio
* If the selected netif is set default using this API, no other interface could be set-default disregarding
* its route_prio number (unless the selected netif gets destroyed)
*
* @param[in] esp_netif Handle to esp-netif instance
* @return ESP_OK on success
*/
esp_err_t esp_netif_set_default_netif(esp_netif_t *esp_netif);
/**
* @}
*/

36
components/esp_netif/lwip/esp_netif_lwip.c
View File

@@ -92,6 +92,7 @@ typedef enum esp_netif_action {
ESP_NETIF_UNDEF,
ESP_NETIF_STARTED,
ESP_NETIF_STOPPED,
ESP_NETIF_SET_DEFAULT,
} esp_netif_action_t;
//
@@ -103,6 +104,7 @@ static const char *TAG = "esp_netif_lwip";
static bool tcpip_initialized = false;
static esp_netif_t *s_last_default_esp_netif = NULL;
static bool s_is_last_default_esp_netif_overridden = false;
#if !LWIP_TCPIP_CORE_LOCKING
static sys_sem_t api_sync_sem = NULL;
@@ -140,7 +142,7 @@ static inline esp_err_t esp_netif_lwip_ipc_call(esp_netif_api_fn fn, esp_netif_t
.api_fn = fn
};
#if !LWIP_TCPIP_CORE_LOCKING
if (g_lwip_task != xTaskGetCurrentTaskHandle()) {
if (tcpip_initialized && g_lwip_task != xTaskGetCurrentTaskHandle()) {
ESP_LOGD(TAG, "check: remote, if=%p fn=%p\n", netif, fn);
sys_arch_sem_wait(&api_lock_sem, 0);
tcpip_send_msg_wait_sem((tcpip_callback_fn)esp_netif_api_cb, &msg, &api_sync_sem);
@@ -176,7 +178,7 @@ static esp_netif_t* esp_netif_is_active(esp_netif_t *arg)
*
* @note: This function must be called from lwip thread
*/
static void esp_netif_set_default_netif(esp_netif_t *esp_netif)
static void esp_netif_set_default_netif_internal(esp_netif_t *esp_netif)
{
if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) {
#if CONFIG_PPP_SUPPORT
@@ -199,17 +201,31 @@ static esp_err_t esp_netif_update_default_netif_lwip(esp_netif_api_msg_t *msg)
ESP_LOGD(TAG, "%s %p", __func__, esp_netif);
if (s_is_last_default_esp_netif_overridden && action != ESP_NETIF_SET_DEFAULT) {
// check if manually configured default interface hasn't been destroyed
s_last_default_esp_netif = esp_netif_is_active(s_last_default_esp_netif);
if (s_last_default_esp_netif != NULL) {
return ESP_OK; // still valid -> don't update default netif
}
// invalid -> reset the manual override and perform auto update
s_is_last_default_esp_netif_overridden = false;
}
switch (action) {
case ESP_NETIF_SET_DEFAULT:
s_last_default_esp_netif = esp_netif;
s_is_last_default_esp_netif_overridden = true;
esp_netif_set_default_netif_internal(s_last_default_esp_netif);
break;
case ESP_NETIF_STARTED:
{
// check if previously default interface hasn't been destroyed in the meantime
s_last_default_esp_netif = esp_netif_is_active(s_last_default_esp_netif);
if (s_last_default_esp_netif && esp_netif_is_netif_up(s_last_default_esp_netif)
&& (s_last_default_esp_netif->route_prio > esp_netif->route_prio)) {
esp_netif_set_default_netif(s_last_default_esp_netif);
esp_netif_set_default_netif_internal(s_last_default_esp_netif);
} else if (esp_netif_is_netif_up(esp_netif)) {
s_last_default_esp_netif = esp_netif;
esp_netif_set_default_netif(s_last_default_esp_netif);
esp_netif_set_default_netif_internal(s_last_default_esp_netif);
}
}
break;
@@ -235,7 +251,7 @@ static esp_err_t esp_netif_update_default_netif_lwip(esp_netif_api_msg_t *msg)
}
esp_netif_list_unlock();
if (s_last_default_esp_netif && esp_netif_is_netif_up(s_last_default_esp_netif)) {
esp_netif_set_default_netif(s_last_default_esp_netif);
esp_netif_set_default_netif_internal(s_last_default_esp_netif);
}
}
break;
@@ -254,6 +270,11 @@ static esp_err_t esp_netif_update_default_netif(esp_netif_t *esp_netif, esp_neti
return esp_netif_lwip_ipc_call(esp_netif_update_default_netif_lwip, esp_netif, (void*)action);
}
esp_err_t esp_netif_set_default_netif(esp_netif_t *esp_netif)
{
return esp_netif_update_default_netif(esp_netif, ESP_NETIF_SET_DEFAULT);
}
void esp_netif_set_ip4_addr(esp_ip4_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
{
ip4_addr_t *address = (ip4_addr_t*)addr;
@@ -605,10 +626,7 @@ void esp_netif_destroy(esp_netif_t *esp_netif)
#if CONFIG_ESP_NETIF_L2_TAP
vSemaphoreDelete(esp_netif->transmit_mutex);
#endif // CONFIG_ESP_NETIF_L2_TAP
if (s_last_default_esp_netif == esp_netif) {
// clear last default netif if it happens to be this just destroyed interface
s_last_default_esp_netif = NULL;
}
esp_netif_update_default_netif(esp_netif, ESP_NETIF_STOPPED);
free(esp_netif);
}
}

62
components/esp_netif/test/test_esp_netif.c
View File

@@ -1,10 +1,12 @@
#include <string.h>
#include "unity.h"
#include "test_utils.h"
#include "esp_netif.h"
#include "esp_wifi.h"
#include "nvs_flash.h"
#include "esp_wifi_netif.h"
#include <string.h>
#include "lwip/netif.h"
#include "esp_netif_net_stack.h"
TEST_CASE("esp_netif: init and destroy", "[esp_netif]")
@@ -353,3 +355,61 @@ TEST_CASE("esp_netif: create and destroy default wifi interfaces", "[esp_netif][
TEST_ASSERT_NOT_NULL(sta);
esp_netif_destroy_default_wifi(sta);
}
static esp_err_t dummy_transmit(void* hd, void *buf, size_t length)
{
return ESP_OK;
}
TEST_CASE("esp_netif: test routing priority", "[esp_netif]")
{
test_case_uses_tcpip();
// interface key has to be a unique identifier
const char *if_keys[] = {"if0", "if1", "if2", "if3", "if4", "if5", "if6", "if7", "if8", "if9"};
const int nr_of_netifs = sizeof(if_keys) / sizeof(char *);
esp_netif_t *netifs[nr_of_netifs];
esp_netif_driver_ifconfig_t driver_config = { .handle = (void*)1, .transmit = dummy_transmit };
// create 10 netifs with different route prio
int max_prio_i = nr_of_netifs / 2; // index of netif with maximum route-prio
for (int i = 0; i < nr_of_netifs; ++i) {
esp_netif_inherent_config_t base_netif_config = { .if_key = if_keys[i],
.route_prio = i > max_prio_i ? 0 : i };
esp_netif_config_t cfg = { .base = &base_netif_config,
.stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_STA,
.driver = &driver_config };
netifs[i] = esp_netif_new(&cfg);
TEST_ASSERT_NOT_NULL(netifs[i]);
// set the interface up and connected -- to enable the default netif based on route_prio
esp_netif_action_start(netifs[i], 0, 0, 0);
esp_netif_action_connected(netifs[i], 0, 0, 0);
}
// route_prio increases with index until max_prio_i -> check this is the default netif
TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[max_prio_i]), netif_default);
// now we stop the max_prio netif and check the default is on the previous index (max_prio-1)
esp_netif_action_stop(netifs[max_prio_i], 0, 0, 0);
TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[max_prio_i - 1]), netif_default);
// now we override the default netif with API (which has route_prio == 0)
int override_prio_i = nr_of_netifs - 1; // last netif to be set-default manually
esp_netif_set_default_netif(netifs[override_prio_i]);
// check the configured netif is default
TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[override_prio_i]), netif_default);
// try to start/connect the previously stopped netif with max_prio
esp_netif_action_start(netifs[max_prio_i], 0, 0, 0);
esp_netif_action_connected(netifs[max_prio_i], 0, 0, 0);
// and check the configured netif is still the default
TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[override_prio_i]), netif_default);
// we destroy the configured default netif
esp_netif_destroy(netifs[override_prio_i]);
// ...and check the max-prio netif is default now
TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[max_prio_i]), netif_default);
// stop the max_prio netif, to see the auto-default still works
esp_netif_action_stop(netifs[max_prio_i], 0, 0, 0);
// ...so the current default is on (max_prio-1)
TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[max_prio_i - 1]), netif_default);
// destroy one by one and check it's been removed
for (int i=0; i < override_prio_i; ++i) {
esp_netif_destroy(netifs[i]);
TEST_ASSERT_FALSE(esp_netif_is_netif_listed(netifs[i]));
}
}