esp_netif: update default DHCP IP addresses to be in line with old interface, added loopback implementation, explicit esp-netif init, sanity checks for parameters added

components/esp_common/src/esp_err_to_name.c

@@ -50,8 +50,8 @@
 #if __has_include("nvs.h")
 #include "nvs.h"
 #endif
-#if __has_include("tcpip_adapter.h")
-#include "tcpip_adapter.h"
+#if __has_include("esp_netif.h")
+#include "esp_netif.h"
 #endif
 #if __has_include("ulp_common.h")
 #include "ulp_common.h"

components/esp_eth/include/esp_eth.h

@@ -102,15 +102,6 @@ typedef struct {
         .on_lowlevel_deinit_done = NULL, \
     }
 
-/**
-* @brief Default esp-netif driver related configuration
-*
-*/
-#define ESP_NETIF_DRIVER_DEFAULT_ETH      _g_eth_driver_ifconfig
-
-struct esp_netif_driver_ifconfig;
-extern const struct esp_netif_driver_ifconfig *_g_eth_driver_ifconfig;
-
 /**
 * @brief Install Ethernet driver
 *

components/esp_eth/src/esp_eth.c

@@ -35,15 +35,6 @@ static const char *TAG = "esp_eth";
 
 ESP_EVENT_DEFINE_BASE(ETH_EVENT);
 
-// Default driver interface config, at the init moment doesn't include driver handle, as it is created
-// in starup phase, netif is updated in event handler on eth_start event with valid ethernet driver handle
-static const esp_netif_driver_ifconfig_t _s_eth_driver_ifconfig = {
-        .handle =  NULL,
-        .transmit = esp_eth_transmit,
-};
-
-const esp_netif_driver_ifconfig_t *_g_eth_driver_ifconfig = &_s_eth_driver_ifconfig;
-
 /**
  * @brief The Ethernet driver mainly consists of PHY, MAC and
  * the mediator who will handle the request/response from/to MAC, PHY and Users.
@@ -171,17 +162,16 @@ static esp_err_t esp_eth_driver_start(esp_netif_t * esp_netif, void * args)
     esp_err_t ret = ESP_OK;
     esp_eth_driver_t *eth_driver = args;
     eth_driver->base.netif = esp_netif;
-    // Update esp-netif with already created ethernet handle
+
+    // Set driver related config to esp-netif
 
     esp_netif_driver_ifconfig_t driver_ifconfig = {
             .handle =  eth_driver,
             .transmit = esp_eth_transmit,
+            .driver_free_rx_buffer = NULL
     };
-    esp_netif_config_t cfg =  {
-            .driver = &driver_ifconfig,
 
-    };
-    ESP_ERROR_CHECK(esp_netif_configure(esp_netif, &cfg));
+    ESP_ERROR_CHECK(esp_netif_set_driver_config(esp_netif, &driver_ifconfig));
     uint8_t eth_mac[6];
     esp_eth_ioctl(eth_driver, ETH_CMD_G_MAC_ADDR, eth_mac);
     ESP_LOGI(TAG, "%x %x %x %x %x %x", eth_mac[0], eth_mac[1], eth_mac[2], eth_mac[3], eth_mac[4], eth_mac[5]);

components/esp_netif/CMakeLists.txt

@@ -2,6 +2,7 @@ idf_component_register(SRCS "esp_netif_handlers.c"
                             "esp_netif_objects.c"
                             "esp_netif_defaults.c"
                             "lwip/esp_netif_lwip.c"
+                            "loopback/esp_netif_loopback.c"
                             "lwip/esp_netif_lwip_defaults.c"
                     INCLUDE_DIRS include
                     PRIV_INCLUDE_DIRS lwip private_include

components/esp_netif/Kconfig

@@ -15,20 +15,26 @@ menu "ESP NETIF Adapter"
 
     choice ESP_NETIF_USE_TCPIP_STACK_LIB
         prompt "TCP/IP Stack Library"
-        default TCPIP_LWIP
+        default ESP_NETIF_TCPIP_LWIP
         help
             Choose the TCP/IP Stack to work, for example, LwIP, uIP, etc.
-        config TCPIP_LWIP
+        config ESP_NETIF_TCPIP_LWIP
             bool "LwIP"
             help
                 lwIP is a small independent implementation of the TCP/IP protocol suite.
+
+        config ESP_NETIF_LOOPBACK
+            bool "Loopback"
+            help
+                Dummy implementation of esp-netif functionality which connects driver transmit
+                to receive function. This option is for testing purpose only
     endchoice
 
-    config ESP_NETIF_USE_TCPIP_ADAPTER_COMPATIBLE_LAYER
+    config ESP_NETIF_TCPIP_ADAPTER_COMPATIBLE_LAYER
         bool "Enable backward compatible tcpip_adapter interface"
         default y
         help
             Backward compatible interface to tcpip_adapter is enabled by default to support
-            legacy tcpip stack initialisation code. Disable this option to use only esp-netif
+            legacy TCP/IP stack initialisation code. Disable this option to use only esp-netif
             interface.
 endmenu

components/esp_netif/README.md

@@ -62,8 +62,8 @@ Overall application interaction with communication media and network stack
 * setters, getters
 * network stack abstraction: enabling user interaction with TCP/IP stack
   - netif up/down
-  - dhcp server, client
-  - dns api
+  - DHCP server, client
+  - DNS API
 * driver conversion utilities
 
 ###  D) Network stack: no public interaction with user code (wrtt interfaces)
@@ -73,7 +73,7 @@ Overall application interaction with communication media and network stack
 
 * `........`     Initialization line from user code to esp-netif and comm driver
 
-* `--<--->--`    Data packets going from communication media to tcpip stack and back
+* `--<--->--`    Data packets going from communication media to TCP/IP stack and back
 
 * `********`     Events agregated in ESP-NETIP propagates to driver, user code and network stack
 

components/esp_netif/esp_netif_defaults.c

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 #include "esp_netif.h"
-#include "esp_event.h"
 #include "esp_wifi_default.h"
 #include "esp_eth.h"
 
@@ -44,8 +43,8 @@ const esp_netif_inherent_config_t _g_esp_netif_inherent_sta_config = {
 };
 
 static const esp_netif_ip_info_t soft_ap_ip = {
-        .ip = { .addr = IP4TOADDR( 192, 168, 8, 1) },
-        .gw = { .addr = IP4TOADDR( 192, 168, 8, 1) },
+        .ip = { .addr = IP4TOADDR( 192, 168, 4, 1) },
+        .gw = { .addr = IP4TOADDR( 192, 168, 4, 1) },
         .netmask = { .addr = IP4TOADDR( 255, 255, 255, 0) },
 
 };

components/esp_netif/esp_netif_objects.c

@@ -23,8 +23,6 @@
 
 static const char *TAG = "esp_netif_objects";
 
-//#define ESP_NETIF_TYPE_DEFINE(id) const esp_netif_type_t id = #id
-
 typedef struct slist_netifs_s slist_netifs_t;
 struct slist_netifs_s {
     esp_netif_t *netif;
@@ -37,10 +35,6 @@ static size_t s_esp_netif_counter = 0;
 
 ESP_EVENT_DEFINE_BASE(IP_EVENT);
 
-//ESP_NETIF_TYPE_DEFINE(ESP_NETIF_TYPE_STA);
-//ESP_NETIF_TYPE_DEFINE(ESP_NETIF_TYPE_AP);
-//ESP_NETIF_TYPE_DEFINE(ESP_NETIF_TYPE_ETH);
-
 
 //
 // List manipulation functions

components/esp_netif/include/esp_netif.h

@@ -67,20 +67,18 @@ esp_netif_t *esp_netif_new(const esp_netif_config_t *esp_netif_config);
 void esp_netif_destroy(esp_netif_t *esp_netif);
 
 /**
- * @brief   Configures the esp_netif object
- *
- * Note: if some of the configuration parameter is null, the corresponding config
- * option is skipped. This enables calling this function multiple times to configure
- * different parts related to for example network stack or io driver separately
+ * @brief   Configures driver related options of esp_netif object
  *
  * @param[inout]  pointer to the object to be configured
- * @param[in]     esp_netif_config pointer esp-netif configuration
+ * @param[in]     driver_config pointer esp-netif io driver related configuration
  * @return
- *         - ESP_OK
+ *         - ESP_OK on success
+ *         - ESP_ERR_ESP_NETIF_INVALID_PARAMS if invalid parameters provided
  *
  */
-esp_err_t esp_netif_configure(esp_netif_t *esp_netif,
-                              const esp_netif_config_t *esp_netif_config);
+esp_err_t esp_netif_set_driver_config(esp_netif_t *esp_netif,
+                              const esp_netif_driver_ifconfig_t *driver_config);
+
 
 esp_err_t esp_netif_attach(esp_netif_t *esp_netif, esp_netif_iodriver_handle driver_handle);
 
@@ -629,13 +627,16 @@ size_t esp_netif_get_nr_of_ifs(void);
  */
 esp_err_t esp_netif_get_sta_list(const wifi_sta_list_t *wifi_sta_list, esp_netif_sta_list_t *tcpip_sta_list);
 
-int esp_netif_get_netif_index(esp_netif_t *esp_netif);
-
-#if CONFIG_ESP_NETIF_USE_TCPIP_ADAPTER_COMPATIBLE_LAYER
-//
-// 8) Compatibility layer
-//
-#include "tcpip_adapter.h"
-#endif
+/**
+ * @brief  Get net interface index from network stack implementation
+ *
+ * @note This index could be used in `setsockopt()` to bind socket with multicast interface
+ *
+ * @param[in]  esp_netif Handle to esp-netif instance
+ *
+ * @return
+ *         implementation specific index of interface represented with supplied esp_netif
+ */
+int esp_netif_get_netif_impl_index(esp_netif_t *esp_netif);
 
 #endif /*  _ESP_NETIF_H_ */

components/esp_netif/include/esp_netif_defaults.h

@@ -26,7 +26,7 @@
     {                                            \
         .base = ESP_NETIF_BASE_DEFAULT_ETH,      \
         .stack = ESP_NETIF_NETSTACK_DEFAULT_ETH, \
-        .driver = ESP_NETIF_DRIVER_DEFAULT_ETH,  \
+        .driver = NULL,  \
     }
 
 /**

components/esp_netif/include/esp_netif_ip_addr.h

@@ -24,6 +24,12 @@
                       (((x) & (uint32_t)0x00ff0000UL) >>  8) | \
                       (((x) & (uint32_t)0xff000000UL) >> 24))
 #endif
+
+#define esp_netif_ip4_makeu32(a,b,c,d) (((uint32_t)((a) & 0xff) << 24) | \
+                               ((uint32_t)((b) & 0xff) << 16) | \
+                               ((uint32_t)((c) & 0xff) << 8)  | \
+                                (uint32_t)((d) & 0xff))
+
 // Access address in 16-bit block
 #define ESP_IP6_ADDR_BLOCK1(ip6addr) ((uint16_t)((esp_netif_htonl((ip6addr)->addr[0]) >> 16) & 0xffff))
 #define ESP_IP6_ADDR_BLOCK2(ip6addr) ((uint16_t)((esp_netif_htonl((ip6addr)->addr[0])) & 0xffff))
@@ -63,6 +69,10 @@
     ESP_IP6_ADDR_BLOCK7(&(ipaddr)),     \
     ESP_IP6_ADDR_BLOCK8(&(ipaddr))
 
+#define ESP_IPADDR_TYPE_V4                0U
+#define ESP_IPADDR_TYPE_V6                6U
+#define ESP_IPADDR_TYPE_ANY               46U
+
 
 struct esp_ip6_addr {
     uint32_t addr[4];

components/esp_netif/include/esp_netif_types.h

@@ -202,6 +202,7 @@ typedef struct esp_netif_driver_ifconfig esp_netif_driver_ifconfig_t;
  */
 typedef enum esp_netif_netstack_type {
     ESP_NETIF_NETWORK_STACK_IS_LWIP = 0,
+    ESP_NETIF_NETWORK_STACK_IS_LOOPBACK = 1,
     ESP_NETIF_NETWORK_STACK_MAX,
 } esp_netif_netstack_type_t;
 

components/esp_netif/loopback/esp_netif_loopback.c

@@ -0,0 +1,466 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+
+#include "esp_netif_lwip_internal.h"
+
+#include "esp_netif.h"
+#include "esp_netif_private.h"
+
+#if CONFIG_ESP_NETIF_LOOPBACK
+
+#include "esp_log.h"
+
+//
+// Purpose of this module is to implement minimal loopback netif to facilitate
+//   low level driver testing
+//
+
+#define ESP_NETIF_HOSTNAME_MAX_SIZE    32
+
+static const char *TAG = "esp_netif_loopback";
+
+static bool s_netif_initialized = false;
+static bool s_netif_started = false;
+static bool s_netif_up = false;
+
+/**
+ * @brief Main esp-netif container with interface related information
+ *
+ *
+ */
+struct esp_netif_obj {
+    // default interface addresses
+    uint8_t mac[NETIF_MAX_HWADDR_LEN];
+    esp_netif_ip_info_t* ip_info;
+    esp_netif_ip_info_t* ip_info_old;
+
+    // io driver related
+    void* driver_handle;
+    esp_err_t (*driver_transmit)(void *h, void *buffer, size_t len);
+    void (*driver_free_rx_buffer)(void *h, void* buffer);
+
+    // misc flags, types, keys, priority
+    esp_netif_flags_t flags;
+    char * hostname;
+    char * if_key;
+    esp_netif_type_t if_type;
+    int route_prio;
+};
+
+void esp_netif_set_ip4_addr(esp_ip4_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
+{
+    memset(addr, 0, sizeof(esp_ip4_addr_t));
+    addr->addr = esp_netif_htonl(esp_netif_ip4_makeu32(a,b,c,d));
+}
+
+char * esp_ip4addr_ntoa(const esp_ip4_addr_t *addr, char *buf, int buflen)
+{
+    return NULL;
+}
+
+esp_netif_iodriver_handle esp_netif_get_io_driver(esp_netif_t *esp_netif)
+{
+    return esp_netif->driver_handle;
+}
+
+esp_netif_t* esp_netif_get_handle_from_netif_impl(void *dev)
+{
+    return NULL;
+}
+
+void* esp_netif_get_netif_impl(esp_netif_t *esp_netif)
+{
+    return NULL;
+}
+
+esp_err_t esp_netif_init(void)
+{
+    ESP_LOGI(TAG, "loopback initialization");
+    if (s_netif_initialized) {
+        ESP_LOGE(TAG, "esp-netif has already been initialized");
+        return ESP_ERR_INVALID_SIZE;
+    }
+
+    s_netif_initialized = true;
+    ESP_LOGD(TAG, "esp-netif has been successfully initialized");
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_deinit(void)
+{
+    ESP_LOGI(TAG, "loopback initialization");
+    if (!s_netif_initialized) {
+        ESP_LOGE(TAG, "esp-netif has not been initialized yet");
+        return ESP_ERR_INVALID_SIZE;
+    }
+    s_netif_initialized = false;
+    ESP_LOGD(TAG, "esp-netif has been successfully deinitialized");
+    return ESP_OK;
+}
+
+static esp_err_t esp_netif_init_configuration(esp_netif_t *esp_netif, const esp_netif_config_t *cfg)
+{
+    // Basic esp_netif and lwip is a mandatory configuration and cannot be updated after esp_netif_new()
+    if (cfg == NULL || cfg->base == NULL || cfg->stack == NULL) {
+        return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
+    }
+
+    // Configure general esp-netif properties
+    memcpy(esp_netif->mac, cfg->base->mac, NETIF_MAX_HWADDR_LEN);
+    if (cfg->base->ip_info == NULL) {
+        ip4_addr_set_zero(&esp_netif->ip_info->ip);
+        ip4_addr_set_zero(&esp_netif->ip_info->gw);
+        ip4_addr_set_zero(&esp_netif->ip_info->netmask);
+    } else {
+        memcpy(esp_netif->ip_info, cfg->base->ip_info, sizeof(esp_netif_ip_info_t));
+    }
+    memcpy(esp_netif->ip_info_old, esp_netif->ip_info, sizeof(esp_netif_ip_info_t));
+
+    // Setup main config parameters
+    esp_netif->flags = cfg->base->flags;
+
+    if (cfg->base->if_key) {
+        esp_netif->if_key = strdup(cfg->base->if_key);
+    }
+    if (cfg->base->if_type) {
+        esp_netif->if_type = cfg->base->if_type;
+    }
+    if (cfg->base->route_prio) {
+        esp_netif->route_prio = cfg->base->route_prio;
+    }
+
+    // Install network stack functions -- connects netif and L3 stack
+    if (cfg->stack->base.type != ESP_NETIF_NETWORK_STACK_IS_LOOPBACK) {
+        ESP_LOGE(TAG, "Failed to configure uknown network stack %d", cfg->stack->base.type);
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+
+    // Install IO functions only if provided -- connects driver and netif
+    // this configuration could be updated after esp_netif_new(), typically in post_attach callback
+    if (cfg->driver) {
+        const esp_netif_driver_ifconfig_t *esp_netif_driver_config = cfg->driver;
+        if (esp_netif_driver_config->handle) {
+            esp_netif->driver_handle = esp_netif_driver_config->handle;
+        }
+        if (esp_netif_driver_config->transmit) {
+            esp_netif->driver_transmit = esp_netif_driver_config->transmit;
+        }
+        if (esp_netif_driver_config->driver_free_rx_buffer) {
+            esp_netif->driver_free_rx_buffer = esp_netif_driver_config->driver_free_rx_buffer;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_netif_t *esp_netif_new(const esp_netif_config_t *esp_netif_config)
+{
+    // mandatory configuration must be provided when creating esp_netif object
+    if (esp_netif_config == NULL) {
+        return NULL;
+    }
+
+    // Create parent esp-netif object
+    esp_netif_t *esp_netif = calloc(1, sizeof(struct esp_netif_obj));
+    if (!esp_netif) {
+        return NULL;
+    }
+
+    // Create ip info
+    esp_netif_ip_info_t *ip_info = calloc(1, sizeof(esp_netif_ip_info_t));
+    if (!ip_info) {
+        free(esp_netif);
+        return NULL;
+    }
+    esp_netif->ip_info = ip_info;
+
+    // creating another ip info (to store old ip)
+    ip_info = calloc(1, sizeof(esp_netif_ip_info_t));
+    if (!ip_info) {
+        free(esp_netif->ip_info);
+        free(esp_netif);
+        return NULL;
+    }
+    esp_netif->ip_info_old = ip_info;
+
+    esp_netif_add_to_list(esp_netif);
+
+    // Configure the created object with provided configuration
+    esp_err_t ret =  esp_netif_init_configuration(esp_netif, esp_netif_config);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Initial configuration of esp_netif failed with %d", ret);
+        esp_netif_destroy(esp_netif);
+        return NULL;
+    }
+
+    return esp_netif;
+}
+
+void esp_netif_destroy(esp_netif_t *esp_netif)
+{
+    if (esp_netif) {
+        esp_netif_remove_from_list(esp_netif);
+        free(esp_netif->ip_info);
+        free(esp_netif->ip_info_old);
+        free(esp_netif->if_key);
+        free(esp_netif);
+    }
+}
+
+esp_err_t esp_netif_attach(esp_netif_t *esp_netif, esp_netif_iodriver_handle driver_handle)
+{
+    esp_netif_driver_base_t *base_driver = driver_handle;
+
+    esp_netif->driver_handle = driver_handle;
+    if (base_driver->post_attach) {
+        esp_err_t ret = base_driver->post_attach(esp_netif, driver_handle);
+        if (ret != ESP_OK) {
+            ESP_LOGE(TAG, "Post-attach callback of driver(%p) failed with %d", driver_handle, ret);
+            return ESP_ERR_ESP_NETIF_DRIVER_ATACH_FAILED;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_set_driver_config(esp_netif_t *esp_netif,
+                                      const esp_netif_driver_ifconfig_t *driver_config)
+{
+    if (esp_netif == NULL || driver_config == NULL) {
+        return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
+    }
+    esp_netif->driver_handle = driver_config->handle;
+    esp_netif->driver_transmit = driver_config->transmit;
+    esp_netif->driver_free_rx_buffer = driver_config->driver_free_rx_buffer;
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_set_mac(esp_netif_t *esp_netif, uint8_t mac[])
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_start(esp_netif_t *esp_netif)
+{
+    ESP_LOGI(TAG, "Netif started");
+    s_netif_started = true;
+    return ESP_OK;
+}
+
+
+esp_err_t esp_netif_stop(esp_netif_t *esp_netif)
+{
+    ESP_LOGI(TAG, "Netif stopped");
+    s_netif_started = false;
+    return ESP_OK;
+}
+
+//
+// IO translate functions
+//
+void esp_netif_free_rx_buffer(void *h, void* buffer)
+{
+    esp_netif_t *esp_netif = h;
+    esp_netif->driver_free_rx_buffer(esp_netif->driver_handle, buffer);
+}
+
+esp_err_t esp_netif_transmit(esp_netif_t *esp_netif, void* data, size_t len)
+{
+    ESP_LOGV(TAG, "Transmitting data: ptr:%p, size:%d", data, len);
+    return (esp_netif->driver_transmit)(esp_netif->driver_handle, data, len);
+}
+
+esp_err_t esp_netif_receive(esp_netif_t *esp_netif, void *buffer, size_t len, void *eb)
+{
+    ESP_LOGV(TAG, "Received data: ptr:%p, size:%d", buffer, len);
+    esp_netif_transmit(esp_netif, buffer, len);
+    if (eb) {
+        esp_netif_free_rx_buffer(esp_netif, eb);
+    }
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_dhcpc_stop(esp_netif_t *esp_netif)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_dhcpc_start(esp_netif_t *esp_netif)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_dhcps_get_status(esp_netif_t *esp_netif, esp_netif_dhcp_status_t *status)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_dhcpc_get_status(esp_netif_t *esp_netif, esp_netif_dhcp_status_t *status)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_dhcps_start(esp_netif_t *esp_netif)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_dhcps_stop(esp_netif_t *esp_netif)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_set_hostname(esp_netif_t *esp_netif, const char *hostname)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_get_hostname(esp_netif_t *esp_netif, const char **hostname)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_up(esp_netif_t *esp_netif)
+{
+    ESP_LOGI(TAG, "Netif going up");
+    s_netif_up = true;
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_down(esp_netif_t *esp_netif)
+{
+    ESP_LOGI(TAG, "Netif going down");
+    s_netif_up = false;
+    return ESP_OK;
+}
+
+bool esp_netif_is_netif_up(esp_netif_t *esp_netif)
+{
+    return s_netif_up;
+}
+
+esp_err_t esp_netif_get_old_ip_info(esp_netif_t *esp_netif, esp_netif_ip_info_t *ip_info)
+{
+    ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
+
+    if (esp_netif == NULL || ip_info == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    memcpy(ip_info, esp_netif->ip_info_old, sizeof(esp_netif_ip_info_t));
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_get_ip_info(esp_netif_t *esp_netif, esp_netif_ip_info_t *ip_info)
+{
+    ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
+
+    if (esp_netif == NULL || ip_info == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    memcpy(ip_info, esp_netif->ip_info, sizeof(esp_netif_ip_info_t));
+    return ESP_OK;
+}
+
+
+bool esp_netif_is_valid_static_ip(esp_netif_ip_info_t *ip_info)
+{
+    return true;
+}
+
+esp_err_t esp_netif_set_old_ip_info(esp_netif_t *esp_netif, const esp_netif_ip_info_t *ip_info)
+{
+    ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
+
+    if (esp_netif == NULL || ip_info == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    memcpy(esp_netif->ip_info_old, ip_info, sizeof(esp_netif_ip_info_t));
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_set_dns_info(esp_netif_t *esp_netif, esp_netif_dns_type_t type, esp_netif_dns_info_t *dns)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_get_dns_info(esp_netif_t *esp_netif, esp_netif_dns_type_t type, esp_netif_dns_info_t *dns)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_get_sta_list(const wifi_sta_list_t *wifi_sta_list, esp_netif_sta_list_t *netif_sta_list)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_create_ip6_linklocal(esp_netif_t *esp_netif)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_get_ip6_linklocal(esp_netif_t *esp_netif, esp_ip6_addr_t *if_ip6)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_netif_flags_t esp_netif_get_flags(esp_netif_t *esp_netif)
+{
+    return esp_netif->flags;
+}
+
+char *esp_netif_get_ifkey(esp_netif_t *esp_netif)
+{
+    return esp_netif->if_key;
+}
+
+esp_netif_type_t esp_netif_get_type(esp_netif_t *esp_netif)
+{
+    return esp_netif->if_type;
+}
+
+esp_netif_t *esp_netif_get_handle_from_ifkey(const char *if_key)
+{
+    esp_netif_t *esp_netif = esp_netif_next(NULL);
+    do {
+        if (esp_netif && strcmp(if_key, esp_netif->if_key)==0) {
+            return esp_netif;
+        }
+    } while (NULL != (esp_netif = esp_netif_next(esp_netif)));
+    return NULL;
+}
+
+uint32_t esp_netif_get_event_id(esp_netif_t *esp_netif, esp_netif_ip_event_type_t event_type)
+{
+    return 0;
+}
+
+esp_err_t esp_netif_dhcps_option(esp_netif_t *esp_netif, esp_netif_dhcp_option_mode_t opt_op, esp_netif_dhcp_option_id_t opt_id, void *opt_val,
+                                 uint32_t opt_len)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+esp_err_t esp_netif_dhcpc_option(esp_netif_t *esp_netif, esp_netif_dhcp_option_mode_t opt_op, esp_netif_dhcp_option_id_t opt_id, void *opt_val,
+                                 uint32_t opt_len)
+{
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+int esp_netif_get_netif_impl_index(esp_netif_t *esp_netif)
+{
+    return 0;
+}
+
+#endif /* CONFIG_ESP_NETIF_LOOPBACK */

components/esp_netif/lwip/esp_netif_lwip.c

@@ -12,18 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <stdio.h>
 #include <string.h>
 
 #include "esp_netif_lwip_internal.h"
 
 #include "esp_netif.h"
 #include "esp_netif_private.h"
-#include "esp_netif_net_stack.h"
 
-#if CONFIG_TCPIP_LWIP
+#if CONFIG_ESP_NETIF_TCPIP_LWIP
 
-#include "lwip/inet.h"
 #include "lwip/tcpip.h"
 #include "lwip/dhcp.h"
 #include "lwip/ip_addr.h"
@@ -34,14 +31,12 @@
 #if LWIP_DNS /* don't build if not configured for use in lwipopts.h */
 #include "lwip/dns.h"
 #endif
-#include "esp_netif_lwip_internal.h"
 
 #include "dhcpserver/dhcpserver.h"
 #include "dhcpserver/dhcpserver_options.h"
 
 #include "esp_event.h"
 #include "esp_log.h"
-#include "lwip/ip_addr.h"
 
 //
 // This is the main module implementing lwip interaction with esp-netif
@@ -64,8 +59,6 @@ static sys_sem_t api_lock_sem = NULL;
 static bool tcpip_initialized = false;
 static esp_netif_t *s_last_default_esp_netif = NULL;
 
-static int esp_netif_ipc_check(esp_netif_api_msg_t *msg);
-
 /**
  * @brief Main esp-netif container with interface related information
  *
@@ -73,7 +66,7 @@ static int esp_netif_ipc_check(esp_netif_api_msg_t *msg);
  */
 struct esp_netif_obj {
     // default interface addresses
-    uint8_t mac[6];
+    uint8_t mac[NETIF_MAX_HWADDR_LEN];
     esp_netif_ip_info_t* ip_info;
     esp_netif_ip_info_t* ip_info_old;
 
@@ -104,6 +97,55 @@ struct esp_netif_obj {
     int route_prio;
 };
 
+/**
+ * @brief thread safe tcpip function utility macro
+ */
+#define _LWIP_TASK_IPC_CALL(function, netif, param) \
+{   \
+    return esp_netif_lwip_ipc_call(function, netif, (void *)param); \
+}
+
+/**
+ * @brief Api callback from tcpip thread used to call esp-netif
+ * function in lwip task context
+ */
+static void esp_netif_api_cb(void *api_msg)
+{
+    esp_netif_api_msg_t *msg = (esp_netif_api_msg_t *)api_msg;
+
+    if (!msg || !msg->api_fn) {
+        ESP_LOGD(TAG, "null msg/api_fn");
+        return;
+    }
+
+    msg->ret = msg->api_fn(msg);
+    ESP_LOGD(TAG, "call api in lwip: ret=0x%x, give sem", msg->ret);
+    sys_sem_signal(&api_sync_sem);
+
+}
+
+/**
+ * @brief Initiates a tcpip remote call if called from another task
+ * or calls the function directly if executed from lwip task
+ */
+static inline esp_err_t esp_netif_lwip_ipc_call(esp_netif_api_fn fn, esp_netif_t *netif, void *data)
+{
+    esp_netif_api_msg_t msg = {
+            .esp_netif = netif,
+            .data = data,
+            .api_fn = fn
+    };
+    if (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);
+        sys_sem_signal(&api_lock_sem);
+        return msg.ret;
+    }
+    ESP_LOGD(TAG, "check: local, if=%p fn=%p\n", netif, fn);
+    return fn(&msg);
+}
+
 /**
  * @brief This function sets default routing netif based on priorities of all interfaces which are up
  * @param esp_netif current interface which just updated state
@@ -172,7 +214,9 @@ esp_netif_t* esp_netif_get_handle_from_netif_impl(void *dev)
 
 void* esp_netif_get_netif_impl(esp_netif_t *esp_netif)
 {
-    return esp_netif->lwip_netif;
+    if (esp_netif)
+        return esp_netif->lwip_netif;
+    return NULL;
 }
 
 esp_err_t esp_netif_init(void)
@@ -218,8 +262,76 @@ esp_err_t esp_netif_deinit(void)
     return ESP_ERR_INVALID_STATE;
 }
 
+static esp_err_t esp_netif_init_configuration(esp_netif_t *esp_netif, const esp_netif_config_t *cfg)
+{
+    // Basic esp_netif and lwip is a mandatory configuration and cannot be updated after esp_netif_new()
+    if (cfg == NULL || cfg->base == NULL || cfg->stack == NULL) {
+        return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
+    }
+
+    // Configure general esp-netif properties
+    memcpy(esp_netif->mac, cfg->base->mac, NETIF_MAX_HWADDR_LEN);
+    if (cfg->base->ip_info == NULL) {
+        ip4_addr_set_zero(&esp_netif->ip_info->ip);
+        ip4_addr_set_zero(&esp_netif->ip_info->gw);
+        ip4_addr_set_zero(&esp_netif->ip_info->netmask);
+    } else {
+        memcpy(esp_netif->ip_info, cfg->base->ip_info, sizeof(esp_netif_ip_info_t));
+    }
+    memcpy(esp_netif->ip_info_old, esp_netif->ip_info, sizeof(esp_netif_ip_info_t));
+
+    // Setup main config parameters
+    esp_netif->lost_ip_event = cfg->base->lost_ip_event;
+    esp_netif->get_ip_event = cfg->base->get_ip_event;
+    esp_netif->flags = cfg->base->flags;
+
+    if (cfg->base->if_key) {
+        esp_netif->if_key = strdup(cfg->base->if_key);
+    }
+    if (cfg->base->if_type) {
+        esp_netif->if_type = cfg->base->if_type;
+    }
+    if (cfg->base->route_prio) {
+        esp_netif->route_prio = cfg->base->route_prio;
+    }
+
+    // Install network stack functions -- connects netif and L3 stack
+    const esp_netif_netstack_config_t *esp_netif_stack_config = cfg->stack;
+    if (cfg->stack->base.type != ESP_NETIF_NETWORK_STACK_IS_LWIP) {
+        ESP_LOGE(TAG, "Failed to configure uknown network stack %d", cfg->stack->base.type);
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    if (esp_netif_stack_config->init_fn) {
+        esp_netif->lwip_init_fn = esp_netif_stack_config->init_fn;
+    }
+    if (esp_netif_stack_config->input_fn) {
+        esp_netif->lwip_input_fn = esp_netif_stack_config->input_fn;
+    }
+
+    // Install IO functions only if provided -- connects driver and netif
+    // this configuration could be updated after esp_netif_new(), typically in post_attach callback
+    if (cfg->driver) {
+        const esp_netif_driver_ifconfig_t *esp_netif_driver_config = cfg->driver;
+        if (esp_netif_driver_config->handle) {
+            esp_netif->driver_handle = esp_netif_driver_config->handle;
+        }
+        if (esp_netif_driver_config->transmit) {
+            esp_netif->driver_transmit = esp_netif_driver_config->transmit;
+        }
+        if (esp_netif_driver_config->driver_free_rx_buffer) {
+            esp_netif->driver_free_rx_buffer = esp_netif_driver_config->driver_free_rx_buffer;
+        }
+    }
+    return ESP_OK;
+}
+
 esp_netif_t *esp_netif_new(const esp_netif_config_t *esp_netif_config)
 {
+    // mandatory configuration must be provided when creating esp_netif object
+    if (esp_netif_config == NULL) {
+        return NULL;
+    }
+
     // Create parent esp-netif object
     esp_netif_t *esp_netif = calloc(1, sizeof(struct esp_netif_obj));
     if (!esp_netif) {
@@ -258,8 +370,11 @@ esp_netif_t *esp_netif_new(const esp_netif_config_t *esp_netif_config)
     esp_netif_add_to_list(esp_netif);
 
     // Configure the created object with provided configuration
-    if (esp_netif_config) {
-        ESP_ERROR_CHECK(esp_netif_configure(esp_netif, esp_netif_config));
+    esp_err_t ret =  esp_netif_init_configuration(esp_netif, esp_netif_config);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Initial configuration of esp_netif failed with %d", ret);
+        esp_netif_destroy(esp_netif);
+        return NULL;
     }
 
     return esp_netif;
@@ -292,67 +407,15 @@ esp_err_t esp_netif_attach(esp_netif_t *esp_netif, esp_netif_iodriver_handle dri
     return ESP_OK;
 }
 
-esp_err_t esp_netif_configure(esp_netif_t *esp_netif, const esp_netif_config_t *cfg)
-
+esp_err_t esp_netif_set_driver_config(esp_netif_t *esp_netif,
+                                      const esp_netif_driver_ifconfig_t *driver_config)
 {
-    if (cfg == NULL) {
+    if (esp_netif == NULL || driver_config == NULL) {
         return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
     }
-// Configure general esp-netif properties
-    if (cfg->base) {
-        memcpy(esp_netif->mac, cfg->base->mac, NETIF_MAX_HWADDR_LEN);
-        if (cfg->base->ip_info == NULL) {
-            ip4_addr_set_zero(&esp_netif->ip_info->ip);
-            ip4_addr_set_zero(&esp_netif->ip_info->gw);
-            ip4_addr_set_zero(&esp_netif->ip_info->netmask);
-        } else {
-            memcpy(esp_netif->ip_info, cfg->base->ip_info, sizeof(esp_netif_ip_info_t));
-        }
-        memcpy(esp_netif->ip_info_old, esp_netif->ip_info, sizeof(esp_netif_ip_info_t));
-
-        // Setup main config parameters
-        esp_netif->lost_ip_event = cfg->base->lost_ip_event;
-        esp_netif->get_ip_event = cfg->base->get_ip_event;
-        esp_netif->flags = cfg->base->flags;
-
-        if (cfg->base->if_key) {
-            esp_netif->if_key = strdup(cfg->base->if_key);
-        }
-        if (cfg->base->if_type) {
-            esp_netif->if_type = cfg->base->if_type;
-        }
-        if (cfg->base->route_prio) {
-            esp_netif->route_prio = cfg->base->route_prio;
-        }
-    }
-
-// Install network stack functions -- connects netif and L3 stack
-    if (cfg->stack) {
-        const esp_netif_netstack_config_t *esp_netif_stack_config = cfg->stack;
-        if (cfg->stack->base.type != ESP_NETIF_NETWORK_STACK_IS_LWIP) {
-            ESP_LOGE(TAG, "Failed to configure uknown network stack %d", cfg->stack->base.type);
-            return ESP_ERR_NOT_SUPPORTED;
-        }
-        if (esp_netif_stack_config->init_fn) {
-            esp_netif->lwip_init_fn = esp_netif_stack_config->init_fn;
-        }
-        if (esp_netif_stack_config->input_fn) {
-            esp_netif->lwip_input_fn = esp_netif_stack_config->input_fn;
-        }
-    }
-// Install IO functions -- connects driver and netif
-    if (cfg->driver) {
-        const esp_netif_driver_ifconfig_t *esp_netif_driver_config = cfg->driver;
-        if (esp_netif_driver_config->handle) {
-            esp_netif->driver_handle = esp_netif_driver_config->handle;
-        }
-        if (esp_netif_driver_config->transmit) {
-            esp_netif->driver_transmit = esp_netif_driver_config->transmit;
-        }
-        if (esp_netif_driver_config->driver_free_rx_buffer) {
-            esp_netif->driver_free_rx_buffer = esp_netif_driver_config->driver_free_rx_buffer;
-        }
-    }
+    esp_netif->driver_handle = driver_config->handle;
+    esp_netif->driver_transmit = driver_config->transmit;
+    esp_netif->driver_free_rx_buffer = driver_config->driver_free_rx_buffer;
     return ESP_OK;
 }
 
@@ -374,10 +437,6 @@ esp_err_t esp_netif_set_mac(esp_netif_t *esp_netif, uint8_t mac[])
     return ESP_OK;
 }
 
-esp_err_t esp_netif_start_api(esp_netif_api_msg_t *msg)
-{
-    return esp_netif_start(msg->esp_netif);
-}
 
 static void esp_netif_dhcps_cb(u8_t client_ip[4])
 {
@@ -393,13 +452,37 @@ static void esp_netif_dhcps_cb(u8_t client_ip[4])
     }
 }
 
+static esp_err_t esp_netif_config_sanity_check(const esp_netif_t * esp_netif)
+{
+    if (esp_netif == NULL) {
+        ESP_LOGE(TAG,  "Cannot start esp_netif: esp_netif must not be null");
+        return ESP_ERR_INVALID_STATE;
+    }
 
-esp_err_t esp_netif_start(esp_netif_t *esp_netif)
+    if (esp_netif->driver_transmit == NULL ||
+        esp_netif->driver_handle == NULL ||
+        esp_netif->lwip_input_fn == NULL ||
+        esp_netif->lwip_init_fn == NULL ||
+        esp_netif->lwip_netif == NULL) {
+        ESP_LOGE(TAG,  "Cannot start esp_netif: Missing mandatory configuration:\n"
+                       "esp_netif->driver_transmit: %p, esp_netif->driver_handle:%p, "
+                       "esp_netif->lwip_input_fn: %p, esp_netif->lwip_init_fn:%p, esp_netif->lwip_netif: %p",
+                       esp_netif->driver_transmit,  esp_netif->driver_handle,
+                       esp_netif->lwip_input_fn,  esp_netif->lwip_init_fn, esp_netif->lwip_netif);
+
+         return ESP_ERR_INVALID_STATE;
+    }
+    return ESP_OK;
+}
+
+static esp_err_t esp_netif_start_api(esp_netif_api_msg_t *msg)
 {
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, esp_netif_start_api);
+    esp_netif_t * esp_netif = msg->esp_netif;
 
     ESP_LOGD(TAG, "%s %p", __func__, esp_netif);
 
+    ESP_ERROR_CHECK(esp_netif_config_sanity_check(esp_netif));
+
     netif_add(esp_netif->lwip_netif, (struct ip4_addr*)&esp_netif->ip_info->ip, (struct ip4_addr*)&esp_netif->ip_info->netmask, (struct ip4_addr*)&esp_netif->ip_info->gw, esp_netif, esp_netif->lwip_init_fn, tcpip_input);
 
     if (esp_netif->flags&ESP_NETIF_FLAG_GARP) {
@@ -441,14 +524,11 @@ esp_err_t esp_netif_start(esp_netif_t *esp_netif)
     return ESP_OK;
 }
 
-esp_err_t esp_netif_stop_api(esp_netif_api_msg_t *msg)
-{
-    return esp_netif_stop(msg->esp_netif);
-}
+esp_err_t esp_netif_start(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_start_api, esp_netif, NULL)
 
-esp_err_t esp_netif_stop(esp_netif_t *esp_netif)
+static esp_err_t esp_netif_stop_api(esp_netif_api_msg_t *msg)
 {
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, esp_netif_stop_api);
+    esp_netif_t *esp_netif = msg->esp_netif;
 
     struct netif *lwip_netif = esp_netif->lwip_netif;
     if (lwip_netif == NULL) {
@@ -482,6 +562,11 @@ esp_err_t esp_netif_stop(esp_netif_t *esp_netif)
     return ESP_OK;
 }
 
+esp_err_t esp_netif_stop(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_stop_api, esp_netif, NULL)
+
+//
+// IO translate functions
+//
 void esp_netif_free_rx_buffer(void *h, void* buffer)
 {
     esp_netif_t *esp_netif = h;
@@ -499,41 +584,6 @@ esp_err_t esp_netif_receive(esp_netif_t *esp_netif, void *buffer, size_t len, vo
     return ESP_OK;
 }
 
-
-static void esp_netif_api_cb(void *api_msg)
-{
-    esp_netif_api_msg_t *msg = (esp_netif_api_msg_t *)api_msg;
-
-    if (!msg || !msg->api_fn) {
-        ESP_LOGD(TAG, "null msg/api_fn");
-        return;
-    }
-
-    msg->ret = msg->api_fn(msg);
-    ESP_LOGD(TAG, "call api in lwip: ret=0x%x, give sem", msg->ret);
-    sys_sem_signal(&api_sync_sem);
-
-}
-
-static int esp_netif_ipc_check(esp_netif_api_msg_t *msg)
-{
-#if ESP_NETIF_TRHEAD_SAFE
-    xTaskHandle local_task = xTaskGetCurrentTaskHandle();
-
-    if (local_task == g_lwip_task) {
-        return ESP_NETIF_IPC_LOCAL;
-    }
-
-    sys_arch_sem_wait(&api_lock_sem, 0);
-    tcpip_send_msg_wait_sem((tcpip_callback_fn)esp_netif_api_cb, msg, &api_sync_sem);
-    sys_sem_signal(&api_lock_sem);
-
-    return ESP_NETIF_IPC_REMOTE;
-#else
-    return ESP_NETIF_IPC_LOCAL;
-#endif
-}
-
 //
 // DHCP:
 //
@@ -603,8 +653,6 @@ static void esp_netif_ip_lost_timer(void *arg)
 
     struct netif *netif = esp_netif->lwip_netif;
 
-    // @TODO: check if netif type is sta
-
     if ( (!netif) || (netif && ip4_addr_cmp(ip_2_ip4(&netif->ip_addr), IP4_ADDR_ANY4))) {
         ip_event_got_ip_t evt = {
                 .esp_netif = esp_netif,
@@ -654,15 +702,10 @@ static esp_err_t esp_netif_start_ip_lost_timer(esp_netif_t *esp_netif)
 
 static esp_err_t esp_netif_dhcpc_stop_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_dhcpc_stop(msg->esp_netif);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
 
-esp_err_t esp_netif_dhcpc_stop(esp_netif_t *esp_netif)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, esp_netif_dhcpc_stop_api);
-
     if (esp_netif == NULL) {
         ESP_LOGE(TAG, "dhcp client stop called with NULL api");
         return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
@@ -690,25 +733,20 @@ esp_err_t esp_netif_dhcpc_stop(esp_netif_t *esp_netif)
     LWIP_DHCP_IP_ADDR_ERASE(esp_netif);
 
     return ESP_OK;
-
 }
 
+esp_err_t esp_netif_dhcpc_stop(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_dhcpc_stop_api, esp_netif, NULL)
 
 static esp_err_t esp_netif_dhcpc_start_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_dhcpc_start(msg->esp_netif);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
 
-esp_err_t esp_netif_dhcpc_start(esp_netif_t *esp_netif)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
     if (!esp_netif) {
         return ESP_ERR_INVALID_ARG;
     }
 
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, esp_netif_dhcpc_start_api);
-
     struct netif *p_netif = esp_netif->lwip_netif;
 
     esp_netif_reset_ip_info(esp_netif);
@@ -746,6 +784,8 @@ esp_err_t esp_netif_dhcpc_start(esp_netif_t *esp_netif)
     }
 }
 
+esp_err_t esp_netif_dhcpc_start(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_dhcpc_start_api, esp_netif, NULL)
+
 esp_err_t esp_netif_dhcps_get_status(esp_netif_t *esp_netif, esp_netif_dhcp_status_t *status)
 {
     if (!esp_netif || (esp_netif->flags&ESP_NETIF_DHCPC)) {
@@ -768,19 +808,14 @@ esp_err_t esp_netif_dhcpc_get_status(esp_netif_t *esp_netif, esp_netif_dhcp_stat
 
 static esp_err_t esp_netif_dhcps_start_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_dhcps_start(msg->esp_netif);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
 
-esp_err_t esp_netif_dhcps_start(esp_netif_t *esp_netif)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
-    if (!esp_netif || (!(esp_netif->flags&ESP_NETIF_DHCPS))) {
+    if (!esp_netif) {
         return ESP_ERR_INVALID_ARG;
     }
 
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, esp_netif_dhcps_start_api);
-
     struct netif *p_netif = esp_netif->lwip_netif;
     if (p_netif != NULL && netif_is_up(p_netif)) {
         esp_netif_ip_info_t *default_ip = esp_netif->ip_info;
@@ -798,19 +833,17 @@ esp_err_t esp_netif_dhcps_start(esp_netif_t *esp_netif)
     }
 }
 
+esp_err_t esp_netif_dhcps_start(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_dhcps_start_api, esp_netif, NULL)
+
 static esp_err_t esp_netif_dhcps_stop_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_dhcps_stop(msg->esp_netif);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
 
-esp_err_t esp_netif_dhcps_stop(esp_netif_t *esp_netif)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
     if (!esp_netif) {
         return ESP_ERR_INVALID_ARG;
     }
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, esp_netif_dhcps_stop_api);
 
     struct netif *p_netif = esp_netif->lwip_netif;
     if (esp_netif->dhcps_status == ESP_NETIF_DHCP_STARTED) {
@@ -830,13 +863,13 @@ esp_err_t esp_netif_dhcps_stop(esp_netif_t *esp_netif)
     return ESP_OK;
 }
 
+esp_err_t esp_netif_dhcps_stop(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_dhcps_stop_api, esp_netif, NULL)
+
 static esp_err_t esp_netif_set_hostname_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_set_hostname(msg->esp_netif, msg->data);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
+    const char *hostname = msg->data;
 
-esp_err_t esp_netif_set_hostname(esp_netif_t *esp_netif, const char *hostname)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p hostname %s", __func__, esp_netif, hostname);
 
     if (!esp_netif) {
@@ -844,7 +877,6 @@ esp_err_t esp_netif_set_hostname(esp_netif_t *esp_netif, const char *hostname)
     }
 
 #if LWIP_NETIF_HOSTNAME
-    ESP_NETIF_IPC_CALL(esp_netif, hostname, esp_netif_set_hostname_api);
 
     struct netif *p_netif = esp_netif->lwip_netif;
     if (esp_netif->hostname) {
@@ -870,6 +902,8 @@ esp_err_t esp_netif_set_hostname(esp_netif_t *esp_netif, const char *hostname)
 #endif
 }
 
+esp_err_t esp_netif_set_hostname(esp_netif_t *esp_netif, const char *hostname) _LWIP_TASK_IPC_CALL(esp_netif_set_hostname_api, esp_netif, hostname)
+
 esp_err_t esp_netif_get_hostname(esp_netif_t *esp_netif, const char **hostname)
 {
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
@@ -894,17 +928,13 @@ esp_err_t esp_netif_get_hostname(esp_netif_t *esp_netif, const char **hostname)
 
 esp_err_t esp_netif_up_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_up(msg->esp_netif);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
 
-esp_err_t esp_netif_up(esp_netif_t *esp_netif)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
     if (!esp_netif) {
         return ESP_ERR_INVALID_STATE;
     }
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, esp_netif_up_api);
 
     struct netif *lwip_netif = esp_netif->lwip_netif;
 
@@ -917,24 +947,17 @@ esp_err_t esp_netif_up(esp_netif_t *esp_netif)
     return ESP_OK;
 }
 
+esp_err_t esp_netif_up(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_up_api, esp_netif, NULL)
+
 static esp_err_t esp_netif_down_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_down(msg->esp_netif);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
 
-esp_err_t esp_netif_down(esp_netif_t *esp_netif)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
     if (!esp_netif) {
         return ESP_ERR_INVALID_STATE;
     }
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, &esp_netif_down_api);
-
-    if (esp_netif->flags&ESP_NETIF_FLAG_AUTOUP) {
-        ESP_LOGE(TAG, "Interface  if%p asked to go up, but configured to AUTO-UP flag (flags=%x)", esp_netif, esp_netif->flags);
-        return ESP_ERR_INVALID_STATE;
-    }
 
     struct netif *lwip_netif = esp_netif->lwip_netif;
 
@@ -958,6 +981,8 @@ esp_err_t esp_netif_down(esp_netif_t *esp_netif)
     return ESP_OK;
 }
 
+esp_err_t esp_netif_down(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_down_api, esp_netif, NULL)
+
 bool esp_netif_is_netif_up(esp_netif_t *esp_netif)
 {
     ESP_LOGV(TAG, "%s esp_netif:%p", __func__, esp_netif);
@@ -1015,34 +1040,31 @@ bool esp_netif_is_valid_static_ip(esp_netif_ip_info_t *ip_info)
 
 static esp_err_t esp_netif_set_ip_old_info_api(esp_netif_api_msg_t *msg)
 {
-    memcpy(msg->esp_netif->ip_info, msg->data, sizeof(esp_netif_ip_info_t));
-    return ESP_OK;
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
+    const esp_netif_ip_info_t *ip_info = msg->data;
 
-esp_err_t esp_netif_set_old_ip_info(esp_netif_t *esp_netif, const esp_netif_ip_info_t *ip_info)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
     if (esp_netif == NULL || ip_info == NULL) {
         return ESP_ERR_INVALID_STATE;
     }
-    ESP_NETIF_IPC_CALL(esp_netif, ip_info, esp_netif_set_ip_old_info_api);
+
+    memcpy(msg->esp_netif->ip_info_old, msg->data, sizeof(esp_netif_ip_info_t));
     return ESP_OK;
 }
 
+esp_err_t esp_netif_set_old_ip_info(esp_netif_t *esp_netif, const esp_netif_ip_info_t *ip_info) _LWIP_TASK_IPC_CALL(esp_netif_set_ip_old_info_api, esp_netif, ip_info)
+
 static esp_err_t esp_netif_set_ip_info_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_set_ip_info(msg->esp_netif, msg->data);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
+    const esp_netif_ip_info_t *ip_info = msg->data;
 
-esp_err_t esp_netif_set_ip_info(esp_netif_t *esp_netif, const esp_netif_ip_info_t *ip_info)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
     if (esp_netif == NULL || ip_info == NULL) {
         return ESP_ERR_INVALID_STATE;
     }
-    ESP_NETIF_IPC_CALL(esp_netif, ip_info, esp_netif_set_ip_info_api);
 
     if (esp_netif->flags&ESP_NETIF_DHCPS) {
         if (esp_netif->dhcps_status != ESP_NETIF_DHCP_STOPPED) {
@@ -1092,24 +1114,17 @@ esp_err_t esp_netif_set_ip_info(esp_netif_t *esp_netif, const esp_netif_ip_info_
     return ESP_OK;
 }
 
+esp_err_t esp_netif_set_ip_info(esp_netif_t *esp_netif, const esp_netif_ip_info_t *ip_info) _LWIP_TASK_IPC_CALL(esp_netif_set_ip_info_api, esp_netif, ip_info)
+
 static esp_err_t esp_netif_set_dns_info_api(esp_netif_api_msg_t *msg)
 {
-    esp_netif_dns_param_t *dns_param = (esp_netif_dns_param_t *)msg->data;
+    esp_netif_t *esp_netif = msg->esp_netif;
+    esp_netif_dns_param_t *dns_param = msg->data;
+    esp_netif_dns_type_t type = dns_param->dns_type;
+    esp_netif_dns_info_t *dns = dns_param->dns_info;
 
-    return esp_netif_set_dns_info(msg->esp_netif, dns_param->dns_type, dns_param->dns_info);
-}
-
-esp_err_t esp_netif_set_dns_info(esp_netif_t *esp_netif, esp_netif_dns_type_t type, esp_netif_dns_info_t *dns)
-{
     ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
-    esp_netif_dns_param_t dns_param;
-
-    dns_param.dns_type =  type;
-    dns_param.dns_info =  dns;
-
-    ESP_NETIF_IPC_CALL(esp_netif, &dns_param, esp_netif_set_dns_info_api);
-
     if (esp_netif == NULL) {
         return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
     }
@@ -1144,25 +1159,26 @@ esp_err_t esp_netif_set_dns_info(esp_netif_t *esp_netif, esp_netif_dns_type_t ty
     return ESP_OK;
 }
 
-static esp_err_t esp_netif_get_dns_info_api(esp_netif_api_msg_t *msg)
+esp_err_t esp_netif_set_dns_info(esp_netif_t *esp_netif, esp_netif_dns_type_t type, esp_netif_dns_info_t *dns)
 {
-    esp_netif_dns_param_t *dns_param = (esp_netif_dns_param_t *)msg->data;
-
-    return esp_netif_get_dns_info(msg->esp_netif, dns_param->dns_type, dns_param->dns_info);
+    esp_netif_dns_param_t dns_param = {
+        .dns_type = type,
+        .dns_info = dns
+    };
+    return esp_netif_lwip_ipc_call(esp_netif_set_dns_info_api, esp_netif, (void *)&dns_param);
 }
 
-esp_err_t esp_netif_get_dns_info(esp_netif_t *esp_netif, esp_netif_dns_type_t type, esp_netif_dns_info_t *dns)
+static esp_err_t esp_netif_get_dns_info_api(esp_netif_api_msg_t *msg)
 {
-    ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
-
-    esp_netif_dns_param_t dns_param;
+    esp_netif_t *esp_netif = msg->esp_netif;
+    esp_netif_dns_param_t *dns_param = msg->data;
+    esp_netif_dns_type_t type = dns_param->dns_type;
+    esp_netif_dns_info_t *dns = dns_param->dns_info;
 
-    dns_param.dns_type =  type;
-    dns_param.dns_info =  dns;
+    ESP_LOGD(TAG, "%s esp_netif:%p", __func__, esp_netif);
 
-    ESP_NETIF_IPC_CALL(esp_netif, &dns_param, esp_netif_get_dns_info_api);
     if (!dns) {
-        ESP_LOGD(TAG, "get dns null dns");
+        ESP_LOGE(TAG, "%s: dns_info cannot be NULL", __func__);
         return ESP_ERR_ESP_NETIF_INVALID_PARAMS;
     }
 
@@ -1180,6 +1196,15 @@ esp_err_t esp_netif_get_dns_info(esp_netif_t *esp_netif, esp_netif_dns_type_t ty
     return ESP_OK;
 }
 
+esp_err_t esp_netif_get_dns_info(esp_netif_t *esp_netif, esp_netif_dns_type_t type, esp_netif_dns_info_t *dns)
+{
+    esp_netif_dns_param_t dns_param = {
+        .dns_type = type,
+        .dns_info = dns
+    };
+    return esp_netif_lwip_ipc_call(esp_netif_get_dns_info_api, esp_netif, (void *)&dns_param);
+}
+
 esp_err_t esp_netif_get_sta_list(const wifi_sta_list_t *wifi_sta_list, esp_netif_sta_list_t *netif_sta_list)
 {
     ESP_LOGD(TAG, "%s entered", __func__);
@@ -1203,7 +1228,7 @@ static void esp_netif_nd6_cb(struct netif *p_netif, uint8_t ip_idex)
 {
     ESP_LOGD(TAG, "%s lwip-netif:%p", __func__, p_netif);
     if (!p_netif) {
-        ESP_LOGD(TAG, "null p_netif=%p", p_netif);
+        ESP_LOGD(TAG, "esp_netif_nd6_cb called with null p_netif");
         return;
     }
 
@@ -1225,20 +1250,14 @@ static void esp_netif_nd6_cb(struct netif *p_netif, uint8_t ip_idex)
     if (ESP_OK != ret) {
         ESP_LOGE(TAG, "nd6 cb: failed to post IP_EVENT_GOT_IP6 (%x)", ret);
     }
-
 }
 
-
 static esp_err_t esp_netif_create_ip6_linklocal_api(esp_netif_api_msg_t *msg)
 {
-    return esp_netif_create_ip6_linklocal(msg->esp_netif);
-}
+    esp_netif_t *esp_netif = msg->esp_netif;
 
-esp_err_t esp_netif_create_ip6_linklocal(esp_netif_t *esp_netif)
-{
     ESP_LOGD(TAG, "%s esp-netif:%p", __func__, esp_netif);
 
-    ESP_NETIF_IPC_CALL(esp_netif, NULL, esp_netif_create_ip6_linklocal_api);
     struct netif *p_netif = esp_netif->lwip_netif;
     if (p_netif != NULL && netif_is_up(p_netif)) {
         netif_create_ip6_linklocal_address(p_netif, 1);
@@ -1249,6 +1268,8 @@ esp_err_t esp_netif_create_ip6_linklocal(esp_netif_t *esp_netif)
     }
 }
 
+esp_err_t esp_netif_create_ip6_linklocal(esp_netif_t *esp_netif) _LWIP_TASK_IPC_CALL(esp_netif_create_ip6_linklocal_api, esp_netif, NULL)
+
 esp_err_t esp_netif_get_ip6_linklocal(esp_netif_t *esp_netif, esp_ip6_addr_t *if_ip6)
 {
     ESP_LOGD(TAG, "%s esp-netif:%p", __func__, esp_netif);
@@ -1433,7 +1454,7 @@ esp_err_t esp_netif_dhcpc_option(esp_netif_t *esp_netif, esp_netif_dhcp_option_m
     return ESP_ERR_NOT_SUPPORTED;
 }
 
-int esp_netif_get_netif_index(esp_netif_t *esp_netif)
+int esp_netif_get_netif_impl_index(esp_netif_t *esp_netif)
 {
     if (esp_netif == NULL || esp_netif->lwip_netif == NULL) {
         return -1;
@@ -1441,4 +1462,4 @@ int esp_netif_get_netif_index(esp_netif_t *esp_netif)
     return netif_get_index(esp_netif->lwip_netif);
 }
 
-#endif /* CONFIG_TCPIP_LWIP */
+#endif /* CONFIG_ESP_NETIF_TCPIP_LWIP */

components/esp_netif/lwip/esp_netif_lwip_internal.h

@@ -46,25 +46,3 @@ typedef struct esp_netif_ip_lost_timer_s {
     bool timer_running;
 } esp_netif_ip_lost_timer_t;
 
-
-#define ESP_NETIF_TRHEAD_SAFE 1
-#define ESP_NETIF_IPC_LOCAL   0
-#define ESP_NETIF_IPC_REMOTE  1
-
-#define ESP_NETIF_IPC_CALL(_if, _data, _fn) do {\
-    esp_netif_api_msg_t msg;\
-    if (tcpip_initialized == false) {\
-        ESP_LOGE(TAG, "esp_netif is not initialized!");\
-        abort();\
-    }\
-    memset(&msg, 0, sizeof(msg));\
-    msg.esp_netif = (_if);\
-    msg.data     = (void*)(_data);\
-    msg.api_fn   = (_fn);\
-    if (ESP_NETIF_IPC_REMOTE == esp_netif_ipc_check(&msg)) {\
-        ESP_LOGD(TAG, "check: remote, if=%p fn=%p\n", (_if), (_fn));\
-        return msg.ret;\
-    } else {\
-        ESP_LOGD(TAG, "check: local, if=%p fn=%p\n", (_if), (_fn));\
-    }\
-} while(0)

components/esp_netif/test/test_esp_netif.c

@@ -4,11 +4,14 @@
 
 TEST_CASE("esp_netif: init and destroy", "[esp_netif][leaks=0]")
 {
-    esp_netif_config_t cfg = {};
+    esp_netif_inherent_config_t base = {};
+    const esp_netif_netstack_base_config_t stack = { .type = ESP_NETIF_NETWORK_STACK_IS_LWIP };
+    esp_netif_config_t cfg = { .base = &base, .stack = (const esp_netif_netstack_config_t*)&stack };
     esp_netif_t *esp_netif = esp_netif_new(NULL);
 
-    TEST_ASSERT_EQUAL(ESP_ERR_ESP_NETIF_INVALID_PARAMS, esp_netif_configure(esp_netif, NULL));
-    TEST_ASSERT_EQUAL(ESP_OK, esp_netif_configure(esp_netif, &cfg));
+    TEST_ASSERT_EQUAL(NULL, esp_netif);
+    esp_netif = esp_netif_new(&cfg);
+    TEST_ASSERT_NOT_EQUAL(NULL, esp_netif);
 
     esp_netif_destroy(esp_netif);
 }
@@ -41,8 +44,8 @@ TEST_CASE("esp_netif: create and delete multiple netifs", "[esp_netif][leaks=0]"
 
     // create 10 wifi stations
     for (int i=0; i<nr_of_netifs; ++i) {
-        netifs[i] = esp_netif_new(NULL);
-        TEST_ASSERT_EQUAL(ESP_OK, esp_netif_configure(netifs[i] , &cfg));
+        netifs[i] = esp_netif_new(&cfg);
+        TEST_ASSERT_NOT_NULL(netifs[i]);
     }
 
     // there's no AP within created stations

components/esp_wifi/src/wifi_init.c

@@ -110,7 +110,9 @@ esp_err_t esp_wifi_deinit(void)
         ESP_LOGE(TAG, "Failed to deinit Wi-Fi driver (0x%x)", err);
     }
 
+#if CONFIG_ESP_NETIF_TCPIP_ADAPTER_COMPATIBLE_LAYER
     tcpip_adapter_clear_default_wifi_handlers();
+#endif
 
     return err;
 }
@@ -126,7 +128,7 @@ esp_err_t esp_wifi_init(const wifi_init_config_t *config)
         }
     }
 #endif
-#if CONFIG_ESP_NETIF_USE_TCPIP_ADAPTER_COMPATIBLE_LAYER
+#if CONFIG_ESP_NETIF_TCPIP_ADAPTER_COMPATIBLE_LAYER
     esp_err_t err = tcpip_adapter_set_default_wifi_handlers();
     if (err != ESP_OK) {
         ESP_LOGW(TAG, "Failed to set default Wi-Fi event handlers (0x%x)", err);

components/tcpip_adapter/include/tcpip_adapter.h

@@ -15,51 +15,10 @@
 #ifndef _TCPIP_ADAPTER_H_
 #define _TCPIP_ADAPTER_H_
 
-#include "esp_netif.h"
-#include "lwip/ip_addr.h"
-#include "dhcpserver/dhcpserver.h"
-
-
-//
-// Define compatible types if tcpip_adapter interface used
-//
-#define TCPIP_ADAPTER_DHCP_STARTED ESP_NETIF_DHCP_STARTED
-#define TCPIP_ADAPTER_DHCP_STOPPED ESP_NETIF_DHCP_STOPPED
-#define TCPIP_ADAPTER_DHCP_INIT    ESP_NETIF_DHCP_INIT
-#define TCPIP_ADAPTER_OP_SET       ESP_NETIF_OP_SET
-#define TCPIP_ADAPTER_OP_GET       ESP_NETIF_OP_GET
-#define TCPIP_ADAPTER_DOMAIN_NAME_SERVER             ESP_NETIF_DOMAIN_NAME_SERVER
-#define TCPIP_ADAPTER_ROUTER_SOLICITATION_ADDRESS    ESP_NETIF_ROUTER_SOLICITATION_ADDRESS
-#define TCPIP_ADAPTER_REQUESTED_IP_ADDRESS           ESP_NETIF_REQUESTED_IP_ADDRESS
-#define TCPIP_ADAPTER_IP_ADDRESS_LEASE_TIME          ESP_NETIF_IP_ADDRESS_LEASE_TIME
-#define TCPIP_ADAPTER_IP_REQUEST_RETRY_TIME          ESP_NETIF_IP_REQUEST_RETRY_TIME
-
-typedef enum {
-    TCPIP_ADAPTER_IF_STA = 0,     /**< Wi-Fi STA (station) interface */
-    TCPIP_ADAPTER_IF_AP,          /**< Wi-Fi soft-AP interface */
-    TCPIP_ADAPTER_IF_ETH,         /**< Ethernet interface */
-    TCPIP_ADAPTER_IF_TEST,        /**< tcpip stack test interface */
-    TCPIP_ADAPTER_IF_MAX
-} tcpip_adapter_if_t;
-
-/** @brief legacy ip_info type
- */
-typedef struct {
-    ip4_addr_t ip;      /**< Interface IPV4 address */
-    ip4_addr_t netmask; /**< Interface IPV4 netmask */
-    ip4_addr_t gw;      /**< Interface IPV4 gateway address */
-} tcpip_adapter_ip_info_t;
+#warning "This header is deprecated, please use new network related API in esp_netif.h"
 
-/** @brief legacy typedefs
- */
-typedef esp_netif_dhcp_status_t tcpip_adapter_dhcp_status_t;
-typedef dhcps_lease_t tcpip_adapter_dhcps_lease_t;
-typedef esp_netif_dhcp_option_mode_t tcpip_adapter_dhcp_option_mode_t;
-typedef esp_netif_dhcp_option_id_t tcpip_adapter_dhcp_option_id_t;
-typedef esp_netif_dns_type_t tcpip_adapter_dns_type_t;
-typedef esp_netif_dns_info_t tcpip_adapter_dns_info_t;
-typedef esp_netif_sta_list_t tcpip_adapter_sta_list_t;
-typedef esp_netif_sta_info_t tcpip_adapter_sta_info_t;
+#include "esp_netif.h"
+#include "tcpip_adapter_types.h"
 
 /**
  * @brief tcpip adapter legacy init. It is used only to set the compatibility mode of esp-netif, which
@@ -147,18 +106,64 @@ esp_err_t tcpip_adapter_eth_input(void *buffer, uint16_t len, void *eb);
  */
 esp_err_t tcpip_adapter_clear_default_wifi_handlers(void);
 
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_dhcps_stop
+*/
 esp_err_t tcpip_adapter_dhcps_stop(tcpip_adapter_if_t tcpip_if);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_dhcpc_stop
+*/
 esp_err_t tcpip_adapter_dhcpc_stop(tcpip_adapter_if_t tcpip_if);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_dhcps_start
+*/
 esp_err_t tcpip_adapter_dhcps_start(tcpip_adapter_if_t tcpip_if);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_dhcpc_start
+*/
 esp_err_t tcpip_adapter_dhcpc_start(tcpip_adapter_if_t tcpip_if);
 
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_dhcps_get_status
+*/
 esp_err_t tcpip_adapter_dhcps_get_status(tcpip_adapter_if_t tcpip_if, tcpip_adapter_dhcp_status_t *status);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_dhcps_option
+*/
 esp_err_t tcpip_adapter_dhcps_option(tcpip_adapter_dhcp_option_mode_t opt_op, tcpip_adapter_dhcp_option_id_t opt_id, void *opt_val, uint32_t opt_len);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_dhcpc_option
+*/
 esp_err_t tcpip_adapter_dhcpc_option(tcpip_adapter_dhcp_option_mode_t opt_op, tcpip_adapter_dhcp_option_id_t opt_id, void *opt_val, uint32_t opt_len);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_set_ip_info
+*/
 esp_err_t tcpip_adapter_set_ip_info(tcpip_adapter_if_t tcpip_if, const tcpip_adapter_ip_info_t *ip_info);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_get_dns_info
+*/
 esp_err_t tcpip_adapter_get_dns_info(tcpip_adapter_if_t tcpip_if, tcpip_adapter_dns_type_t type, tcpip_adapter_dns_info_t *dns);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_set_dns_info
+*/
 esp_err_t tcpip_adapter_set_dns_info(tcpip_adapter_if_t tcpip_if, tcpip_adapter_dns_type_t type, tcpip_adapter_dns_info_t *dns);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_get_netif_impl_index
+*/
 int tcpip_adapter_get_netif_index(tcpip_adapter_if_t tcpip_if);
+
+/**
+ * @brief Compatible version of former tcpip_adapter API of esp_netif_get_sta_list
+*/
 esp_err_t tcpip_adapter_get_sta_list(const wifi_sta_list_t *wifi_sta_list, tcpip_adapter_sta_list_t *tcpip_sta_list);
 
 #endif //_TCPIP_ADAPTER_H_

components/tcpip_adapter/include/tcpip_adapter_types.h

@@ -0,0 +1,61 @@
+// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef _TCPIP_ADAPTER_TYPES_H_
+#define _TCPIP_ADAPTER_TYPES_H_
+
+#include "lwip/ip_addr.h"
+#include "dhcpserver/dhcpserver.h"
+//
+// Define compatible types if tcpip_adapter interface used
+//
+#define TCPIP_ADAPTER_DHCP_STARTED ESP_NETIF_DHCP_STARTED
+#define TCPIP_ADAPTER_DHCP_STOPPED ESP_NETIF_DHCP_STOPPED
+#define TCPIP_ADAPTER_DHCP_INIT    ESP_NETIF_DHCP_INIT
+#define TCPIP_ADAPTER_OP_SET       ESP_NETIF_OP_SET
+#define TCPIP_ADAPTER_OP_GET       ESP_NETIF_OP_GET
+#define TCPIP_ADAPTER_DOMAIN_NAME_SERVER             ESP_NETIF_DOMAIN_NAME_SERVER
+#define TCPIP_ADAPTER_ROUTER_SOLICITATION_ADDRESS    ESP_NETIF_ROUTER_SOLICITATION_ADDRESS
+#define TCPIP_ADAPTER_REQUESTED_IP_ADDRESS           ESP_NETIF_REQUESTED_IP_ADDRESS
+#define TCPIP_ADAPTER_IP_ADDRESS_LEASE_TIME          ESP_NETIF_IP_ADDRESS_LEASE_TIME
+#define TCPIP_ADAPTER_IP_REQUEST_RETRY_TIME          ESP_NETIF_IP_REQUEST_RETRY_TIME
+
+typedef enum {
+    TCPIP_ADAPTER_IF_STA = 0,     /**< Wi-Fi STA (station) interface */
+    TCPIP_ADAPTER_IF_AP,          /**< Wi-Fi soft-AP interface */
+    TCPIP_ADAPTER_IF_ETH,         /**< Ethernet interface */
+    TCPIP_ADAPTER_IF_TEST,        /**< tcpip stack test interface */
+    TCPIP_ADAPTER_IF_MAX
+} tcpip_adapter_if_t;
+
+/** @brief legacy ip_info type
+ */
+typedef struct {
+    ip4_addr_t ip;      /**< Interface IPV4 address */
+    ip4_addr_t netmask; /**< Interface IPV4 netmask */
+    ip4_addr_t gw;      /**< Interface IPV4 gateway address */
+} tcpip_adapter_ip_info_t;
+
+/** @brief legacy typedefs
+ */
+typedef esp_netif_dhcp_status_t tcpip_adapter_dhcp_status_t;
+typedef dhcps_lease_t tcpip_adapter_dhcps_lease_t;
+typedef esp_netif_dhcp_option_mode_t tcpip_adapter_dhcp_option_mode_t;
+typedef esp_netif_dhcp_option_id_t tcpip_adapter_dhcp_option_id_t;
+typedef esp_netif_dns_type_t tcpip_adapter_dns_type_t;
+typedef esp_netif_dns_info_t tcpip_adapter_dns_info_t;
+typedef esp_netif_sta_list_t tcpip_adapter_sta_list_t;
+typedef esp_netif_sta_info_t tcpip_adapter_sta_info_t;
+
+#endif // _TCPIP_ADAPTER_TYPES_H_

components/tcpip_adapter/tcpip_adapter_compat.c

@@ -13,12 +13,14 @@
 // limitations under the License.
 
 #include "esp_netif.h"
-#include "tcpip_adapter_compatible/tcpip_adapter_compat.h"
 #include "esp_private/wifi.h"
 #include "esp_log.h"
 #include "esp_netif_net_stack.h"
-#include "tcpip_adapter.h"
+
+#if CONFIG_ESP_NETIF_TCPIP_ADAPTER_COMPATIBLE_LAYER
+
 #include "esp_eth.h"
+#include "tcpip_adapter_types.h"
 
 extern void _esp_wifi_set_default_ap_netif(esp_netif_t* esp_netif);
 extern void _esp_wifi_set_default_sta_netif(esp_netif_t* esp_netif);
@@ -129,21 +131,16 @@ esp_err_t tcpip_adapter_eth_input(void *buffer, uint16_t len, void *eb)
 
 esp_err_t tcpip_adapter_start_eth(void* eth_driver)
 {
-#if CONFIG_ESP_NETIF_USE_TCPIP_ADAPTER_COMPATIBLE_LAYER
     if (s_tcpip_adapter_compat) {
         esp_netif_t *esp_netif = netif_from_if(TCPIP_ADAPTER_IF_ETH);
         esp_netif_attach(esp_netif, eth_driver);
     }
     return ESP_OK;
-#else
-    ESP_LOGE(TAG, "%s: tcpip adapter compatibility layer is disabled", __func__);
-    return ESP_ERR_INVALID_STATE;
-#endif
 }
 
 esp_err_t tcpip_adapter_set_default_wifi_handlers(void)
 {
-#if CONFIG_ESP_NETIF_USE_TCPIP_ADAPTER_COMPATIBLE_LAYER
+#if CONFIG_ESP_NETIF_TCPIP_ADAPTER_COMPATIBLE_LAYER
     if (s_tcpip_adapter_compat) {
         // create instances and register default handlers only on start event
         esp_err_t err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_START, wifi_create_and_start_sta, NULL);
@@ -265,10 +262,19 @@ esp_err_t tcpip_adapter_set_dns_info(tcpip_adapter_if_t tcpip_if, tcpip_adapter_
 
 int tcpip_adapter_get_netif_index(tcpip_adapter_if_t tcpip_if)
 {
-    return esp_netif_get_netif_index(netif_from_if(tcpip_if));
+    return esp_netif_get_netif_impl_index(netif_from_if(tcpip_if));
 }
 
 esp_err_t tcpip_adapter_get_sta_list(const wifi_sta_list_t *wifi_sta_list, tcpip_adapter_sta_list_t *tcpip_sta_list)
 {
     return esp_netif_get_sta_list(wifi_sta_list, tcpip_sta_list);
 }
+
+#else
+
+esp_err_t tcpip_adapter_start_eth(void* eth_driver)
+{
+    return ESP_OK;
+}
+
+#endif

examples/protocols/sockets/udp_multicast/main/udp_multicast_example_main.c

@@ -212,7 +212,7 @@ static int create_multicast_ipv6_socket(void)
 #endif // LISTEN_ALL_IF
 
     // search for netif index
-    netif_index = esp_netif_get_netif_index(EXAMPLE_INTERFACE);
+    netif_index = esp_netif_get_netif_impl_index(EXAMPLE_INTERFACE);
     if(netif_index < 0) {
         ESP_LOGE(V6TAG, "Failed to get netif index");
         goto err;