Merge pull request #43 from gabsuren/mdns_migration_with_history

mdns: Initial version based on IDF 5.0

.github/workflows/build_and_run_example_test_mdns.yml

@@ -0,0 +1,35 @@
+name: Build mDNS
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32", "esp32s2", "esp32c3"]
+
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@master
+        with:
+          path: esp-protocols
+      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/examples/
+          cat sdkconfig.ci.eth_def >> sdkconfig.defaults
+          idf.py build
+          rm sdkconfig.defaults
+          cat sdkconfig.ci.eth_custom_netif >> sdkconfig.defaults
+          idf.py build
+          rm sdkconfig.defaults
+          cat sdkconfig.ci.eth_socket >> sdkconfig.defaults
+          idf.py build
+          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/test_apps/
+          idf.py build

.github/workflows/publish-docs-component.yml

@@ -21,25 +21,36 @@ jobs:
         run: |
           sudo apt-get update
           sudo apt-get -y install doxygen clang python3-pip
-          python -m pip install breathe recommonmark esp-docs==0.2.1
+          python -m pip install breathe recommonmark esp-docs
           cd $GITHUB_WORKSPACE/components/esp_modem/docs
           ./generate_docs
           mkdir -p $GITHUB_WORKSPACE/docs/esp_modem
           cp -r html/. $GITHUB_WORKSPACE/docs/esp_modem
+
           cd $GITHUB_WORKSPACE/components/esp_websocket_client/docs
           ./generate_docs
           mkdir -p $GITHUB_WORKSPACE/docs/esp_websocket_client
           cp -r html/. $GITHUB_WORKSPACE/docs/esp_websocket_client
+
+          cd $GITHUB_WORKSPACE/components/mdns/docs
+          ./generate_docs
+          mkdir -p $GITHUB_WORKSPACE/docs/mdns/en
+          mkdir -p $GITHUB_WORKSPACE/docs/mdns/zh_CN
+          cp -r html_en/. $GITHUB_WORKSPACE/docs/mdns/en
+          cp -r html_zh_CN/. $GITHUB_WORKSPACE/docs/mdns/zh_CN
+
           cd $GITHUB_WORKSPACE/docs
           touch .nojekyll
-          echo '<a href="esp_modem/index.html">esp-modem</a>' > index.html
-          echo '<a href="esp_websocket_client/index.html">esp-websocket-client</a>' >> index.html
+          echo '<a href="esp_modem/index.html">esp-modem</a><br>' > index.html
+          echo '<a href="esp_websocket_client/index.html">esp-websocket-client</a><br>' >> index.html
+          echo '<a href="mdns/en/index.html">mDNS_en</a><br>' >> index.html
+          echo '<a href="mdns/zh_CN/index.html">mDNS_zh_CN</a><br>' >> index.html
 
 
       - name: Upload components to component service
         uses: espressif/github-actions/upload_components@master
         with:
-          directories: "components/esp_modem;components/esp_websocket_client"
+          directories: "components/esp_modem;components/esp_websocket_client;components/mdns"
           namespace: "espressif"
           api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}
 

.github/workflows/test_afl_fuzzer.yml

@@ -0,0 +1,30 @@
+name: AFL fuzzer compilation test
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32"]
+
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@master
+        with:
+          path: esp-protocols
+      - name: Install Necessary Libs
+        run: |
+          apt-get update -y
+          apt-get install -y libbsd-dev
+      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/test_afl_fuzz_host/
+          make INSTR=off

README.md

@@ -9,6 +9,11 @@
 * Brief introduction [README](components/esp_modem/README.md)
 * Full html [documentation](https://espressif.github.io/esp-protocols/esp_modem/index.html)
 
+### mDNS
+
+* Brief introduction [README](components/mdns/README.md)
+* Full html [documentation](https://espressif.github.io/esp-protocols/mdns/index.html)
+
 ### esp_websocket_client
 
 * Brief introduction [README](components/esp_websocket_client/README.md)

common_components/protocol_examples_common/CMakeLists.txt

@@ -0,0 +1,4 @@
+idf_component_register(SRCS "connect.c" "stdin_out.c" "addr_from_stdin.c"
+                    INCLUDE_DIRS "include"
+                    PRIV_REQUIRES esp_netif driver
+                    )

common_components/protocol_examples_common/Kconfig.projbuild

@@ -0,0 +1,322 @@
+menu "Example Connection Configuration"
+
+    orsource "$IDF_PATH/examples/common_components/env_caps/$IDF_TARGET/Kconfig.env_caps"
+
+    config EXAMPLE_CONNECT_WIFI
+        bool "connect using WiFi interface"
+        default y
+        help
+            Protocol examples can use Wi-Fi and/or Ethernet to connect to the network.
+            Choose this option to connect with WiFi
+
+    if EXAMPLE_CONNECT_WIFI
+        config EXAMPLE_WIFI_SSID
+            string "WiFi SSID"
+            default "myssid"
+            help
+                SSID (network name) for the example to connect to.
+
+        config EXAMPLE_WIFI_PASSWORD
+            string "WiFi Password"
+            default "mypassword"
+            help
+                WiFi password (WPA or WPA2) for the example to use.
+                Can be left blank if the network has no security set.
+
+        choice EXAMPLE_WIFI_SCAN_METHOD
+            prompt "WiFi Scan Method"
+            default EXAMPLE_WIFI_SCAN_METHOD_ALL_CHANNEL
+            help
+                WiFi scan method:
+
+                If "Fast" is selected, scan will end after find SSID match AP.
+
+                If "All Channel" is selected, scan will end after scan all the channel.
+
+            config EXAMPLE_WIFI_SCAN_METHOD_FAST
+                bool "Fast"
+            config EXAMPLE_WIFI_SCAN_METHOD_ALL_CHANNEL
+                bool "All Channel"
+        endchoice
+
+        menu "WiFi Scan threshold"
+            config EXAMPLE_WIFI_SCAN_RSSI_THRESHOLD
+                int "WiFi minimum rssi"
+                range -127 0
+
+                default -127
+                help
+                    The minimum rssi to accept in the scan mode.
+
+            choice EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD
+                prompt "WiFi Scan auth mode threshold"
+                default EXAMPLE_WIFI_AUTH_OPEN
+                help
+                    The weakest authmode to accept in the scan mode.
+
+                config EXAMPLE_WIFI_AUTH_OPEN
+                    bool "OPEN"
+                config EXAMPLE_WIFI_AUTH_WEP
+                    bool "WEP"
+                config EXAMPLE_WIFI_AUTH_WPA_PSK
+                    bool "WPA PSK"
+                config EXAMPLE_WIFI_AUTH_WPA2_PSK
+                    bool "WPA2 PSK"
+                config EXAMPLE_WIFI_AUTH_WPA_WPA2_PSK
+                    bool "WPA WPA2 PSK"
+                config EXAMPLE_WIFI_AUTH_WPA2_ENTERPRISE
+                    bool "WPA2 ENTERPRISE"
+                config EXAMPLE_WIFI_AUTH_WPA3_PSK
+                    bool "WPA3 PSK"
+                config EXAMPLE_WIFI_AUTH_WPA2_WPA3_PSK
+                    bool "WPA2 WPA3 PSK"
+                config EXAMPLE_WIFI_AUTH_WAPI_PSK
+                    bool "WAPI PSK"
+            endchoice
+        endmenu
+
+        choice EXAMPLE_WIFI_CONNECT_AP_SORT_METHOD
+            prompt "WiFi Connect AP Sort Method"
+            default EXAMPLE_WIFI_CONNECT_AP_BY_SIGNAL
+            help
+                WiFi connect AP sort method:
+
+                If "Signal" is selected, Sort matched APs in scan list by RSSI.
+
+                If "Security" is selected, Sort matched APs in scan list by security mode.
+
+            config EXAMPLE_WIFI_CONNECT_AP_BY_SIGNAL
+                bool "Signal"
+            config EXAMPLE_WIFI_CONNECT_AP_BY_SECURITY
+                bool "Security"
+        endchoice
+    endif
+
+    config EXAMPLE_CONNECT_ETHERNET
+        bool "connect using Ethernet interface"
+        default n
+        help
+            Protocol examples can use Wi-Fi and/or Ethernet to connect to the network.
+            Choose this option to connect with Ethernet
+
+    if EXAMPLE_CONNECT_ETHERNET
+        config EXAMPLE_USE_SPI_ETHERNET
+            bool
+
+        choice EXAMPLE_ETHERNET_TYPE
+            prompt "Ethernet Type"
+            default EXAMPLE_USE_INTERNAL_ETHERNET if IDF_TARGET_ESP32
+            default EXAMPLE_USE_W5500
+            help
+                Select which kind of Ethernet will be used in the example.
+
+            config EXAMPLE_USE_INTERNAL_ETHERNET
+                depends on IDF_TARGET_ESP32
+                select ETH_USE_ESP32_EMAC
+                bool "Internal EMAC"
+                help
+                    Select internal Ethernet MAC controller.
+
+            config EXAMPLE_USE_DM9051
+                bool "DM9051 Module"
+                select EXAMPLE_USE_SPI_ETHERNET
+                select ETH_USE_SPI_ETHERNET
+                select ETH_SPI_ETHERNET_DM9051
+                help
+                    Select external SPI-Ethernet module.
+
+            config EXAMPLE_USE_W5500
+                bool "W5500 Module"
+                select EXAMPLE_USE_SPI_ETHERNET
+                select ETH_USE_SPI_ETHERNET
+                select ETH_SPI_ETHERNET_W5500
+                help
+                    Select external SPI-Ethernet module (W5500).
+
+            config EXAMPLE_USE_OPENETH
+                bool "OpenCores Ethernet MAC (EXPERIMENTAL)"
+                select ETH_USE_OPENETH
+                help
+                    When this option is enabled, the example is built with support for
+                    OpenCores Ethernet MAC, which allows testing the example in QEMU.
+                    Note that this option is used for internal testing purposes, and
+                    not officially supported. Examples built with this option enabled
+                    will not run on a real ESP32 chip.
+
+        endchoice # EXAMPLE_ETHERNET_TYPE
+
+        if EXAMPLE_USE_INTERNAL_ETHERNET
+            choice EXAMPLE_ETH_PHY_MODEL
+                prompt "Ethernet PHY Device"
+                default EXAMPLE_ETH_PHY_IP101
+                help
+                    Select the Ethernet PHY device to use in the example.
+
+                config EXAMPLE_ETH_PHY_IP101
+                    bool "IP101"
+                    help
+                        IP101 is a single port 10/100 MII/RMII/TP/Fiber Fast Ethernet Transceiver.
+                        Goto http://www.icplus.com.tw/pp-IP101G.html for more information about it.
+
+                config EXAMPLE_ETH_PHY_RTL8201
+                    bool "RTL8201/SR8201"
+                    help
+                        RTL8201F/SR8201F is a single port 10/100Mb Ethernet Transceiver with auto MDIX.
+                        Goto http://www.corechip-sz.com/productsview.asp?id=22 for more information about it.
+
+                config EXAMPLE_ETH_PHY_LAN87XX
+                    bool "LAN87xx"
+                    help
+                        Below chips are supported:
+                        LAN8710A is a small footprint MII/RMII 10/100 Ethernet Transceiver with HP Auto-MDIX and
+                            flexPWR® Technology.
+                        LAN8720A is a small footprint RMII 10/100 Ethernet Transceiver with HP Auto-MDIX Support.
+                        LAN8740A/LAN8741A is a small footprint MII/RMII 10/100 Energy Efficient Ethernet Transceiver
+                            with HP Auto-MDIX and flexPWR® Technology.
+                        LAN8742A is a small footprint RMII 10/100 Ethernet Transceiver with HP Auto-MDIX and
+                            flexPWR® Technology.
+                        Goto https://www.microchip.com for more information about them.
+
+                config EXAMPLE_ETH_PHY_DP83848
+                    bool "DP83848"
+                    help
+                        DP83848 is a single port 10/100Mb/s Ethernet Physical Layer Transceiver.
+                        Goto http://www.ti.com/product/DP83848J for more information about it.
+
+                config EXAMPLE_ETH_PHY_KSZ80XX
+                    bool "KSZ80xx"
+                    help
+                        With the KSZ80xx series, Microchip offers single-chip 10BASE-T/100BASE-TX
+                        Ethernet Physical Layer Tranceivers (PHY).
+                        The following chips are supported: KSZ8001, KSZ8021, KSZ8031, KSZ8041,
+                            KSZ8051, KSZ8061, KSZ8081, KSZ8091
+                        Goto https://www.microchip.com for more information about them.
+            endchoice
+
+            config EXAMPLE_ETH_MDC_GPIO
+                int "SMI MDC GPIO number"
+                range ENV_GPIO_RANGE_MIN ENV_GPIO_OUT_RANGE_MAX
+                default 23
+                help
+                    Set the GPIO number used by SMI MDC.
+
+            config EXAMPLE_ETH_MDIO_GPIO
+                int "SMI MDIO GPIO number"
+                range ENV_GPIO_RANGE_MIN ENV_GPIO_OUT_RANGE_MAX
+                default 18
+                help
+                    Set the GPIO number used by SMI MDIO.
+        endif
+
+        if EXAMPLE_USE_SPI_ETHERNET
+            config EXAMPLE_ETH_SPI_HOST
+                int "SPI Host Number"
+                range 0 2
+                default 1
+                help
+                    Set the SPI host used to communicate with the SPI Ethernet Controller.
+
+            config EXAMPLE_ETH_SPI_SCLK_GPIO
+                int "SPI SCLK GPIO number"
+                range ENV_GPIO_RANGE_MIN ENV_GPIO_OUT_RANGE_MAX
+                default 14
+                help
+                    Set the GPIO number used by SPI SCLK.
+
+            config EXAMPLE_ETH_SPI_MOSI_GPIO
+                int "SPI MOSI GPIO number"
+                range ENV_GPIO_RANGE_MIN ENV_GPIO_OUT_RANGE_MAX
+                default 13
+                help
+                    Set the GPIO number used by SPI MOSI.
+
+            config EXAMPLE_ETH_SPI_MISO_GPIO
+                int "SPI MISO GPIO number"
+                range ENV_GPIO_RANGE_MIN ENV_GPIO_IN_RANGE_MAX
+                default 12
+                help
+                    Set the GPIO number used by SPI MISO.
+
+            config EXAMPLE_ETH_SPI_CS_GPIO
+                int "SPI CS GPIO number"
+                range ENV_GPIO_RANGE_MIN ENV_GPIO_OUT_RANGE_MAX
+                default 15
+                help
+                    Set the GPIO number used by SPI CS.
+
+            config EXAMPLE_ETH_SPI_CLOCK_MHZ
+                int "SPI clock speed (MHz)"
+                range 5 80
+                default 36
+                help
+                    Set the clock speed (MHz) of SPI interface.
+
+            config EXAMPLE_ETH_SPI_INT_GPIO
+                int "Interrupt GPIO number"
+                range ENV_GPIO_RANGE_MIN ENV_GPIO_IN_RANGE_MAX
+                default 4
+                help
+                    Set the GPIO number used by the SPI Ethernet module interrupt line.
+        endif # EXAMPLE_USE_SPI_ETHERNET
+
+        config EXAMPLE_ETH_PHY_RST_GPIO
+            int "PHY Reset GPIO number"
+            range -1 ENV_GPIO_OUT_RANGE_MAX
+            default 5
+            help
+                Set the GPIO number used to reset PHY chip.
+                Set to -1 to disable PHY chip hardware reset.
+
+        config EXAMPLE_ETH_PHY_ADDR
+            int "PHY Address"
+            range 0 31 if EXAMPLE_USE_INTERNAL_ETHERNET
+            default 1
+            help
+                Set PHY address according your board schematic.
+    endif # EXAMPLE_CONNECT_ETHERNET
+
+    config EXAMPLE_CONNECT_IPV6
+        bool "Obtain IPv6 address"
+        default y
+        depends on EXAMPLE_CONNECT_WIFI || EXAMPLE_CONNECT_ETHERNET
+        select LWIP_IPV6
+        help
+            By default, examples will wait until IPv4 and IPv6 local link addresses are obtained.
+            Disable this option if the network does not support IPv6.
+            Choose the preferred IPv6 address type if the connection code should wait until other than
+            the local link address gets assigned.
+            Consider enabling IPv6 stateless address autoconfiguration (SLAAC) in the LWIP component.
+
+    if EXAMPLE_CONNECT_IPV6
+        choice EXAMPLE_CONNECT_PREFERRED_IPV6
+            prompt "Preferred IPv6 Type"
+            default EXAMPLE_CONNECT_IPV6_PREF_LOCAL_LINK
+            help
+                Select which kind of IPv6 address the connect logic waits for.
+
+            config EXAMPLE_CONNECT_IPV6_PREF_LOCAL_LINK
+                bool "Local Link Address"
+                help
+                    Blocks until Local link address assigned.
+
+            config EXAMPLE_CONNECT_IPV6_PREF_GLOBAL
+                bool "Global Address"
+                help
+                    Blocks until Global address assigned.
+
+            config EXAMPLE_CONNECT_IPV6_PREF_SITE_LOCAL
+                bool "Site Local Address"
+                help
+                    Blocks until Site link address assigned.
+
+            config EXAMPLE_CONNECT_IPV6_PREF_UNIQUE_LOCAL
+                bool "Unique Local Link Address"
+                help
+                    Blocks until Unique local address assigned.
+
+        endchoice
+
+    endif
+
+
+endmenu

common_components/protocol_examples_common/addr_from_stdin.c

@@ -0,0 +1,68 @@
+#include <string.h>
+#include "esp_system.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "protocol_examples_common.h"
+
+#include "lwip/sockets.h"
+#include <lwip/netdb.h>
+#include <arpa/inet.h>
+
+#define HOST_IP_SIZE 128
+
+esp_err_t get_addr_from_stdin(int port, int sock_type, int *ip_protocol, int *addr_family, struct sockaddr_storage *dest_addr)
+{
+    char host_ip[HOST_IP_SIZE];
+    int len;
+    static bool already_init = false;
+
+    // this function could be called multiple times -> make sure UART init runs only once
+    if (!already_init) {
+        example_configure_stdin_stdout();
+        already_init = true;
+    }
+
+    // ignore empty or LF only string (could receive from DUT class)
+    do {
+        fgets(host_ip, HOST_IP_SIZE, stdin);
+        len = strlen(host_ip);
+    } while (len<=1 && host_ip[0] == '\n');
+    host_ip[len - 1] = '\0';
+
+    struct addrinfo hints, *addr_list, *cur;
+    memset( &hints, 0, sizeof( hints ) );
+
+    // run getaddrinfo() to decide on the IP protocol
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = sock_type;
+    hints.ai_protocol = IPPROTO_TCP;
+    if( getaddrinfo( host_ip, NULL, &hints, &addr_list ) != 0 ) {
+        return ESP_FAIL;
+    }
+    for( cur = addr_list; cur != NULL; cur = cur->ai_next ) {
+        memcpy(dest_addr, cur->ai_addr, sizeof(*dest_addr));
+        if (cur->ai_family == AF_INET) {
+            *ip_protocol = IPPROTO_IP;
+            *addr_family = AF_INET;
+            // add port number and return on first IPv4 match
+            ((struct sockaddr_in*)dest_addr)->sin_port = htons(port);
+            freeaddrinfo( addr_list );
+            return ESP_OK;
+
+        }
+#if CONFIG_LWIP_IPV6
+        else if (cur->ai_family == AF_INET6) {
+            *ip_protocol = IPPROTO_IPV6;
+            *addr_family = AF_INET6;
+            // add port and interface number and return on first IPv6 match
+            ((struct sockaddr_in6*)dest_addr)->sin6_port = htons(port);
+            ((struct sockaddr_in6*)dest_addr)->sin6_scope_id = esp_netif_get_netif_impl_index(EXAMPLE_INTERFACE);
+            freeaddrinfo( addr_list );
+            return ESP_OK;
+        }
+#endif
+    }
+    // no match found
+    freeaddrinfo( addr_list );
+    return ESP_FAIL;
+}

common_components/protocol_examples_common/connect.c

@@ -0,0 +1,515 @@
+/* Common functions for protocol examples, to establish Wi-Fi or Ethernet connection.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#include <string.h>
+#include "protocol_examples_common.h"
+#include "sdkconfig.h"
+#include "esp_event.h"
+#include "esp_wifi.h"
+#include "esp_wifi_default.h"
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+#include "esp_eth.h"
+#if CONFIG_ETH_USE_SPI_ETHERNET
+#include "driver/spi_master.h"
+#endif // CONFIG_ETH_USE_SPI_ETHERNET
+#endif // CONFIG_EXAMPLE_CONNECT_ETHERNET
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "driver/gpio.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "lwip/err.h"
+#include "lwip/sys.h"
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+#define MAX_IP6_ADDRS_PER_NETIF (5)
+#define NR_OF_IP_ADDRESSES_TO_WAIT_FOR (s_active_interfaces*2)
+
+#if defined(CONFIG_EXAMPLE_CONNECT_IPV6_PREF_LOCAL_LINK)
+#define EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE ESP_IP6_ADDR_IS_LINK_LOCAL
+#elif defined(CONFIG_EXAMPLE_CONNECT_IPV6_PREF_GLOBAL)
+#define EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE ESP_IP6_ADDR_IS_GLOBAL
+#elif defined(CONFIG_EXAMPLE_CONNECT_IPV6_PREF_SITE_LOCAL)
+#define EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE ESP_IP6_ADDR_IS_SITE_LOCAL
+#elif defined(CONFIG_EXAMPLE_CONNECT_IPV6_PREF_UNIQUE_LOCAL)
+#define EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE ESP_IP6_ADDR_IS_UNIQUE_LOCAL
+#endif // if-elif CONFIG_EXAMPLE_CONNECT_IPV6_PREF_...
+
+#else
+#define NR_OF_IP_ADDRESSES_TO_WAIT_FOR (s_active_interfaces)
+#endif
+
+#define EXAMPLE_DO_CONNECT CONFIG_EXAMPLE_CONNECT_WIFI || CONFIG_EXAMPLE_CONNECT_ETHERNET
+
+#if CONFIG_EXAMPLE_WIFI_SCAN_METHOD_FAST
+#define EXAMPLE_WIFI_SCAN_METHOD WIFI_FAST_SCAN
+#elif CONFIG_EXAMPLE_WIFI_SCAN_METHOD_ALL_CHANNEL
+#define EXAMPLE_WIFI_SCAN_METHOD WIFI_ALL_CHANNEL_SCAN
+#endif
+
+#if CONFIG_EXAMPLE_WIFI_CONNECT_AP_BY_SIGNAL
+#define EXAMPLE_WIFI_CONNECT_AP_SORT_METHOD WIFI_CONNECT_AP_BY_SIGNAL
+#elif CONFIG_EXAMPLE_WIFI_CONNECT_AP_BY_SECURITY
+#define EXAMPLE_WIFI_CONNECT_AP_SORT_METHOD WIFI_CONNECT_AP_BY_SECURITY
+#endif
+
+#if CONFIG_EXAMPLE_WIFI_AUTH_OPEN
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_OPEN
+#elif CONFIG_EXAMPLE_WIFI_AUTH_WEP
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WEP
+#elif CONFIG_EXAMPLE_WIFI_AUTH_WPA_PSK
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA_PSK
+#elif CONFIG_EXAMPLE_WIFI_AUTH_WPA2_PSK
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_PSK
+#elif CONFIG_EXAMPLE_WIFI_AUTH_WPA_WPA2_PSK
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA_WPA2_PSK
+#elif CONFIG_EXAMPLE_WIFI_AUTH_WPA2_ENTERPRISE
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_ENTERPRISE
+#elif CONFIG_EXAMPLE_WIFI_AUTH_WPA3_PSK
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA3_PSK
+#elif CONFIG_EXAMPLE_WIFI_AUTH_WPA2_WPA3_PSK
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_WPA3_PSK
+#elif CONFIG_EXAMPLE_WIFI_AUTH_WAPI_PSK
+#define EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WAPI_PSK
+#endif
+
+static int s_active_interfaces = 0;
+static SemaphoreHandle_t s_semph_get_ip_addrs;
+static esp_netif_t *s_example_esp_netif = NULL;
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+static esp_ip6_addr_t s_ipv6_addr;
+
+/* types of ipv6 addresses to be displayed on ipv6 events */
+static const char *s_ipv6_addr_types[] = {
+    "ESP_IP6_ADDR_IS_UNKNOWN",
+    "ESP_IP6_ADDR_IS_GLOBAL",
+    "ESP_IP6_ADDR_IS_LINK_LOCAL",
+    "ESP_IP6_ADDR_IS_SITE_LOCAL",
+    "ESP_IP6_ADDR_IS_UNIQUE_LOCAL",
+    "ESP_IP6_ADDR_IS_IPV4_MAPPED_IPV6"
+};
+#endif
+
+static const char *TAG = "example_connect";
+
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+static esp_netif_t *wifi_start(void);
+static void wifi_stop(void);
+#endif
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+static esp_netif_t *eth_start(void);
+static void eth_stop(void);
+#endif
+
+/**
+ * @brief Checks the netif description if it contains specified prefix.
+ * All netifs created withing common connect component are prefixed with the module TAG,
+ * so it returns true if the specified netif is owned by this module
+ */
+static bool is_our_netif(const char *prefix, esp_netif_t *netif)
+{
+    return strncmp(prefix, esp_netif_get_desc(netif), strlen(prefix) - 1) == 0;
+}
+
+/* set up connection, Wi-Fi and/or Ethernet */
+static void start(void)
+{
+
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+    s_example_esp_netif = wifi_start();
+    s_active_interfaces++;
+#endif
+
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+    s_example_esp_netif = eth_start();
+    s_active_interfaces++;
+#endif
+
+#if CONFIG_EXAMPLE_CONNECT_WIFI && CONFIG_EXAMPLE_CONNECT_ETHERNET
+    /* if both intefaces at once, clear out to indicate that multiple netifs are active */
+    s_example_esp_netif = NULL;
+#endif
+
+#if EXAMPLE_DO_CONNECT
+    /* create semaphore if at least one interface is active */
+    s_semph_get_ip_addrs = xSemaphoreCreateCounting(NR_OF_IP_ADDRESSES_TO_WAIT_FOR, 0);
+#endif
+
+}
+
+/* tear down connection, release resources */
+static void stop(void)
+{
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+    wifi_stop();
+    s_active_interfaces--;
+#endif
+
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+    eth_stop();
+    s_active_interfaces--;
+#endif
+}
+
+#if EXAMPLE_DO_CONNECT
+static esp_ip4_addr_t s_ip_addr;
+
+static void on_got_ip(void *arg, esp_event_base_t event_base,
+                      int32_t event_id, void *event_data)
+{
+    ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
+    if (!is_our_netif(TAG, event->esp_netif)) {
+        ESP_LOGW(TAG, "Got IPv4 from another interface \"%s\": ignored", esp_netif_get_desc(event->esp_netif));
+        return;
+    }
+    ESP_LOGI(TAG, "Got IPv4 event: Interface \"%s\" address: " IPSTR, esp_netif_get_desc(event->esp_netif), IP2STR(&event->ip_info.ip));
+    memcpy(&s_ip_addr, &event->ip_info.ip, sizeof(s_ip_addr));
+    xSemaphoreGive(s_semph_get_ip_addrs);
+}
+#endif
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+
+static void on_got_ipv6(void *arg, esp_event_base_t event_base,
+                        int32_t event_id, void *event_data)
+{
+    ip_event_got_ip6_t *event = (ip_event_got_ip6_t *)event_data;
+    if (!is_our_netif(TAG, event->esp_netif)) {
+        ESP_LOGW(TAG, "Got IPv6 from another netif: ignored");
+        return;
+    }
+    esp_ip6_addr_type_t ipv6_type = esp_netif_ip6_get_addr_type(&event->ip6_info.ip);
+    ESP_LOGI(TAG, "Got IPv6 event: Interface \"%s\" address: " IPV6STR ", type: %s", esp_netif_get_desc(event->esp_netif),
+             IPV62STR(event->ip6_info.ip), s_ipv6_addr_types[ipv6_type]);
+    if (ipv6_type == EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE) {
+        memcpy(&s_ipv6_addr, &event->ip6_info.ip, sizeof(s_ipv6_addr));
+        xSemaphoreGive(s_semph_get_ip_addrs);
+    }
+}
+
+#endif // CONFIG_EXAMPLE_CONNECT_IPV6
+
+esp_err_t example_connect(void)
+{
+#if EXAMPLE_DO_CONNECT
+    if (s_semph_get_ip_addrs != NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+#endif
+    start();
+    ESP_ERROR_CHECK(esp_register_shutdown_handler(&stop));
+    ESP_LOGI(TAG, "Waiting for IP(s)");
+    for (int i = 0; i < NR_OF_IP_ADDRESSES_TO_WAIT_FOR; ++i) {
+        xSemaphoreTake(s_semph_get_ip_addrs, portMAX_DELAY);
+    }
+    // iterate over active interfaces, and print out IPs of "our" netifs
+    esp_netif_t *netif = NULL;
+    esp_netif_ip_info_t ip;
+    for (int i = 0; i < esp_netif_get_nr_of_ifs(); ++i) {
+        netif = esp_netif_next(netif);
+        if (is_our_netif(TAG, netif)) {
+            ESP_LOGI(TAG, "Connected to %s", esp_netif_get_desc(netif));
+            ESP_ERROR_CHECK(esp_netif_get_ip_info(netif, &ip));
+
+            ESP_LOGI(TAG, "- IPv4 address: " IPSTR, IP2STR(&ip.ip));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+            esp_ip6_addr_t ip6[MAX_IP6_ADDRS_PER_NETIF];
+            int ip6_addrs = esp_netif_get_all_ip6(netif, ip6);
+            for (int j = 0; j < ip6_addrs; ++j) {
+                esp_ip6_addr_type_t ipv6_type = esp_netif_ip6_get_addr_type(&(ip6[j]));
+                ESP_LOGI(TAG, "- IPv6 address: " IPV6STR ", type: %s", IPV62STR(ip6[j]), s_ipv6_addr_types[ipv6_type]);
+            }
+#endif
+
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t example_disconnect(void)
+{
+    if (s_semph_get_ip_addrs == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    vSemaphoreDelete(s_semph_get_ip_addrs);
+    s_semph_get_ip_addrs = NULL;
+    stop();
+    ESP_ERROR_CHECK(esp_unregister_shutdown_handler(&stop));
+    return ESP_OK;
+}
+
+#ifdef CONFIG_EXAMPLE_CONNECT_WIFI
+
+static void on_wifi_disconnect(void *arg, esp_event_base_t event_base,
+                               int32_t event_id, void *event_data)
+{
+    ESP_LOGI(TAG, "Wi-Fi disconnected, trying to reconnect...");
+    esp_err_t err = esp_wifi_connect();
+    if (err == ESP_ERR_WIFI_NOT_STARTED) {
+        return;
+    }
+    ESP_ERROR_CHECK(err);
+}
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+
+static void on_wifi_connect(void *esp_netif, esp_event_base_t event_base,
+                            int32_t event_id, void *event_data)
+{
+    esp_netif_create_ip6_linklocal(esp_netif);
+}
+
+#endif // CONFIG_EXAMPLE_CONNECT_IPV6
+
+static esp_netif_t *wifi_start(void)
+{
+    char *desc;
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
+
+    esp_netif_inherent_config_t esp_netif_config = ESP_NETIF_INHERENT_DEFAULT_WIFI_STA();
+    // Prefix the interface description with the module TAG
+    // Warning: the interface desc is used in tests to capture actual connection details (IP, gw, mask)
+    asprintf(&desc, "%s: %s", TAG, esp_netif_config.if_desc);
+    esp_netif_config.if_desc = desc;
+    esp_netif_config.route_prio = 128;
+    esp_netif_t *netif = esp_netif_create_wifi(WIFI_IF_STA, &esp_netif_config);
+    free(desc);
+    esp_wifi_set_default_wifi_sta_handlers();
+
+    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &on_wifi_disconnect, NULL));
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &on_got_ip, NULL));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, &on_wifi_connect, netif));
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_GOT_IP6, &on_got_ipv6, NULL));
+#endif
+
+    ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
+    wifi_config_t wifi_config = {
+        .sta = {
+            .ssid = CONFIG_EXAMPLE_WIFI_SSID,
+            .password = CONFIG_EXAMPLE_WIFI_PASSWORD,
+            .scan_method = EXAMPLE_WIFI_SCAN_METHOD,
+            .sort_method = EXAMPLE_WIFI_CONNECT_AP_SORT_METHOD,
+            .threshold.rssi = CONFIG_EXAMPLE_WIFI_SCAN_RSSI_THRESHOLD,
+            .threshold.authmode = EXAMPLE_WIFI_SCAN_AUTH_MODE_THRESHOLD,
+        },
+    };
+    ESP_LOGI(TAG, "Connecting to %s...", wifi_config.sta.ssid);
+    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
+    ESP_ERROR_CHECK(esp_wifi_start());
+    esp_wifi_connect();
+    return netif;
+}
+
+static void wifi_stop(void)
+{
+    esp_netif_t *wifi_netif = get_example_netif_from_desc("sta");
+    ESP_ERROR_CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &on_wifi_disconnect));
+    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &on_got_ip));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_GOT_IP6, &on_got_ipv6));
+    ESP_ERROR_CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, &on_wifi_connect));
+#endif
+    esp_err_t err = esp_wifi_stop();
+    if (err == ESP_ERR_WIFI_NOT_INIT) {
+        return;
+    }
+    ESP_ERROR_CHECK(err);
+    ESP_ERROR_CHECK(esp_wifi_deinit());
+    ESP_ERROR_CHECK(esp_wifi_clear_default_wifi_driver_and_handlers(wifi_netif));
+    esp_netif_destroy(wifi_netif);
+    s_example_esp_netif = NULL;
+}
+#endif // CONFIG_EXAMPLE_CONNECT_WIFI
+
+#ifdef CONFIG_EXAMPLE_CONNECT_ETHERNET
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+
+/** Event handler for Ethernet events */
+static void on_eth_event(void *esp_netif, esp_event_base_t event_base,
+                         int32_t event_id, void *event_data)
+{
+    switch (event_id) {
+    case ETHERNET_EVENT_CONNECTED:
+        ESP_LOGI(TAG, "Ethernet Link Up");
+        ESP_ERROR_CHECK(esp_netif_create_ip6_linklocal(esp_netif));
+        break;
+    default:
+        break;
+    }
+}
+
+#endif // CONFIG_EXAMPLE_CONNECT_IPV6
+
+static esp_eth_handle_t s_eth_handle = NULL;
+static esp_eth_mac_t *s_mac = NULL;
+static esp_eth_phy_t *s_phy = NULL;
+static esp_eth_netif_glue_handle_t s_eth_glue = NULL;
+
+static esp_netif_t *eth_start(void)
+{
+    char *desc;
+    esp_netif_inherent_config_t esp_netif_config = ESP_NETIF_INHERENT_DEFAULT_ETH();
+    // Prefix the interface description with the module TAG
+    // Warning: the interface desc is used in tests to capture actual connection details (IP, gw, mask)
+    asprintf(&desc, "%s: %s", TAG, esp_netif_config.if_desc);
+    esp_netif_config.if_desc = desc;
+    esp_netif_config.route_prio = 64;
+    esp_netif_config_t netif_config = {
+        .base = &esp_netif_config,
+        .stack = ESP_NETIF_NETSTACK_DEFAULT_ETH
+    };
+    esp_netif_t *netif = esp_netif_new(&netif_config);
+    assert(netif);
+    free(desc);
+
+    eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
+    eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
+    phy_config.phy_addr = CONFIG_EXAMPLE_ETH_PHY_ADDR;
+    phy_config.reset_gpio_num = CONFIG_EXAMPLE_ETH_PHY_RST_GPIO;
+#if CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET
+    eth_esp32_emac_config_t esp32_emac_config = ETH_ESP32_EMAC_DEFAULT_CONFIG();
+    esp32_emac_config.smi_mdc_gpio_num = CONFIG_EXAMPLE_ETH_MDC_GPIO;
+    esp32_emac_config.smi_mdio_gpio_num = CONFIG_EXAMPLE_ETH_MDIO_GPIO;
+    s_mac = esp_eth_mac_new_esp32(&esp32_emac_config, &mac_config);
+#if CONFIG_EXAMPLE_ETH_PHY_IP101
+    s_phy = esp_eth_phy_new_ip101(&phy_config);
+#elif CONFIG_EXAMPLE_ETH_PHY_RTL8201
+    s_phy = esp_eth_phy_new_rtl8201(&phy_config);
+#elif CONFIG_EXAMPLE_ETH_PHY_LAN87XX
+    s_phy = esp_eth_phy_new_lan87xx(&phy_config);
+#elif CONFIG_EXAMPLE_ETH_PHY_DP83848
+    s_phy = esp_eth_phy_new_dp83848(&phy_config);
+#elif CONFIG_EXAMPLE_ETH_PHY_KSZ80XX
+    s_phy = esp_eth_phy_new_ksz80xx(&phy_config);
+#endif
+#elif CONFIG_EXAMPLE_USE_SPI_ETHERNET
+    gpio_install_isr_service(0);
+    spi_device_handle_t spi_handle = NULL;
+    spi_bus_config_t buscfg = {
+        .miso_io_num = CONFIG_EXAMPLE_ETH_SPI_MISO_GPIO,
+        .mosi_io_num = CONFIG_EXAMPLE_ETH_SPI_MOSI_GPIO,
+        .sclk_io_num = CONFIG_EXAMPLE_ETH_SPI_SCLK_GPIO,
+        .quadwp_io_num = -1,
+        .quadhd_io_num = -1,
+    };
+    ESP_ERROR_CHECK(spi_bus_initialize(CONFIG_EXAMPLE_ETH_SPI_HOST, &buscfg, 1));
+#if CONFIG_EXAMPLE_USE_DM9051
+    spi_device_interface_config_t devcfg = {
+        .command_bits = 1,
+        .address_bits = 7,
+        .mode = 0,
+        .clock_speed_hz = CONFIG_EXAMPLE_ETH_SPI_CLOCK_MHZ * 1000 * 1000,
+        .spics_io_num = CONFIG_EXAMPLE_ETH_SPI_CS_GPIO,
+        .queue_size = 20
+    };
+    ESP_ERROR_CHECK(spi_bus_add_device(CONFIG_EXAMPLE_ETH_SPI_HOST, &devcfg, &spi_handle));
+    /* dm9051 ethernet driver is based on spi driver */
+    eth_dm9051_config_t dm9051_config = ETH_DM9051_DEFAULT_CONFIG(spi_handle);
+    dm9051_config.int_gpio_num = CONFIG_EXAMPLE_ETH_SPI_INT_GPIO;
+    s_mac = esp_eth_mac_new_dm9051(&dm9051_config, &mac_config);
+    s_phy = esp_eth_phy_new_dm9051(&phy_config);
+#elif CONFIG_EXAMPLE_USE_W5500
+    spi_device_interface_config_t devcfg = {
+        .command_bits = 16, // Actually it's the address phase in W5500 SPI frame
+        .address_bits = 8,  // Actually it's the control phase in W5500 SPI frame
+        .mode = 0,
+        .clock_speed_hz = CONFIG_EXAMPLE_ETH_SPI_CLOCK_MHZ * 1000 * 1000,
+        .spics_io_num = CONFIG_EXAMPLE_ETH_SPI_CS_GPIO,
+        .queue_size = 20
+    };
+    ESP_ERROR_CHECK(spi_bus_add_device(CONFIG_EXAMPLE_ETH_SPI_HOST, &devcfg, &spi_handle));
+    /* w5500 ethernet driver is based on spi driver */
+    eth_w5500_config_t w5500_config = ETH_W5500_DEFAULT_CONFIG(spi_handle);
+    w5500_config.int_gpio_num = CONFIG_EXAMPLE_ETH_SPI_INT_GPIO;
+    s_mac = esp_eth_mac_new_w5500(&w5500_config, &mac_config);
+    s_phy = esp_eth_phy_new_w5500(&phy_config);
+#endif
+#elif CONFIG_EXAMPLE_USE_OPENETH
+    phy_config.autonego_timeout_ms = 100;
+    s_mac = esp_eth_mac_new_openeth(&mac_config);
+    s_phy = esp_eth_phy_new_dp83848(&phy_config);
+#endif
+
+    // Install Ethernet driver
+    esp_eth_config_t config = ETH_DEFAULT_CONFIG(s_mac, s_phy);
+    ESP_ERROR_CHECK(esp_eth_driver_install(&config, &s_eth_handle));
+#if !CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET
+    /* The SPI Ethernet module might doesn't have a burned factory MAC address, we cat to set it manually.
+       02:00:00 is a Locally Administered OUI range so should not be used except when testing on a LAN under your control.
+    */
+    ESP_ERROR_CHECK(esp_eth_ioctl(s_eth_handle, ETH_CMD_S_MAC_ADDR, (uint8_t[]) {
+        0x02, 0x00, 0x00, 0x12, 0x34, 0x56
+    }));
+#endif
+    // combine driver with netif
+    s_eth_glue = esp_eth_new_netif_glue(s_eth_handle);
+    esp_netif_attach(netif, s_eth_glue);
+
+    // Register user defined event handers
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, &on_got_ip, NULL));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+    ESP_ERROR_CHECK(esp_event_handler_register(ETH_EVENT, ETHERNET_EVENT_CONNECTED, &on_eth_event, netif));
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_GOT_IP6, &on_got_ipv6, NULL));
+#endif
+
+    esp_eth_start(s_eth_handle);
+    return netif;
+}
+
+static void eth_stop(void)
+{
+    esp_netif_t *eth_netif = get_example_netif_from_desc("eth");
+    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_ETH_GOT_IP, &on_got_ip));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_GOT_IP6, &on_got_ipv6));
+    ESP_ERROR_CHECK(esp_event_handler_unregister(ETH_EVENT, ETHERNET_EVENT_CONNECTED, &on_eth_event));
+#endif
+    ESP_ERROR_CHECK(esp_eth_stop(s_eth_handle));
+    ESP_ERROR_CHECK(esp_eth_del_netif_glue(s_eth_glue));
+    ESP_ERROR_CHECK(esp_eth_driver_uninstall(s_eth_handle));
+    s_eth_handle = NULL;
+    ESP_ERROR_CHECK(s_phy->del(s_phy));
+    ESP_ERROR_CHECK(s_mac->del(s_mac));
+
+    esp_netif_destroy(eth_netif);
+    s_example_esp_netif = NULL;
+}
+
+esp_eth_handle_t get_example_eth_handle(void)
+{
+    return s_eth_handle;
+}
+
+#endif // CONFIG_EXAMPLE_CONNECT_ETHERNET
+
+esp_netif_t *get_example_netif(void)
+{
+    return s_example_esp_netif;
+}
+
+esp_netif_t *get_example_netif_from_desc(const char *desc)
+{
+    esp_netif_t *netif = NULL;
+    char *expected_desc;
+    asprintf(&expected_desc, "%s: %s", TAG, desc);
+    while ((netif = esp_netif_next(netif)) != NULL) {
+        if (strcmp(esp_netif_get_desc(netif), expected_desc) == 0) {
+            free(expected_desc);
+            return netif;
+        }
+    }
+    free(expected_desc);
+    return netif;
+}

common_components/protocol_examples_common/include/addr_from_stdin.h

@@ -0,0 +1,44 @@
+/*  Common utilities for socket address input interface:
+    The API get_addr_from_stdin() is mainly used by socket client examples which read IP address from stdin (if configured).
+    This option is typically used in the CI, but could be enabled in the project configuration.
+    In that case this component is used to receive a string that is evaluated and processed to output
+    socket structures to open a connectio
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lwip/sys.h"
+#include <lwip/netdb.h>
+#include <arpa/inet.h>
+
+/**
+ * @brief Read and evaluate IP address from stdin
+ *
+ * This API reads stdin and parses the input address using getaddrinfo()
+ * to fill in struct sockaddr_storage (for both IPv4 and IPv6) used to open
+ * a socket. IP protocol is guessed from the IP address string.
+ *
+ * @param[in] port port number of expected connection
+ * @param[in] sock_type expected protocol: SOCK_STREAM or SOCK_DGRAM
+ * @param[out] ip_protocol resultant IP protocol: IPPROTO_IP or IPPROTO_IP6
+ * @param[out] addr_family resultant address family: AF_INET or AF_INET6
+ * @param[out] dest_addr sockaddr_storage structure (for both IPv4 and IPv6)
+ * @return ESP_OK on success, ESP_FAIL otherwise
+ */
+esp_err_t get_addr_from_stdin(int port, int sock_type,
+                              int *ip_protocol,
+                              int *addr_family,
+                              struct sockaddr_storage *dest_addr);
+
+#ifdef __cplusplus
+}
+#endif

common_components/protocol_examples_common/include/protocol_examples_common.h

@@ -0,0 +1,92 @@
+/* Common functions for protocol examples, to establish Wi-Fi or Ethernet connection.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp_err.h"
+#include "esp_netif.h"
+
+#ifdef CONFIG_EXAMPLE_CONNECT_ETHERNET
+#define EXAMPLE_INTERFACE get_example_netif()
+#endif
+
+#ifdef CONFIG_EXAMPLE_CONNECT_WIFI
+#define EXAMPLE_INTERFACE get_example_netif()
+#endif
+
+#if !defined (CONFIG_EXAMPLE_CONNECT_ETHERNET) && !defined (CONFIG_EXAMPLE_CONNECT_WIFI)
+// This is useful for some tests which do not need a network connection
+#define EXAMPLE_INTERFACE NULL
+#endif
+
+/**
+ * @brief Configure Wi-Fi or Ethernet, connect, wait for IP
+ *
+ * This all-in-one helper function is used in protocols examples to
+ * reduce the amount of boilerplate in the example.
+ *
+ * It is not intended to be used in real world applications.
+ * See examples under examples/wifi/getting_started/ and examples/ethernet/
+ * for more complete Wi-Fi or Ethernet initialization code.
+ *
+ * Read "Establishing Wi-Fi or Ethernet Connection" section in
+ * examples/protocols/README.md for more information about this function.
+ *
+ * @return ESP_OK on successful connection
+ */
+esp_err_t example_connect(void);
+
+/**
+ * Counterpart to example_connect, de-initializes Wi-Fi or Ethernet
+ */
+esp_err_t example_disconnect(void);
+
+/**
+ * @brief Configure stdin and stdout to use blocking I/O
+ *
+ * This helper function is used in ASIO examples. It wraps installing the
+ * UART driver and configuring VFS layer to use UART driver for console I/O.
+ */
+esp_err_t example_configure_stdin_stdout(void);
+
+/**
+ * @brief Returns esp-netif pointer created by example_connect()
+ *
+ * @note If multiple interfaces active at once, this API return NULL
+ * In that case the get_example_netif_from_desc() should be used
+ * to get esp-netif pointer based on interface description
+ */
+esp_netif_t *get_example_netif(void);
+
+/**
+ * @brief Returns esp-netif pointer created by example_connect() described by
+ * the supplied desc field
+ *
+ * @param desc Textual interface of created network interface, for example "sta"
+ * indicate default WiFi station, "eth" default Ethernet interface.
+ *
+ */
+esp_netif_t *get_example_netif_from_desc(const char *desc);
+
+#ifdef CONFIG_EXAMPLE_CONNECT_ETHERNET
+/**
+ * @brief Get the example Ethernet driver handle
+ *
+ * @return esp_eth_handle_t
+ */
+esp_eth_handle_t get_example_eth_handle(void);
+#endif // CONFIG_EXAMPLE_CONNECT_ETHERNET
+
+#ifdef __cplusplus
+}
+#endif

common_components/protocol_examples_common/stdin_out.c

@@ -0,0 +1,29 @@
+/* Common functions for protocol examples, to configure stdin and stdout.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#include "protocol_examples_common.h"
+#include "esp_err.h"
+#include "esp_vfs_dev.h"
+#include "driver/uart.h"
+#include "sdkconfig.h"
+
+esp_err_t example_configure_stdin_stdout(void)
+{
+    // Initialize VFS & UART so we can use std::cout/cin
+    setvbuf(stdin, NULL, _IONBF, 0);
+    /* Install UART driver for interrupt-driven reads and writes */
+    ESP_ERROR_CHECK( uart_driver_install( (uart_port_t)CONFIG_ESP_CONSOLE_UART_NUM,
+            256, 0, 0, NULL, 0) );
+    /* Tell VFS to use UART driver */
+    esp_vfs_dev_uart_use_driver(CONFIG_ESP_CONSOLE_UART_NUM);
+    esp_vfs_dev_uart_port_set_rx_line_endings(CONFIG_ESP_CONSOLE_UART_NUM, ESP_LINE_ENDINGS_CR);
+    /* Move the caret to the beginning of the next line on '\n' */
+    esp_vfs_dev_uart_port_set_tx_line_endings(CONFIG_ESP_CONSOLE_UART_NUM, ESP_LINE_ENDINGS_CRLF);
+    return ESP_OK;
+}

components/mdns/CMakeLists.txt

@@ -0,0 +1,22 @@
+if(CONFIG_MDNS_NETWORKING_SOCKET)
+    set(MDNS_NETWORKING "mdns_networking_socket.c")
+else()
+    set(MDNS_NETWORKING "mdns_networking_lwip.c")
+endif()
+
+idf_build_get_property(target IDF_TARGET)
+if(${target} STREQUAL "linux")
+    set(dependencies esp_system_protocols_linux)
+    set(srcs "mdns.c" ${MDNS_NETWORKING})
+else()
+    set(dependencies lwip console esp_netif)
+    set(private_dependencies esp_timer)
+    set(srcs "mdns.c" ${MDNS_NETWORKING} "mdns_console.c")
+endif()
+
+idf_component_register(
+        SRCS ${srcs}
+        INCLUDE_DIRS "include"
+        PRIV_INCLUDE_DIRS "private_include"
+        REQUIRES ${dependencies}
+        PRIV_REQUIRES ${private_dependencies})

components/mdns/Kconfig

@@ -0,0 +1,127 @@
+menu "mDNS"
+
+    config MDNS_MAX_INTERFACES
+        int "Max number of interfaces"
+        range 1 9
+        default 3
+        help
+            Number of network interfaces to be served by the mDNS library.
+            Lowering this number helps to reduce some static RAM usage.
+
+    config MDNS_MAX_SERVICES
+        int "Max number of services"
+        range 1 64
+        default 10
+        help
+            Services take up a certain amount of memory, and allowing fewer
+            services to be open at the same time conserves memory. Specify
+            the maximum amount of services here. The valid value is from 1
+            to 64.
+
+    config MDNS_TASK_PRIORITY
+        int "mDNS task priority"
+        range 1 255
+        default 1
+        help
+            Allows setting mDNS task priority. Please do not set the task priority
+            higher than priorities of system tasks. Compile time warning/error
+            would be emitted if the chosen task priority were too high.
+
+    config MDNS_TASK_STACK_SIZE
+        int "mDNS task stack size"
+        default 4096
+        help
+            Allows setting mDNS task stacksize.
+
+    choice MDNS_TASK_AFFINITY
+        prompt "mDNS task affinity"
+        default MDNS_TASK_AFFINITY_CPU0
+        help
+            Allows setting mDNS tasks affinity, i.e. whether the task is pinned to
+            CPU0, pinned to CPU1, or allowed to run on any CPU.
+
+        config MDNS_TASK_AFFINITY_NO_AFFINITY
+            bool "No affinity"
+        config MDNS_TASK_AFFINITY_CPU0
+            bool "CPU0"
+        config MDNS_TASK_AFFINITY_CPU1
+            bool "CPU1"
+            depends on !FREERTOS_UNICORE
+
+    endchoice
+
+    config MDNS_TASK_AFFINITY
+        hex
+        default FREERTOS_NO_AFFINITY if MDNS_TASK_AFFINITY_NO_AFFINITY
+        default 0x0 if MDNS_TASK_AFFINITY_CPU0
+        default 0x1 if MDNS_TASK_AFFINITY_CPU1
+
+    config MDNS_SERVICE_ADD_TIMEOUT_MS
+        int "mDNS adding service timeout (ms)"
+        range 10 30000
+        default 2000
+        help
+            Configures timeout for adding a new mDNS service. Adding a service
+            fails if could not be completed within this time.
+
+    config MDNS_STRICT_MODE
+        bool "mDNS strict mode"
+        default "n"
+        help
+            Configures strict mode. Set this to 1 for the mDNS library to strictly follow the RFC6762:
+            Currently the only strict feature: Do not repeat original questions in response packets
+            (defined in RFC6762 sec. 6).
+            Default configuration is 0, i.e. non-strict mode, since some implementations,
+            such as lwIP mDNS resolver (used by standard POSIX API like getaddrinfo, gethostbyname)
+            could not correctly resolve advertised names.
+
+    config MDNS_TIMER_PERIOD_MS
+        int "mDNS timer period (ms)"
+        range 10 10000
+        default 100
+        help
+            Configures period of mDNS timer, which periodically transmits packets
+            and schedules mDNS searches.
+
+    config MDNS_NETWORKING_SOCKET
+        bool "Use BSD sockets for mDNS networking"
+        default n
+        help
+            Enables optional mDNS networking implementation using BSD sockets
+            in UDP multicast mode.
+            This option creates a new thread to serve receiving packets (TODO).
+            This option uses additional N sockets, where N is number of interfaces.
+
+    config MDNS_MULTIPLE_INSTANCE
+        bool "Multiple instances under the same service type"
+        default y
+        help
+            Enables adding multiple service instances under the same service type.
+
+    menu "MDNS Predefined interfaces"
+
+        config MDNS_PREDEF_NETIF_STA
+            bool "Use predefined interface for WiFi Station"
+            default y
+            help
+                Set up mDNS for the default WiFi station.
+                Disable this option if you do not need mDNS on default WiFi STA.
+
+        config MDNS_PREDEF_NETIF_AP
+            bool "Use predefined interface for WiFi Access Point"
+            default y
+            help
+                Set up mDNS for the default WiFi Access Point.
+                Disable this option if you do not need mDNS on default WiFi AP.
+
+        config MDNS_PREDEF_NETIF_ETH
+            bool "Use predefined interface for Ethernet"
+            depends on ETH_ENABLED
+            default y
+            help
+                Set up mDNS for the default Ethernet interface.
+                Disable this option if you do not need mDNS on default Ethernet.
+
+    endmenu # MDNS Predefined interfaces
+
+endmenu

components/mdns/README.md

@@ -0,0 +1,11 @@
+# mDNS Service
+
+mDNS is a multicast UDP service that is used to provide local network service and host discovery.
+
+## Examples
+
+Get started with example test [Example](examples/README.md):
+
+## Documentation
+
+* View the full [html documentation](https://espressif.github.io/esp-protocols/mdns/index.html)

components/mdns/docs/Doxyfile

@@ -0,0 +1,75 @@
+# This is Doxygen configuration file
+#
+# Doxygen provides over 260 configuration statements
+# To make this file easier to follow,
+# it contains only statements that are non-default
+#
+# NOTE:
+# It is recommended not to change defaults unless specifically required
+# Test any changes how they affect generated documentation
+# Make sure that correct warnings are generated to flag issues with documented code
+#
+# For the complete list of configuration statements see:
+# http://doxygen.nl/manual/config.html
+
+
+PROJECT_NAME = "ESP Protocols Programming Guide"
+
+## The 'INPUT' statement below is used as input by script 'gen-df-input.py'
+## to automatically generate API reference list files heder_file.inc
+## These files are placed in '_inc' directory
+## and used to include in API reference documentation
+
+INPUT = \
+   $(PROJECT_PATH)/include/mdns.h
+
+## Get warnings for functions that have no documentation for their parameters or return value
+##
+WARN_NO_PARAMDOC = YES
+
+## Enable preprocessing and remove __attribute__(...) expressions from the INPUT files
+##
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = YES
+EXPAND_ONLY_PREDEF     = YES
+PREDEFINED             = \
+    $(ENV_DOXYGEN_DEFINES) \
+    __DOXYGEN__=1 \
+    __attribute__(x)= \
+	_Static_assert()= \
+    IDF_DEPRECATED(X)= \
+    IRAM_ATTR= \
+    configSUPPORT_DYNAMIC_ALLOCATION=1 \
+    configSUPPORT_STATIC_ALLOCATION=1 \
+    configQUEUE_REGISTRY_SIZE=1 \
+    configUSE_RECURSIVE_MUTEXES=1 \
+    configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS=1 \
+    configNUM_THREAD_LOCAL_STORAGE_POINTERS=1 \
+    configUSE_APPLICATION_TASK_TAG=1 \
+    configTASKLIST_INCLUDE_COREID=1 \
+    "ESP_EVENT_DECLARE_BASE(x)=extern esp_event_base_t x"
+
+## Do not complain about not having dot
+##
+HAVE_DOT = NO
+
+## Generate XML that is required for Breathe
+##
+GENERATE_XML    = YES
+XML_OUTPUT      = xml
+
+GENERATE_HTML   = NO
+HAVE_DOT        = NO
+GENERATE_LATEX  = NO
+GENERATE_MAN    = YES
+GENERATE_RTF    = NO
+
+## Skip distracting progress messages
+##
+QUIET = YES
+
+## Enable Section Tags for conditional documentation
+##
+ENABLED_SECTIONS += \
+    DOC_EXCLUDE_HEADER_SECTION \   ## To conditionally remove doc sections from IDF source files without affecting documentation in upstream files.
+    DOC_SINGLE_GROUP        ## To conditionally remove groups from the documentation and create a 'flat' document without affecting documentation in upstream files.

components/mdns/docs/conf_common.py

@@ -0,0 +1,21 @@
+from esp_docs.conf_docs import *  # noqa: F403,F401
+
+extensions += ['sphinx_copybutton',
+               # Needed as a trigger for running doxygen
+               'esp_docs.esp_extensions.dummy_build_system',
+               'esp_docs.esp_extensions.run_doxygen',
+               ]
+
+# link roles config
+github_repo = 'espressif/esp-protocols'
+
+# context used by sphinx_idf_theme
+html_context['github_user'] = 'espressif'
+html_context['github_repo'] = 'esp-protocols'
+
+# Extra options required by sphinx_idf_theme
+project_slug = 'esp-idf' # >=5.0
+versions_url = 'https://github.com/espressif/esp-protocols/docs/docs_versions.js'
+
+idf_targets = ['esp32']
+languages = ['en', 'zh_CN']

components/mdns/docs/en/conf.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+#
+# English Language RTD & Sphinx config file
+#
+# Uses ../conf_common.py for most non-language-specific settings.
+
+# Importing conf_common adds all the non-language-specific
+# parts to this conf module
+
+try:
+    from conf_common import *  # noqa: F403,F401
+except ImportError:
+    import os
+    import sys
+    sys.path.insert(0, os.path.abspath('../'))
+    from conf_common import *  # noqa: F403,F401
+
+# General information about the project.
+project = u'ESP-Protocols'
+copyright = u'2016 - 2022, Espressif Systems (Shanghai) Co., Ltd'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+language = 'en'

components/mdns/docs/en/index.rst

@@ -0,0 +1,205 @@
+mDNS Service
+============
+:link_to_translation:`zh_CN:[中文]`
+
+Overview
+--------
+
+mDNS is a multicast UDP service that is used to provide local network service and host discovery.
+
+mDNS is installed by default on most operating systems or is available as separate package. On ``Mac OS`` it is installed by default and is called ``Bonjour``. Apple releases an installer for ``Windows`` that can be found `on Apple's support page <https://support.apple.com/downloads/bonjour%2520for%2520windows>`_. On ``Linux``, mDNS is provided by `avahi <https://github.com/lathiat/avahi>`_ and is usually installed by default.
+
+mDNS Properties
+^^^^^^^^^^^^^^^
+
+    * ``hostname``: the hostname that the device will respond to. If not set, the ``hostname`` will be read from the interface. Example: ``my-{IDF_TARGET_PATH_NAME}`` will resolve to ``my-{IDF_TARGET_PATH_NAME}.local``
+    * ``default_instance``: friendly name for your device, like ``Jhon's {IDF_TARGET_NAME} Thing``. If not set, ``hostname`` will be used.
+
+Example method to start mDNS for the STA interface and set ``hostname`` and ``default_instance``:
+
+.. highlight:: c
+
+::
+
+    void start_mdns_service()
+    {
+        //initialize mDNS service
+        esp_err_t err = mdns_init();
+        if (err) {
+            printf("MDNS Init failed: %d\n", err);
+            return;
+        }
+
+        //set hostname
+        mdns_hostname_set("my-{IDF_TARGET_PATH_NAME}");
+        //set default instance
+        mdns_instance_name_set("Jhon's {IDF_TARGET_NAME} Thing");
+    }
+
+mDNS Services
+^^^^^^^^^^^^^
+
+mDNS can advertise information about network services that your device offers. Each service is defined by a few properties.
+
+    * ``instance_name``: friendly name for your service, like ``Jhon's E{IDF_TARGET_NAME} Web Server``. If not defined, ``default_instance`` will be used.
+    * ``service_type``: (required) service type, prepended with underscore. Some common types can be found `here <http://www.dns-sd.org/serviceTypes.html>`_.
+    * ``proto``: (required) protocol that the service runs on, prepended with underscore. Example: ``_tcp`` or ``_udp``
+    * ``port``: (required) network port that the service runs on
+    * ``txt``: ``{var, val}`` array of strings, used to define properties for your service
+
+Example method to add a few services and different properties::
+
+    void add_mdns_services()
+    {
+        //add our services
+        mdns_service_add(NULL, "_http", "_tcp", 80, NULL, 0);
+        mdns_service_add(NULL, "_arduino", "_tcp", 3232, NULL, 0);
+        mdns_service_add(NULL, "_myservice", "_udp", 1234, NULL, 0);
+
+        //NOTE: services must be added before their properties can be set
+        //use custom instance for the web server
+        mdns_service_instance_name_set("_http", "_tcp", "Jhon's {IDF_TARGET_NAME} Web Server");
+
+        mdns_txt_item_t serviceTxtData[3] = {
+            {"board","{{IDF_TARGET_PATH_NAME}}"},
+            {"u","user"},
+            {"p","password"}
+        };
+        //set txt data for service (will free and replace current data)
+        mdns_service_txt_set("_http", "_tcp", serviceTxtData, 3);
+
+        //change service port
+        mdns_service_port_set("_myservice", "_udp", 4321);
+    }
+
+mDNS Query
+^^^^^^^^^^
+
+mDNS provides methods for browsing for services and resolving host's IP/IPv6 addresses.
+
+Results for services are returned as a linked list of ``mdns_result_t`` objects.
+
+Example method to resolve host IPs::
+
+    void resolve_mdns_host(const char * host_name)
+    {
+        printf("Query A: %s.local", host_name);
+
+        struct ip4_addr addr;
+        addr.addr = 0;
+
+        esp_err_t err = mdns_query_a(host_name, 2000,  &addr);
+        if(err){
+            if(err == ESP_ERR_NOT_FOUND){
+                printf("Host was not found!");
+                return;
+            }
+            printf("Query Failed");
+            return;
+        }
+
+        printf(IPSTR, IP2STR(&addr));
+    }
+
+Example method to resolve local services::
+
+    static const char * if_str[] = {"STA", "AP", "ETH", "MAX"};
+    static const char * ip_protocol_str[] = {"V4", "V6", "MAX"};
+
+    void mdns_print_results(mdns_result_t * results){
+        mdns_result_t * r = results;
+        mdns_ip_addr_t * a = NULL;
+        int i = 1, t;
+        while(r){
+            printf("%d: Interface: %s, Type: %s\n", i++, if_str[r->tcpip_if], ip_protocol_str[r->ip_protocol]);
+            if(r->instance_name){
+                printf("  PTR : %s\n", r->instance_name);
+            }
+            if(r->hostname){
+                printf("  SRV : %s.local:%u\n", r->hostname, r->port);
+            }
+            if(r->txt_count){
+                printf("  TXT : [%u] ", r->txt_count);
+                for(t=0; t<r->txt_count; t++){
+                    printf("%s=%s; ", r->txt[t].key, r->txt[t].value);
+                }
+                printf("\n");
+            }
+            a = r->addr;
+            while(a){
+                if(a->addr.type == IPADDR_TYPE_V6){
+                    printf("  AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6));
+                } else {
+                    printf("  A   : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4)));
+                }
+                a = a->next;
+            }
+            r = r->next;
+        }
+
+    }
+
+    void find_mdns_service(const char * service_name, const char * proto)
+    {
+        ESP_LOGI(TAG, "Query PTR: %s.%s.local", service_name, proto);
+
+        mdns_result_t * results = NULL;
+        esp_err_t err = mdns_query_ptr(service_name, proto, 3000, 20,  &results);
+        if(err){
+            ESP_LOGE(TAG, "Query Failed");
+            return;
+        }
+        if(!results){
+            ESP_LOGW(TAG, "No results found!");
+            return;
+        }
+
+        mdns_print_results(results);
+        mdns_query_results_free(results);
+    }
+
+Example of using the methods above::
+
+    void my_app_some_method(){
+        //search for {IDF_TARGET_PATH_NAME}-mdns.local
+        resolve_mdns_host("{IDF_TARGET_PATH_NAME}-mdns");
+
+        //search for HTTP servers
+        find_mdns_service("_http", "_tcp");
+        //or file servers
+        find_mdns_service("_smb", "_tcp"); //windows sharing
+        find_mdns_service("_afpovertcp", "_tcp"); //apple sharing
+        find_mdns_service("_nfs", "_tcp"); //NFS server
+        find_mdns_service("_ftp", "_tcp"); //FTP server
+        //or networked printer
+        find_mdns_service("_printer", "_tcp");
+        find_mdns_service("_ipp", "_tcp");
+    }
+
+
+Performance Optimization
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Execution Speed
+^^^^^^^^^^^^^^^
+
+ - mDNS creates a task with default low priority 1 ``CONFIG_MDNS_TASK_PRIORITY`` (If ``CONFIG_FREERTOS_UNICORE`` enabeled it pinned to CPU0 (``CONFIG_MDNS_TASK_AFFINITY``).
+ Please check `Maximizing Execution Speed <https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/performance/speed.html>`_ for more details.
+
+Minimizing RAM Usage
+^^^^^^^^^^^^^^^^^^^^
+
+- mDNS creates a tasks with stack sizes configured by ``CONFIG_MDNS_TASK_STACK_SIZE``.
+Please check `Minimizing RAM Usage <https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/performance/ram-usage.html>`_ for more details.
+
+Application Example
+-------------------
+
+mDNS server/scanner example: :example:`<../examples>`.
+
+API Reference
+-------------
+
+.. include-build-file:: inc/mdns.inc
+
+

components/mdns/docs/generate_docs

@@ -0,0 +1,28 @@
+build-docs --target esp32 --language en
+build-docs --target esp32 --language zh_CN
+
+cp -rf _build/en/esp32/html html_en
+cp -rf _build/zh_CN/esp32/html html_zh_CN
+rm -rf _build __pycache__ tee
+
+# Modifes some version and target fields of index.html
+echo "<script type="text/javascript">
+window.onload =(function() {
+    var myAnchor = document.getElementById('version-select');
+    var mySpan = document.createElement('input');
+    mySpan.setAttribute('type', 'text');
+    mySpan.setAttribute('maxLength', '10');
+    mySpan.value = 'latest';
+    mySpan.setAttribute('disabled', true);
+    myAnchor.parentNode.replaceChild(mySpan, myAnchor);
+ 
+    var myAnchor = document.getElementById('target-select');
+    var mySpan = document.createElement('input');
+    mySpan.setAttribute('type', 'text');
+    mySpan.setAttribute('maxLength', '10');
+    mySpan.value = 'all targets';
+    mySpan.setAttribute('disabled', true);
+    myAnchor.parentNode.replaceChild(mySpan, myAnchor);
+
+})();
+</script>" | tee -a html_en/index.html html_zh_CN/index.html > /dev/null

components/mdns/docs/zh_CN/conf.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+#
+# English Language RTD & Sphinx config file
+#
+# Uses ../conf_common.py for most non-language-specific settings.
+
+# Importing conf_common adds all the non-language-specific
+# parts to this conf module
+try:
+    from conf_common import *  # noqa: F403,F401
+except ImportError:
+    import os
+    import sys
+    sys.path.insert(0, os.path.abspath('..'))
+    from conf_common import *  # noqa: F403,F401
+
+import datetime
+
+current_year = datetime.datetime.now().year
+
+# General information about the project.
+project = u'ESP-IDF 编程指南'
+copyright = u'2016 - {} 乐鑫信息科技（上海）股份有限公司'.format(current_year)
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+language = 'zh_CN'

components/mdns/docs/zh_CN/index.rst

@@ -0,0 +1,189 @@
+mDNS 服务
+=========
+:link_to_translation:`en:[English]`
+
+概述
+----
+
+mDNS 是一种组播 UDP 服务，用来提供本地网络服务和主机发现。
+
+绝大多数的操作系统默认都会安装 mDNS 服务，或者提供单独的安装包。``Mac OS`` 默认会安装名为 ``Bonjour`` 的服务（该服务基于 mDNS），此外 Apple 还发布了适用于 Windows 系统的安装程序，可以在 `官方支持 <https://support.apple.com/downloads/bonjour%2520for%2520windows>`_ 找到。在 ``Linux`` 上，mDNS 服务由 `avahi <https://github.com/lathiat/avahi>`_ 提供，通常也会被默认安装。
+
+mDNS 属性
+^^^^^^^^^
+
+    * ``hostname``：设备会去响应的主机名，如果没有设置，会根据设备的网络接口名定义 ``hostname`` 。例如，``my-{IDF_TARGET_PATH_NAME}`` 会被解析为 ``my-{IDF_TARGET_PATH_NAME}.local``。
+    * ``default_instance``：默认实例名（即易记的设备名），例如 ``Jhon's {IDF_TARGET_NAME} Thing``。如果没有设置，将会使用 ``hostname``。
+
+以下为 STA 接口启动 mDNS 服务并设置 ``hostname`` 和 ``default_instance`` 的示例方法：
+
+.. highlight:: c
+
+::
+
+    void start_mdns_service()
+    {
+        // 初始化 mDNS 服务
+        esp_err_t err = mdns_init();
+        if (err) {
+            printf("MDNS Init failed: %d\n", err);
+            return;
+        }
+
+        // 设置 hostname
+        mdns_hostname_set("my-{IDF_TARGET_PATH_NAME}");
+        // 设置默认实例
+        mdns_instance_name_set("Jhon's {IDF_TARGET_NAME} Thing");
+    }
+
+mDNS 服务
+^^^^^^^^^
+
+mDNS 可以广播设备能够提供的网络服务的相关信息，每个服务会由以下属性构成。
+
+    * ``instance_name``：实例名（即易记的服务名），例如 ``Jhon's {IDF_TARGET_NAME} Web Server``。如果没有定义，会使用 ``default_instance``。
+    * ``service_type``：（必需）服务类型，以下划线为前缀，`这里 <http://www.dns-sd.org/serviceTypes.html>`_ 列出了常见的类型。
+    * ``proto``：（必需）服务运行所依赖的协议，以下划线为前缀，例如 ``_tcp`` 或者 ``_udp``。
+    * ``port``：（必需）服务运行所用的端口号。
+    * ``txt``：形如 ``{var, val}`` 的字符串数组，用于定义服务的属性。
+
+添加一些服务和不同属性的示例方法::
+
+    void add_mdns_services()
+    {
+        // 添加服务
+        mdns_service_add(NULL, "_http", "_tcp", 80, NULL, 0);
+        mdns_service_add(NULL, "_arduino", "_tcp", 3232, NULL, 0);
+        mdns_service_add(NULL, "_myservice", "_udp", 1234, NULL, 0);
+
+        // 注意：必须先添加服务，然后才能设置其属性
+        // web 服务器使用自定义的实例名
+        mdns_service_instance_name_set("_http", "_tcp", "Jhon's {IDF_TARGET_NAME} Web Server");
+
+        mdns_txt_item_t serviceTxtData[3] = {
+            {"board","{IDF_TARGET_PATH_NAME}"},
+            {"u","user"},
+            {"p","password"}
+        };
+        // 设置服务的文本数据（会释放并替换当前数据）
+        mdns_service_txt_set("_http", "_tcp", serviceTxtData, 3);
+
+        // 修改服务端口号
+        mdns_service_port_set("_myservice", "_udp", 4321);
+    }
+
+mDNS 查询
+^^^^^^^^^
+
+mDNS 提供查询服务和解析主机 IP/IPv6 地址的方法。
+
+服务查询的结果会作为 ``mdns_result_t`` 类型对象的链表返回。
+
+解析主机 IP 地址的示例方法::
+
+    void resolve_mdns_host(const char * host_name)
+    {
+        printf("Query A: %s.local", host_name);
+
+        struct ip4_addr addr;
+        addr.addr = 0;
+
+        esp_err_t err = mdns_query_a(host_name, 2000,  &addr);
+        if(err){
+            if(err == ESP_ERR_NOT_FOUND){
+                printf("Host was not found!");
+                return;
+            }
+            printf("Query Failed");
+            return;
+        }
+
+        printf(IPSTR, IP2STR(&addr));
+    }
+
+解析本地服务的示例方法::
+
+    static const char * if_str[] = {"STA", "AP", "ETH", "MAX"};
+    static const char * ip_protocol_str[] = {"V4", "V6", "MAX"};
+
+    void mdns_print_results(mdns_result_t * results){
+        mdns_result_t * r = results;
+        mdns_ip_addr_t * a = NULL;
+        int i = 1, t;
+        while(r){
+            printf("%d: Interface: %s, Type: %s\n", i++, if_str[r->tcpip_if], ip_protocol_str[r->ip_protocol]);
+            if(r->instance_name){
+                printf("  PTR : %s\n", r->instance_name);
+            }
+            if(r->hostname){
+                printf("  SRV : %s.local:%u\n", r->hostname, r->port);
+            }
+            if(r->txt_count){
+                printf("  TXT : [%u] ", r->txt_count);
+                for(t=0; t<r->txt_count; t++){
+                    printf("%s=%s; ", r->txt[t].key, r->txt[t].value);
+                }
+                printf("\n");
+            }
+            a = r->addr;
+            while(a){
+                if(a->addr.type == IPADDR_TYPE_V6){
+                    printf("  AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6));
+                } else {
+                    printf("  A   : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4)));
+                }
+                a = a->next;
+            }
+            r = r->next;
+        }
+
+    }
+
+    void find_mdns_service(const char * service_name, const char * proto)
+    {
+        ESP_LOGI(TAG, "Query PTR: %s.%s.local", service_name, proto);
+
+        mdns_result_t * results = NULL;
+        esp_err_t err = mdns_query_ptr(service_name, proto, 3000, 20,  &results);
+        if(err){
+            ESP_LOGE(TAG, "Query Failed");
+            return;
+        }
+        if(!results){
+            ESP_LOGW(TAG, "No results found!");
+            return;
+        }
+
+        mdns_print_results(results);
+        mdns_query_results_free(results);
+    }
+
+使用上述方法的示例::
+
+    void my_app_some_method(){
+        // 搜索 {IDF_TARGET_PATH_NAME}-mdns.local
+        resolve_mdns_host("{IDF_TARGET_PATH_NAME}-mdns");
+
+        // 搜索 HTTP 服务器
+        find_mdns_service("_http", "_tcp");
+        // 或者搜索文件服务器
+        find_mdns_service("_smb", "_tcp"); // Windows 系统的共享服务
+        find_mdns_service("_afpovertcp", "_tcp"); // Apple AFP 文件共享服务
+        find_mdns_service("_nfs", "_tcp"); // NFS 服务器
+        find_mdns_service("_ftp", "_tcp"); // FTP 服务器
+        // 或者网络打印机
+        find_mdns_service("_printer", "_tcp");
+        find_mdns_service("_ipp", "_tcp");
+    }
+
+应用示例
+--------
+
+有关 mDNS 服务器和查询器的应用示例请参考 :example:`<../examples>`。
+
+API 参考
+--------
+
+.. include-build-file:: inc/mdns.inc
+
+

components/mdns/examples/CMakeLists.txt

@@ -0,0 +1,10 @@
+# The following lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.5)
+
+set(EXTRA_COMPONENT_DIRS "../..")
+# This example uses an extra component for common functions such as Wi-Fi and Ethernet connection.
+list(APPEND EXTRA_COMPONENT_DIRS "../../../common_components/protocol_examples_common")
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(mdns_test)

components/mdns/examples/README.md

@@ -0,0 +1,91 @@
+# mDNS example
+
+Shows how to use mDNS to advertise lookup services and hosts
+
+## Example workflow
+
+- mDNS is initialized with host name and instance name defined through the project configuration and `_http._tcp` service is added to be advertised
+- A delegated host `esp32-delegated._local` is added and another `_http._tcp` service is added for this host.
+- WiFi STA is started and trying to connect to the access point defined through the project configuration
+- The system event handler is used to pass the network events to mDNS so the service is aware when the interface comes up or down
+- GPIO0 (BOOT Button) is initialized as pulled-up input that can be monitored for button press
+- Example task is started to check if the button is pressed so it can execute the mDNS queries defined
+
+### Configure the project
+
+* Open the project configuration menu (`idf.py menuconfig`)
+
+* Configure Wi-Fi or Ethernet under "Example Connection Configuration" menu
+* Set `mDNS Hostname` as host name prefix for the device and its instance name in `mDNS Instance Name`
+* Disable `Resolve test services` to prevent the example from querying defined names/services on startup (cause warnings in example logs, as illustrated below)
+
+### Build and Flash
+
+Build the project and flash it to the board, then run monitor tool to view serial output:
+
+```
+idf.py -p PORT flash monitor
+```
+
+- Wait for WiFi to connect to your access point
+- You can now ping the device at `[board-hostname].local`, where `[board-hostname]` is preconfigured hostname, `esp32-mdns` by default.
+- You can also browse for `_http._tcp` on the same network to find the advertised service
+- Pressing the BOOT button will start querying the local network for the predefined in `check_button` hosts and services
+- Note that for purpose of CI tests, configuration options of `MDNS_RESOLVE_TEST_SERVICES` and `MDNS_ADD_MAC_TO_HOSTNAME` are available, but disabled by default. If enabled, then the hostname suffix of last 3 bytes from device MAC address is added, e.g. `esp32-mdns-80FFFF`, and a query for test service is issued.
+
+
+(To exit the serial monitor, type ``Ctrl-]``.)
+
+See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
+
+## Example Output
+```
+I (0) cpu_start: Starting scheduler on APP CPU.
+I (276) system_api: Base MAC address is not set, read default base MAC address from BLK0 of EFUSE
+I (276) mdns-test: mdns hostname set to: [esp32-mdns]
+I (286) wifi: wifi driver task: 3ffc2fa4, prio:23, stack:3584, core=0
+I (286) wifi: wifi firmware version: a3be639
+I (286) wifi: config NVS flash: enabled
+I (296) wifi: config nano formating: disabled
+I (296) system_api: Base MAC address is not set, read default base MAC address from BLK0 of EFUSE
+I (306) system_api: Base MAC address is not set, read default base MAC address from BLK0 of EFUSE
+I (336) wifi: Init dynamic tx buffer num: 32
+I (336) wifi: Init data frame dynamic rx buffer num: 32
+I (336) wifi: Init management frame dynamic rx buffer num: 32
+I (346) wifi: Init static rx buffer size: 1600
+I (346) wifi: Init static rx buffer num: 10
+I (346) wifi: Init dynamic rx buffer num: 32
+I (356) mdns-test: Setting WiFi configuration SSID myssid...
+I (426) phy: phy_version: 4000, b6198fa, Sep  3 2018, 15:11:06, 0, 0
+I (426) wifi: mode : sta (30:ae:a4:80:FF:FF)
+I (426) gpio: GPIO[0]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
+I (1756) wifi: n:11 0, o:1 0, ap:255 255, sta:11 0, prof:1
+I (2736) wifi: state: init -> auth (b0)
+I (2756) wifi: state: auth -> assoc (0)
+I (2766) wifi: state: assoc -> run (10)
+I (2786) wifi: connected with myssid, channel 11
+I (2786) wifi: pm start, type: 1
+
+I (4786) event: sta ip: 192.168.0.139, mask: 255.255.255.0, gw: 192.168.0.2
+I (21126) mdns-test: Query A: esp32.local
+W (23176) mdns-test: ESP_ERR_NOT_FOUND: Host was not found!
+I (23176) mdns-test: Query PTR: _arduino._tcp.local
+W (26276) mdns-test: No results found!
+I (26276) mdns-test: Query PTR: _http._tcp.local
+1: Interface: STA, Type: V6
+  PTR : HP Color LaserJet MFP M277dw (7C2E10)
+  SRV : NPI7C2E10.local:80
+  A   : 254.128.0.0
+2: Interface: STA, Type: V4
+  PTR : switch4e4919
+  SRV : switch4e4919.local:80
+  TXT : [1] path=/config/authentication_page.htm;
+  A   : 192.168.0.118
+I (29396) mdns-test: Query PTR: _printer._tcp.local
+1: Interface: STA, Type: V6
+  PTR : HP Color LaserJet MFP M277dw (7C2E10)
+  SRV : NPI7C2E10.local:515
+  A   : 254.128.0.0
+2: Interface: STA, Type: V4
+  PTR : HP Color LaserJet MFP M277dw (7C2E10)
+```

components/mdns/examples/main/CMakeLists.txt

@@ -0,0 +1,2 @@
+idf_component_register(SRCS "mdns_example_main.c"
+                    INCLUDE_DIRS ".")

components/mdns/examples/main/Kconfig.projbuild

@@ -0,0 +1,55 @@
+menu "Example Configuration"
+
+    orsource "$IDF_PATH/examples/common_components/env_caps/$IDF_TARGET/Kconfig.env_caps"
+
+    config MDNS_HOSTNAME
+        string "mDNS Hostname"
+        default "esp32-mdns"
+        help
+            mDNS Hostname for example to use
+
+    config MDNS_INSTANCE
+        string "mDNS Instance Name"
+        default "ESP32 with mDNS"
+        help
+            mDNS Instance Name for example to use
+
+    config MDNS_PUBLISH_DELEGATE_HOST
+        bool "Publish a delegated host"
+        help
+            Enable publishing a delegated host other than ESP32.
+            The example will also add a mock service for this host.
+
+    config MDNS_RESOLVE_TEST_SERVICES
+        bool "Resolve test services"
+        default n
+        help
+            Enable resolving test services on startup.
+            These services are advertized and evaluated in automated tests.
+            When executed locally, these will not be resolved and warnings appear in the log.
+            Please set to false to disable initial querying to avoid warnings.
+
+    config MDNS_ADD_MAC_TO_HOSTNAME
+        bool "Add mac suffix to hostname"
+        default n
+        help
+            If enabled, a portion of MAC address is added to the hostname, this is used
+            for evaluation of tests in CI
+
+    config MDNS_BUTTON_GPIO
+        int "Button GPIO to trigger querries"
+        range ENV_GPIO_RANGE_MIN ENV_GPIO_IN_RANGE_MAX
+        default 0
+        help
+            Set the GPIO number used as mDNS test button
+
+    config MDNS_ADD_CUSTOM_NETIF
+        bool "Add user netif to mdns service"
+        default n
+        help
+            If enabled, we try to add a custom netif to mdns service.
+            Note that for using with common connection example code, we have to disable
+            all predefined interfaces in mdns component setup (since we're adding one
+            of the default interfaces)
+
+endmenu

components/mdns/examples/main/mdns_example_main.c

@@ -0,0 +1,343 @@
+/* MDNS-SD Query and advertise Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_netif_ip_addr.h"
+#include "esp_mac.h"
+#include "esp_event.h"
+#include "esp_log.h"
+#include "nvs_flash.h"
+#include "esp_netif.h"
+#include "protocol_examples_common.h"
+#include "mdns.h"
+#include "driver/gpio.h"
+#include "netdb.h"
+
+
+#define EXAMPLE_MDNS_INSTANCE CONFIG_MDNS_INSTANCE
+#define EXAMPLE_BUTTON_GPIO   CONFIG_MDNS_BUTTON_GPIO
+
+static const char * TAG = "mdns-test";
+static char * generate_hostname(void);
+
+#if CONFIG_MDNS_RESOLVE_TEST_SERVICES == 1
+static void  query_mdns_host_with_gethostbyname(char * host);
+static void  query_mdns_host_with_getaddrinfo(char * host);
+#endif
+
+static void initialise_mdns(void)
+{
+    char * hostname = generate_hostname();
+
+    //initialize mDNS
+    ESP_ERROR_CHECK( mdns_init() );
+    //set mDNS hostname (required if you want to advertise services)
+    ESP_ERROR_CHECK( mdns_hostname_set(hostname) );
+    ESP_LOGI(TAG, "mdns hostname set to: [%s]", hostname);
+    //set default mDNS instance name
+    ESP_ERROR_CHECK( mdns_instance_name_set(EXAMPLE_MDNS_INSTANCE) );
+
+    //structure with TXT records
+    mdns_txt_item_t serviceTxtData[3] = {
+        {"board", "esp32"},
+        {"u", "user"},
+        {"p", "password"}
+    };
+
+    //initialize service
+    ESP_ERROR_CHECK( mdns_service_add("ESP32-WebServer", "_http", "_tcp", 80, serviceTxtData, 3) );
+    ESP_ERROR_CHECK( mdns_service_subtype_add_for_host("ESP32-WebServer", "_http", "_tcp", NULL, "_server") );
+#if CONFIG_MDNS_MULTIPLE_INSTANCE
+    ESP_ERROR_CHECK( mdns_service_add("ESP32-WebServer1", "_http", "_tcp", 80, NULL, 0) );
+#endif
+
+#if CONFIG_MDNS_PUBLISH_DELEGATE_HOST
+    char *delegated_hostname;
+    if (-1 == asprintf(&delegated_hostname, "%s-delegated", hostname)) {
+        abort();
+    }
+
+    mdns_ip_addr_t addr4, addr6;
+    esp_netif_str_to_ip4("10.0.0.1", &addr4.addr.u_addr.ip4);
+    addr4.addr.type = ESP_IPADDR_TYPE_V4;
+    esp_netif_str_to_ip6("fd11:22::1", &addr6.addr.u_addr.ip6);
+    addr6.addr.type = ESP_IPADDR_TYPE_V6;
+    addr4.next = &addr6;
+    addr6.next = NULL;
+    ESP_ERROR_CHECK( mdns_delegate_hostname_add(delegated_hostname, &addr4) );
+    ESP_ERROR_CHECK( mdns_service_add_for_host("test0", "_http", "_tcp", delegated_hostname, 1234, serviceTxtData, 3) );
+    free(delegated_hostname);
+#endif // CONFIG_MDNS_PUBLISH_DELEGATE_HOST
+
+    //add another TXT item
+    ESP_ERROR_CHECK( mdns_service_txt_item_set("_http", "_tcp", "path", "/foobar") );
+    //change TXT item value
+    ESP_ERROR_CHECK( mdns_service_txt_item_set_with_explicit_value_len("_http", "_tcp", "u", "admin", strlen("admin")) );
+    free(hostname);
+}
+
+/* these strings match mdns_ip_protocol_t enumeration */
+static const char * ip_protocol_str[] = {"V4", "V6", "MAX"};
+
+static void mdns_print_results(mdns_result_t *results)
+{
+    mdns_result_t *r = results;
+    mdns_ip_addr_t *a = NULL;
+    int i = 1, t;
+    while (r) {
+        printf("%d: Interface: %s, Type: %s, TTL: %u\n", i++, esp_netif_get_ifkey(r->esp_netif), ip_protocol_str[r->ip_protocol],
+               r->ttl);
+        if (r->instance_name) {
+            printf("  PTR : %s.%s.%s\n", r->instance_name, r->service_type, r->proto);
+        }
+        if (r->hostname) {
+            printf("  SRV : %s.local:%u\n", r->hostname, r->port);
+        }
+        if (r->txt_count) {
+            printf("  TXT : [%zu] ", r->txt_count);
+            for (t = 0; t < r->txt_count; t++) {
+                printf("%s=%s(%d); ", r->txt[t].key, r->txt[t].value ? r->txt[t].value : "NULL", r->txt_value_len[t]);
+            }
+            printf("\n");
+        }
+        a = r->addr;
+        while (a) {
+            if (a->addr.type == ESP_IPADDR_TYPE_V6) {
+                printf("  AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6));
+            } else {
+                printf("  A   : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4)));
+            }
+            a = a->next;
+        }
+        r = r->next;
+    }
+}
+
+static void query_mdns_service(const char * service_name, const char * proto)
+{
+    ESP_LOGI(TAG, "Query PTR: %s.%s.local", service_name, proto);
+
+    mdns_result_t * results = NULL;
+    esp_err_t err = mdns_query_ptr(service_name, proto, 3000, 20,  &results);
+    if(err){
+        ESP_LOGE(TAG, "Query Failed: %s", esp_err_to_name(err));
+        return;
+    }
+    if(!results){
+        ESP_LOGW(TAG, "No results found!");
+        return;
+    }
+
+    mdns_print_results(results);
+    mdns_query_results_free(results);
+}
+
+static bool check_and_print_result(mdns_search_once_t *search)
+{
+    // Check if any result is available
+    mdns_result_t * result = NULL;
+    if (!mdns_query_async_get_results(search, 0, &result, NULL)) {
+        return false;
+    }
+
+    if (!result) {   // search timeout, but no result
+        return true;
+    }
+
+    // If yes, print the result
+    mdns_ip_addr_t * a = result->addr;
+    while (a) {
+        if(a->addr.type == ESP_IPADDR_TYPE_V6){
+            printf("  AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6));
+        } else {
+            printf("  A   : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4)));
+        }
+        a = a->next;
+    }
+    // and free the result
+    mdns_query_results_free(result);
+    return true;
+}
+
+static void query_mdns_hosts_async(const char * host_name)
+{
+    ESP_LOGI(TAG, "Query both A and AAA: %s.local", host_name);
+
+    mdns_search_once_t *s_a = mdns_query_async_new(host_name, NULL, NULL, MDNS_TYPE_A, 1000, 1, NULL);
+    mdns_search_once_t *s_aaaa = mdns_query_async_new(host_name, NULL, NULL, MDNS_TYPE_AAAA, 1000, 1, NULL);
+    while (s_a || s_aaaa) {
+        if (s_a && check_and_print_result(s_a)) {
+            ESP_LOGI(TAG, "Query A %s.local finished", host_name);
+            mdns_query_async_delete(s_a);
+            s_a = NULL;
+        }
+        if (s_aaaa && check_and_print_result(s_aaaa)) {
+            ESP_LOGI(TAG, "Query AAAA %s.local finished", host_name);
+            mdns_query_async_delete(s_aaaa);
+            s_aaaa = NULL;
+        }
+        vTaskDelay(50 / portTICK_PERIOD_MS);
+    }
+}
+
+static void query_mdns_host(const char * host_name)
+{
+    ESP_LOGI(TAG, "Query A: %s.local", host_name);
+
+    struct esp_ip4_addr addr;
+    addr.addr = 0;
+
+    esp_err_t err = mdns_query_a(host_name, 2000,  &addr);
+    if(err){
+        if(err == ESP_ERR_NOT_FOUND){
+            ESP_LOGW(TAG, "%s: Host was not found!", esp_err_to_name(err));
+            return;
+        }
+        ESP_LOGE(TAG, "Query Failed: %s", esp_err_to_name(err));
+        return;
+    }
+
+    ESP_LOGI(TAG, "Query A: %s.local resolved to: " IPSTR, host_name, IP2STR(&addr));
+}
+
+static void initialise_button(void)
+{
+    gpio_config_t io_conf = {0};
+    io_conf.intr_type = GPIO_INTR_DISABLE;
+    io_conf.pin_bit_mask = BIT64(EXAMPLE_BUTTON_GPIO);
+    io_conf.mode = GPIO_MODE_INPUT;
+    io_conf.pull_up_en = 1;
+    io_conf.pull_down_en = 0;
+    gpio_config(&io_conf);
+}
+
+static void check_button(void)
+{
+    static bool old_level = true;
+    bool new_level = gpio_get_level(EXAMPLE_BUTTON_GPIO);
+    if (!new_level && old_level) {
+        query_mdns_hosts_async("esp32-mdns");
+        query_mdns_host("esp32");
+        query_mdns_service("_arduino", "_tcp");
+        query_mdns_service("_http", "_tcp");
+        query_mdns_service("_printer", "_tcp");
+        query_mdns_service("_ipp", "_tcp");
+        query_mdns_service("_afpovertcp", "_tcp");
+        query_mdns_service("_smb", "_tcp");
+        query_mdns_service("_ftp", "_tcp");
+        query_mdns_service("_nfs", "_tcp");
+    }
+    old_level = new_level;
+}
+
+static void mdns_example_task(void *pvParameters)
+{
+#if CONFIG_MDNS_RESOLVE_TEST_SERVICES == 1
+    /* Send initial queries that are started by CI tester */
+    query_mdns_host("tinytester");
+    query_mdns_host_with_gethostbyname("tinytester-lwip.local");
+    query_mdns_host_with_getaddrinfo("tinytester-lwip.local");
+#endif
+
+    while (1) {
+        check_button();
+        vTaskDelay(50 / portTICK_PERIOD_MS);
+    }
+}
+
+void app_main(void)
+{
+    ESP_ERROR_CHECK(nvs_flash_init());
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    initialise_mdns();
+
+    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
+     * Read "Establishing Wi-Fi or Ethernet Connection" section in
+     * examples/protocols/README.md for more information about this function.
+     */
+    ESP_ERROR_CHECK(example_connect());
+
+#if defined(CONFIG_MDNS_ADD_CUSTOM_NETIF) && !defined(CONFIG_MDNS_PREDEF_NETIF_STA) && !defined(CONFIG_MDNS_PREDEF_NETIF_ETH)
+    /* Demonstration of adding a custom netif to mdns service, but we're adding the default example one,
+     * so we must disable all predefined interfaces (PREDEF_NETIF_STA, AP and ETH) first
+     */
+    ESP_ERROR_CHECK(mdns_register_netif(EXAMPLE_INTERFACE));
+    /* It is not enough to just register the interface, we have to enable is manually.
+     * This is typically performed in "GOT_IP" event handler, but we call it here directly
+     * since the `EXAMPLE_INTERFACE` netif is connected already, to keep the example simple.
+     */
+    ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_ENABLE_IP4));
+    ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_ANNOUNCE_IP4));
+#endif
+    initialise_button();
+    xTaskCreate(&mdns_example_task, "mdns_example_task", 2048, NULL, 5, NULL);
+}
+
+/** Generate host name based on sdkconfig, optionally adding a portion of MAC address to it.
+ *  @return host name string allocated from the heap
+ */
+static char* generate_hostname(void)
+{
+#ifndef CONFIG_MDNS_ADD_MAC_TO_HOSTNAME
+    return strdup(CONFIG_MDNS_HOSTNAME);
+#else
+    uint8_t mac[6];
+    char   *hostname;
+    esp_read_mac(mac, ESP_MAC_WIFI_STA);
+    if (-1 == asprintf(&hostname, "%s-%02X%02X%02X", CONFIG_MDNS_HOSTNAME, mac[3], mac[4], mac[5])) {
+        abort();
+    }
+    return hostname;
+#endif
+}
+
+#if CONFIG_MDNS_RESOLVE_TEST_SERVICES == 1
+/**
+ *  @brief Executes gethostbyname and displays list of resolved addresses.
+ *  Note: This function is used only to test advertised mdns hostnames resolution
+ */
+static void  query_mdns_host_with_gethostbyname(char * host)
+{
+    struct hostent *res = gethostbyname(host);
+    if (res) {
+        unsigned int i = 0;
+        while (res->h_addr_list[i] != NULL) {
+            ESP_LOGI(TAG, "gethostbyname: %s resolved to: %s", host, inet_ntoa(*(struct in_addr *) (res->h_addr_list[i])));
+            i++;
+        }
+    }
+}
+
+/**
+ *  @brief Executes getaddrinfo and displays list of resolved addresses.
+ *  Note: This function is used only to test advertised mdns hostnames resolution
+ */
+static void  query_mdns_host_with_getaddrinfo(char * host)
+{
+    struct addrinfo hints;
+    struct addrinfo * res;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+
+    if (!getaddrinfo(host, NULL, &hints, &res)) {
+        while (res) {
+            ESP_LOGI(TAG, "getaddrinfo: %s resolved to: %s", host,
+                     res->ai_family == AF_INET?
+                     inet_ntoa(((struct sockaddr_in *) res->ai_addr)->sin_addr):
+                     inet_ntoa(((struct sockaddr_in6 *) res->ai_addr)->sin6_addr));
+            res = res->ai_next;
+        }
+    }
+}
+#endif

components/mdns/examples/mdns_example_test.py

@@ -0,0 +1,166 @@
+import os
+import re
+import select
+import socket
+import struct
+import subprocess
+import time
+from threading import Event, Thread
+
+import dpkt
+import dpkt.dns
+import ttfw_idf
+from tiny_test_fw import DUT
+from tiny_test_fw.Utility import console_log
+
+
+def get_dns_query_for_esp(esp_host):
+    dns = dpkt.dns.DNS(b'\x00\x00\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x01')
+    dns.qd[0].name = esp_host + u'.local'
+    console_log('Created query for esp host: {} '.format(dns.__repr__()))
+    return dns.pack()
+
+
+def get_dns_answer_to_mdns(tester_host):
+    dns = dpkt.dns.DNS(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
+    dns.op = dpkt.dns.DNS_QR | dpkt.dns.DNS_AA
+    dns.rcode = dpkt.dns.DNS_RCODE_NOERR
+    arr = dpkt.dns.DNS.RR()
+    arr.cls = dpkt.dns.DNS_IN
+    arr.type = dpkt.dns.DNS_A
+    arr.name = tester_host
+    arr.ip = socket.inet_aton('127.0.0.1')
+    dns.an.append(arr)
+    console_log('Created answer to mdns query: {} '.format(dns.__repr__()))
+    return dns.pack()
+
+
+def get_dns_answer_to_mdns_lwip(tester_host, id):
+    dns = dpkt.dns.DNS(b'\x5e\x39\x84\x00\x00\x01\x00\x01\x00\x00\x00\x00\x0a\x64\x61\x76\x69\x64'
+                       b'\x2d\x63\x6f\x6d\x70\x05\x6c\x6f\x63\x61\x6c\x00\x00\x01\x00\x01\xc0\x0c'
+                       b'\x00\x01\x00\x01\x00\x00\x00\x0a\x00\x04\xc0\xa8\x0a\x6c')
+    dns.qd[0].name = tester_host
+    dns.an[0].name = tester_host
+    dns.an[0].ip = socket.inet_aton('127.0.0.1')
+    dns.an[0].rdata = socket.inet_aton('127.0.0.1')
+    dns.id = id
+    print('Created answer to mdns (lwip) query: {} '.format(dns.__repr__()))
+    return dns.pack()
+
+
+def mdns_server(esp_host, events):
+    UDP_IP = '0.0.0.0'
+    UDP_PORT = 5353
+    MCAST_GRP = '224.0.0.251'
+    TESTER_NAME = u'tinytester.local'
+    TESTER_NAME_LWIP = u'tinytester-lwip.local'
+    QUERY_TIMEOUT = 0.2
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+    sock.setblocking(False)
+    sock.bind((UDP_IP, UDP_PORT))
+    mreq = struct.pack('4sl', socket.inet_aton(MCAST_GRP), socket.INADDR_ANY)
+    sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+    last_query_timepoint = time.time()
+    while not events['stop'].is_set():
+        try:
+            current_time = time.time()
+            if current_time - last_query_timepoint > QUERY_TIMEOUT:
+                last_query_timepoint = current_time
+                if not events['esp_answered'].is_set():
+                    sock.sendto(get_dns_query_for_esp(esp_host), (MCAST_GRP, UDP_PORT))
+                if not events['esp_delegated_answered'].is_set():
+                    sock.sendto(get_dns_query_for_esp(esp_host + '-delegated'), (MCAST_GRP, UDP_PORT))
+            timeout = max(0, QUERY_TIMEOUT - (current_time - last_query_timepoint))
+            read_socks, _, _ = select.select([sock], [], [], timeout)
+            if not read_socks:
+                continue
+            data, addr = sock.recvfrom(1024)
+            dns = dpkt.dns.DNS(data)
+            if len(dns.qd) > 0 and dns.qd[0].type == dpkt.dns.DNS_A:
+                if dns.qd[0].name == TESTER_NAME:
+                    console_log('Received query: {} '.format(dns.__repr__()))
+                    sock.sendto(get_dns_answer_to_mdns(TESTER_NAME), (MCAST_GRP, UDP_PORT))
+                elif dns.qd[0].name == TESTER_NAME_LWIP:
+                    console_log('Received query: {} '.format(dns.__repr__()))
+                    sock.sendto(get_dns_answer_to_mdns_lwip(TESTER_NAME_LWIP, dns.id), addr)
+            if len(dns.an) > 0 and dns.an[0].type == dpkt.dns.DNS_A:
+                console_log('Received answer from {}'.format(dns.an[0].name))
+                if dns.an[0].name == esp_host + u'.local':
+                    console_log('Received answer to esp32-mdns query: {}'.format(dns.__repr__()))
+                    events['esp_answered'].set()
+                if dns.an[0].name == esp_host + u'-delegated.local':
+                    console_log('Received answer to esp32-mdns-delegate query: {}'.format(dns.__repr__()))
+                    events['esp_delegated_answered'].set()
+        except socket.timeout:
+            break
+        except dpkt.UnpackError:
+            continue
+
+
+def test_examples_protocol_mdns(env, config):
+    """
+    steps: |
+      1. obtain IP address + init mdns example
+      2. get the dut host name (and IP address)
+      3. check the mdns name is accessible
+      4. check DUT output if mdns advertized host is resolved
+    """
+    dut1 = env.get_dut('mdns-test', 'examples/protocols/mdns', dut_class=ttfw_idf.ESP32DUT, app_config_name=config)
+    # check and log bin size
+    binary_file = os.path.join(dut1.app.binary_path, 'mdns_test.bin')
+    bin_size = os.path.getsize(binary_file)
+    ttfw_idf.log_performance('mdns-test_bin_size', '{}KB'.format(bin_size // 1024))
+    # 1. start mdns application
+    dut1.start_app()
+    # 2. get the dut host name (and IP address)
+    specific_host = dut1.expect(re.compile(r'mdns hostname set to: \[([^\]]+)\]'), timeout=30)[0]
+
+    mdns_server_events = {'stop': Event(), 'esp_answered': Event(), 'esp_delegated_answered': Event()}
+    mdns_responder = Thread(target=mdns_server, args=(str(specific_host), mdns_server_events))
+    try:
+        ip_address = dut1.expect(re.compile(r' eth ip: ([^,]+),'), timeout=30)[0]
+        console_log('Connected to AP with IP: {}'.format(ip_address))
+    except DUT.ExpectTimeout:
+        raise ValueError('ENV_TEST_FAILURE: Cannot connect to AP')
+    try:
+        # 3. check the mdns name is accessible
+        mdns_responder.start()
+        if not mdns_server_events['esp_answered'].wait(timeout=30):
+            raise ValueError('Test has failed: did not receive mdns answer within timeout')
+        if not mdns_server_events['esp_delegated_answered'].wait(timeout=30):
+            raise ValueError('Test has failed: did not receive mdns answer for delegated host within timeout')
+        # 4. check DUT output if mdns advertized host is resolved
+        dut1.expect(re.compile(r'mdns-test: Query A: tinytester.local resolved to: 127.0.0.1'), timeout=30)
+        dut1.expect(re.compile(r'mdns-test: gethostbyname: tinytester-lwip.local resolved to: 127.0.0.1'), timeout=30)
+        dut1.expect(re.compile(r'mdns-test: getaddrinfo: tinytester-lwip.local resolved to: 127.0.0.1'), timeout=30)
+        # 5. check the DUT answers to `dig` command
+        dig_output = subprocess.check_output(['dig', '+short', '-p', '5353', '@224.0.0.251',
+                                              '{}.local'.format(specific_host)])
+        console_log('Resolving {} using "dig" succeeded with:\n{}'.format(specific_host, dig_output))
+        if not ip_address.encode('utf-8') in dig_output:
+            raise ValueError('Test has failed: Incorrectly resolved DUT hostname using dig'
+                             "Output should've contained DUT's IP address:{}".format(ip_address))
+    finally:
+        mdns_server_events['stop'].set()
+        mdns_responder.join()
+
+
+@ttfw_idf.idf_example_test(env_tag='Example_EthKitV1')
+def test_examples_protocol_mdns_default(env, _):
+    test_examples_protocol_mdns(env, 'eth_def')
+
+
+@ttfw_idf.idf_example_test(env_tag='Example_EthKitV1')
+def test_examples_protocol_mdns_socket(env, _):
+    test_examples_protocol_mdns(env, 'eth_socket')
+
+
+@ttfw_idf.idf_example_test(env_tag='Example_EthKitV1')
+def test_examples_protocol_mdns_custom_netif(env, _):
+    test_examples_protocol_mdns(env, 'eth_custom_netif')
+
+
+if __name__ == '__main__':
+    test_examples_protocol_mdns_default()

components/mdns/examples/sdkconfig.ci.eth_custom_netif

@@ -0,0 +1,19 @@
+CONFIG_IDF_TARGET="esp32"
+CONFIG_MDNS_RESOLVE_TEST_SERVICES=y
+CONFIG_MDNS_ADD_MAC_TO_HOSTNAME=y
+CONFIG_MDNS_PUBLISH_DELEGATE_HOST=y
+CONFIG_MDNS_PREDEF_NETIF_STA=n
+CONFIG_MDNS_PREDEF_NETIF_AP=n
+CONFIG_MDNS_PREDEF_NETIF_ETH=n
+CONFIG_MDNS_ADD_CUSTOM_NETIF=y
+CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y
+CONFIG_MDNS_BUTTON_GPIO=32

components/mdns/examples/sdkconfig.ci.eth_def

@@ -0,0 +1,15 @@
+CONFIG_IDF_TARGET="esp32"
+CONFIG_MDNS_RESOLVE_TEST_SERVICES=y
+CONFIG_MDNS_ADD_MAC_TO_HOSTNAME=y
+CONFIG_MDNS_PUBLISH_DELEGATE_HOST=y
+CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y
+CONFIG_MDNS_BUTTON_GPIO=32

components/mdns/examples/sdkconfig.ci.eth_socket

@@ -0,0 +1,16 @@
+CONFIG_IDF_TARGET="esp32"
+CONFIG_MDNS_RESOLVE_TEST_SERVICES=y
+CONFIG_MDNS_ADD_MAC_TO_HOSTNAME=y
+CONFIG_MDNS_PUBLISH_DELEGATE_HOST=y
+CONFIG_MDNS_NETWORKING_SOCKET=y
+CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES=y
+CONFIG_EXAMPLE_CONNECT_ETHERNET=y
+CONFIG_EXAMPLE_CONNECT_WIFI=n
+CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET=y
+CONFIG_EXAMPLE_ETH_PHY_IP101=y
+CONFIG_EXAMPLE_ETH_MDC_GPIO=23
+CONFIG_EXAMPLE_ETH_MDIO_GPIO=18
+CONFIG_EXAMPLE_ETH_PHY_RST_GPIO=5
+CONFIG_EXAMPLE_ETH_PHY_ADDR=1
+CONFIG_EXAMPLE_CONNECT_IPV6=y
+CONFIG_MDNS_BUTTON_GPIO=32

components/mdns/include/mdns.h

@@ -0,0 +1,773 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef ESP_MDNS_H_
+#define ESP_MDNS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <esp_netif.h>
+
+#define MDNS_TYPE_A                 0x0001
+#define MDNS_TYPE_PTR               0x000C
+#define MDNS_TYPE_TXT               0x0010
+#define MDNS_TYPE_AAAA              0x001C
+#define MDNS_TYPE_SRV               0x0021
+#define MDNS_TYPE_OPT               0x0029
+#define MDNS_TYPE_NSEC              0x002F
+#define MDNS_TYPE_ANY               0x00FF
+
+/**
+ * @brief   Asynchronous query handle
+ */
+typedef struct mdns_search_once_s mdns_search_once_t;
+
+
+typedef enum {
+    MDNS_EVENT_ENABLE_IP4                   = 1 << 1,
+    MDNS_EVENT_ENABLE_IP6                   = 1 << 2,
+    MDNS_EVENT_ANNOUNCE_IP4                 = 1 << 3,
+    MDNS_EVENT_ANNOUNCE_IP6                 = 1 << 4,
+    MDNS_EVENT_DISABLE_IP4                  = 1 << 5,
+    MDNS_EVENT_DISABLE_IP6                  = 1 << 6,
+} mdns_event_actions_t;
+
+/**
+ * @brief   mDNS enum to specify the ip_protocol type
+ */
+typedef enum {
+    MDNS_IP_PROTOCOL_V4,
+    MDNS_IP_PROTOCOL_V6,
+    MDNS_IP_PROTOCOL_MAX
+} mdns_ip_protocol_t;
+
+/**
+ * @brief   mDNS basic text item structure
+ *          Used in mdns_service_add()
+ */
+typedef struct {
+    const char * key;                       /*!< item key name */
+    const char * value;                     /*!< item value string */
+} mdns_txt_item_t;
+
+/**
+ * @brief   mDNS query linked list IP item
+ */
+typedef struct mdns_ip_addr_s {
+    esp_ip_addr_t addr;                     /*!< IP address */
+    struct mdns_ip_addr_s * next;           /*!< next IP, or NULL for the last IP in the list */
+} mdns_ip_addr_t;
+
+/**
+ * @brief mDNS query type to be explicitly set to either Unicast or Multicast
+ */
+typedef enum {
+    MDNS_QUERY_UNICAST,
+    MDNS_QUERY_MULTICAST,
+} mdns_query_transmission_type_t;
+
+/**
+ * @brief   mDNS query result structure
+ */
+typedef struct mdns_result_s {
+    struct mdns_result_s * next;            /*!< next result, or NULL for the last result in the list */
+
+    esp_netif_t* esp_netif;                 /*!< ptr to corresponding esp-netif */
+    uint32_t ttl;                           /*!< time to live */
+
+    mdns_ip_protocol_t ip_protocol;         /*!< ip_protocol type of the interface (v4/v6) */
+    // PTR
+    char * instance_name;                   /*!< instance name */
+    char * service_type;                    /*!< service type */
+    char * proto;                           /*!< srevice protocol */
+    // SRV
+    char * hostname;                        /*!< hostname */
+    uint16_t port;                          /*!< service port */
+    // TXT
+    mdns_txt_item_t * txt;                  /*!< txt record */
+    uint8_t *txt_value_len;                 /*!< array of txt value len of each record */
+    size_t txt_count;                       /*!< number of txt items */
+    // A and AAAA
+    mdns_ip_addr_t * addr;                  /*!< linked list of IP addresses found */
+} mdns_result_t;
+
+typedef void (*mdns_query_notify_t)(mdns_search_once_t *search);
+
+/**
+ * @brief  Initialize mDNS on given interface
+ *
+ * @return
+ *     - ESP_OK on success
+ *     - ESP_ERR_INVALID_STATE when failed to register event handler
+ *     - ESP_ERR_NO_MEM on memory error
+ *     - ESP_FAIL when failed to start mdns task
+ */
+esp_err_t mdns_init(void);
+
+/**
+ * @brief  Stop and free mDNS server
+ *
+ */
+void mdns_free(void);
+
+/**
+ * @brief  Set the hostname for mDNS server
+ *         required if you want to advertise services
+ *
+ * @param  hostname     Hostname to set
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_hostname_set(const char * hostname);
+
+/**
+ * @brief  Adds a hostname and address to be delegated
+ *         A/AAAA queries will be replied for the hostname and
+ *         services can be added to this host.
+ *
+ * @param  hostname     Hostname to add
+ * @param  address_list The IP address list of the host
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE mDNS is not running
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM memory error
+ *
+ */
+esp_err_t mdns_delegate_hostname_add(const char * hostname, const mdns_ip_addr_t *address_list);
+
+/**
+ * @brief  Remove a delegated hostname
+ *         All the services added to this host will also be removed.
+ *
+ * @param  hostname     Hostname to remove
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE mDNS is not running
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM memory error
+ *
+ */
+esp_err_t mdns_delegate_hostname_remove(const char * hostname);
+
+/**
+ * @brief  Query whether a hostname has been added
+ *
+ * @param  hostname     Hostname to query
+ *
+ * @return
+ *     - true   The hostname has been added.
+ *     - false  The hostname has not been added.
+ *
+ */
+bool mdns_hostname_exists(const char * hostname);
+
+/**
+ * @brief  Set the default instance name for mDNS server
+ *
+ * @param  instance_name     Instance name to set
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_instance_name_set(const char * instance_name);
+
+/**
+ * @brief  Add service to mDNS server
+ *
+ * @note The value length of txt items will be automatically decided by strlen
+ *
+ * @param  instance_name    instance name to set. If NULL,
+ *                          global instance name or hostname will be used.
+ *                          Note that MDNS_MULTIPLE_INSTANCE config option
+ *                          needs to be enabled for adding multiple instances
+ *                          with the same instance type.
+ * @param  service_type     service type (_http, _ftp, etc)
+ * @param  proto            service protocol (_tcp, _udp)
+ * @param  port             service port
+ * @param  txt              string array of TXT data (eg. {{"var","val"},{"other","2"}})
+ * @param  num_items        number of items in TXT data
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM memory error
+ *     - ESP_FAIL failed to add service
+ */
+esp_err_t mdns_service_add(const char * instance_name, const char * service_type, const char * proto, uint16_t port, mdns_txt_item_t txt[], size_t num_items);
+
+/**
+ * @brief  Add service to mDNS server with a delegated hostname
+ *
+ * @note The value length of txt items will be automatically decided by strlen
+ *
+ * @param  instance_name    instance name to set. If NULL,
+ *                          global instance name or hostname will be used
+ *                          Note that MDNS_MULTIPLE_INSTANCE config option
+ *                          needs to be enabled for adding multiple instances
+ *                          with the same instance type.
+ * @param  service_type     service type (_http, _ftp, etc)
+ * @param  proto            service protocol (_tcp, _udp)
+ * @param  hostname         service hostname. If NULL, local hostname will be used.
+ * @param  port             service port
+ * @param  txt              string array of TXT data (eg. {{"var","val"},{"other","2"}})
+ * @param  num_items        number of items in TXT data
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NO_MEM memory error
+ *     - ESP_FAIL failed to add service
+ */
+esp_err_t mdns_service_add_for_host(const char * instance_name, const char * service_type, const char * proto,
+                                    const char * hostname, uint16_t port, mdns_txt_item_t txt[], size_t num_items);
+
+/**
+ * @brief  Check whether a service has been added.
+ *
+ * @param  service_type     service type (_http, _ftp, etc)
+ * @param  proto            service protocol (_tcp, _udp)
+ * @param  hostname         service hostname. If NULL, checks for the local hostname.
+ *
+ * @return
+ *     - true   Correspondding service has been added.
+ *     - false  Service not found.
+ */
+bool mdns_service_exists(const char * service_type, const char * proto, const char * hostname);
+
+
+/**
+ * @brief  Check whether a service has been added.
+ *
+ * @param  instance         instance name
+ * @param  service_type     service type (_http, _ftp, etc)
+ * @param  proto            service protocol (_tcp, _udp)
+ * @param  hostname         service hostname. If NULL, checks for the local hostname.
+ *
+ * @return
+ *     - true   Correspondding service has been added.
+ *     - false  Service not found.
+ */
+bool mdns_service_exists_with_instance(const char *instance, const char *service_type, const char *proto,
+                                       const char *hostname);
+
+/**
+ * @brief  Remove service from mDNS server
+ *
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_remove(const char * service_type, const char * proto);
+
+/**
+ * @brief  Remove service from mDNS server with hostname
+ *
+ * @param  instance     instance name
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  hostname     service hostname. If NULL, local hostname will be used.
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_remove_for_host(const char *instance, const char * service_type, const char * proto, const char *hostname);
+
+/**
+ * @brief  Set instance name for service
+ *
+ * @param  service_type     service type (_http, _ftp, etc)
+ * @param  proto            service protocol (_tcp, _udp)
+ * @param  instance_name    instance name to set
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_instance_name_set(const char * service_type, const char * proto, const char * instance_name);
+
+/**
+ * @brief  Set instance name for service with hostname
+ *
+ * @param  instance_old     original instance name
+ * @param  service_type     service type (_http, _ftp, etc)
+ * @param  proto            service protocol (_tcp, _udp)
+ * @param  hostname         service hostname. If NULL, local hostname will be used.
+ * @param  instance_name    instance name to set
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_instance_name_set_for_host(const char * instance_old, const char * service_type, const char * proto, const char * hostname,
+                                                  const char * instance_name);
+
+/**
+ * @brief  Set service port
+ *
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  port         service port
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_port_set(const char * service_type, const char * proto, uint16_t port);
+
+
+/**
+ * @brief  Set service port with hostname
+ *
+ * @param  instance     instance name
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  hostname     service hostname. If NULL, local hostname will be used.
+ * @param  port         service port
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_port_set_for_host(const char * instance, const char * service_type, const char * proto, const char * hostname,
+                                         uint16_t port);
+
+/**
+ * @brief  Replace all TXT items for service
+ *
+ * @note The value length of txt items will be automatically decided by strlen
+ *
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  txt          array of TXT data (eg. {{"var","val"},{"other","2"}})
+ * @param  num_items    number of items in TXT data
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_txt_set(const char * service_type, const char * proto, mdns_txt_item_t txt[], uint8_t num_items);
+
+/**
+ * @brief  Replace all TXT items for service with hostname
+ *
+ * @note The value length of txt items will be automatically decided by strlen
+ *
+ * @param  instance     instance name
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  hostname     service hostname. If NULL, local hostname will be used.
+ * @param  txt          array of TXT data (eg. {{"var","val"},{"other","2"}})
+ * @param  num_items    number of items in TXT data
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_txt_set_for_host(const char * instance, const char * service_type, const char * proto, const char * hostname,
+                                        mdns_txt_item_t txt[], uint8_t num_items);
+
+/**
+ * @brief  Set/Add TXT item for service TXT record
+ *
+ * @note The value length will be automatically decided by strlen
+ *
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  key          the key that you want to add/update
+ * @param  value        the new value of the key
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_txt_item_set(const char * service_type, const char * proto, const char * key, const char * value);
+
+/**
+ * @brief  Set/Add TXT item for service TXT record
+ *
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  key          the key that you want to add/update
+ * @param  value        the new value of the key
+ * @param  value_len    the length of the value
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_txt_item_set_with_explicit_value_len(const char *service_type, const char *proto,
+                                                            const char *key, const char *value, uint8_t value_len);
+
+/**
+ * @brief  Set/Add TXT item for service TXT record with hostname
+ *
+ * @note The value length will be automatically decided by strlen
+ *
+ * @param  instance     instance name
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  hostname     service hostname. If NULL, local hostname will be used.
+ * @param  key          the key that you want to add/update
+ * @param  value        the new value of the key
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_txt_item_set_for_host(const char * instance, const char * service_type, const char * proto, const char * hostname,
+                                             const char * key, const char * value);
+
+/**
+ * @brief  Set/Add TXT item for service TXT record with hostname and txt value length
+ *
+ * @param  instance     instance name
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  hostname     service hostname. If NULL, local hostname will be used.
+ * @param  key          the key that you want to add/update
+ * @param  value        the new value of the key
+ * @param  value_len    the length of the value
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_txt_item_set_for_host_with_explicit_value_len(const char * instance, const char *service_type, const char *proto,
+                                                                     const char *hostname, const char *key,
+                                                                     const char *value, uint8_t value_len);
+
+/**
+ * @brief  Remove TXT item for service TXT record
+ *
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  key          the key that you want to remove
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_txt_item_remove(const char * service_type, const char * proto, const char * key);
+
+/**
+ * @brief  Remove TXT item for service TXT record with hostname
+ *
+ * @param  instance     instance name
+ * @param  service_type service type (_http, _ftp, etc)
+ * @param  proto        service protocol (_tcp, _udp)
+ * @param  hostname     service hostname. If NULL, local hostname will be used.
+ * @param  key          the key that you want to remove
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_txt_item_remove_for_host(const char * instance, const char * service_type, const char * proto, const char * hostname,
+                                                const char * key);
+
+/**
+ * @brief  Add subtype for service.
+ *
+ * @param  instance_name    instance name. If NULL, will find the first service with the same service type and protocol.
+ * @param  service_type     service type (_http, _ftp, etc)
+ * @param  proto            service protocol (_tcp, _udp)
+ * @param  hostname         service hostname. If NULL, local hostname will be used.
+ * @param  subtype          The subtype to add.
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ *     - ESP_ERR_NOT_FOUND Service not found
+ *     - ESP_ERR_NO_MEM memory error
+ */
+esp_err_t mdns_service_subtype_add_for_host(const char *instance_name, const char *service_type, const char *proto,
+                                            const char *hostname, const char *subtype);
+
+/**
+ * @brief  Remove and free all services from mDNS server
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_ARG Parameter error
+ */
+esp_err_t mdns_service_remove_all(void);
+
+/**
+ * @brief Deletes the finished query. Call this only after the search has ended!
+ *
+ * @param search pointer to search object
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  search has not finished
+ *     - ESP_ERR_INVALID_ARG    pointer to search object is NULL
+ */
+esp_err_t mdns_query_async_delete(mdns_search_once_t* search);
+
+/**
+ * @brief Get results from search pointer. Results available as a pointer to the output parameter.
+ *        Pointer to search object has to be deleted via `mdns_query_async_delete` once the query has finished.
+ *        The results although have to be freed manually.
+ *
+ * @param search pointer to search object
+ * @param timeout time in milliseconds to wait for answers
+ * @param results pointer to the results of the query
+ * @param num_results pointer to the number of the actual result items (set to NULL to ignore this return value)
+ *
+ * @return
+ *      True if search has finished before or at timeout
+ *      False if search timeout is over
+ */
+bool mdns_query_async_get_results(mdns_search_once_t* search, uint32_t timeout, mdns_result_t ** results, uint8_t * num_results);
+
+/**
+ * @brief  Query mDNS for host or service asynchronousely.
+ *         Search has to be tested for progress and deleted manually!
+ *
+ * @param  name         service instance or host name (NULL for PTR queries)
+ * @param  service_type service type (_http, _arduino, _ftp etc.) (NULL for host queries)
+ * @param  proto        service protocol (_tcp, _udp, etc.) (NULL for host queries)
+ * @param  type         type of query (MDNS_TYPE_*)
+ * @param  timeout      time in milliseconds during which mDNS query is active
+ * @param  max_results  maximum results to be collected
+ * @param  notifier     Notification function to be called when the result is ready, can be NULL
+ *
+ * @return mdns_search_once_s pointer to new search object if query initiated successfully.
+ *         NULL otherwise.
+ */
+mdns_search_once_t *mdns_query_async_new(const char *name, const char *service_type, const char *proto, uint16_t type,
+                                         uint32_t timeout, size_t max_results, mdns_query_notify_t notifier);
+
+/**
+ * @brief  Generic mDNS query
+ *         All following query methods are derived from this one
+ *
+ * @param  name         service instance or host name (NULL for PTR queries)
+ * @param  service_type service type (_http, _arduino, _ftp etc.) (NULL for host queries)
+ * @param  proto        service protocol (_tcp, _udp, etc.) (NULL for host queries)
+ * @param  type         type of query (MDNS_TYPE_*)
+ * @param  transmission_type      either Unicast query, or Multicast query
+ * @param  timeout      time in milliseconds to wait for answers.
+ * @param  max_results  maximum results to be collected
+ * @param  results      pointer to the results of the query
+ *                      results must be freed using mdns_query_results_free below
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running
+ *     - ESP_ERR_NO_MEM         memory error
+ *     - ESP_ERR_INVALID_ARG    timeout was not given
+ */
+esp_err_t mdns_query_generic(const char * name, const char * service_type, const char * proto, uint16_t type,
+                             mdns_query_transmission_type_t transmission_type, uint32_t timeout, size_t max_results, mdns_result_t ** results);
+
+/**
+ * @brief  Query mDNS for host or service
+ *
+ * Note that querying PTR types sends Multicast query, all other types send Unicast queries
+ *
+ * @param  name         service instance or host name (NULL for PTR queries)
+ * @param  service_type service type (_http, _arduino, _ftp etc.) (NULL for host queries)
+ * @param  proto        service protocol (_tcp, _udp, etc.) (NULL for host queries)
+ * @param  type         type of query (MDNS_TYPE_*)
+ * @param  timeout      time in milliseconds to wait for answers.
+ * @param  max_results  maximum results to be collected
+ * @param  results      pointer to the results of the query
+ *                      results must be freed using mdns_query_results_free below
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running
+ *     - ESP_ERR_NO_MEM         memory error
+ *     - ESP_ERR_INVALID_ARG    timeout was not given
+ */
+esp_err_t mdns_query(const char * name, const char * service_type, const char * proto, uint16_t type, uint32_t timeout, size_t max_results, mdns_result_t ** results);
+
+/**
+ * @brief  Free query results
+ *
+ * @param  results      linked list of results to be freed
+ */
+void mdns_query_results_free(mdns_result_t * results);
+
+/**
+ * @brief  Query mDNS for service
+ *
+ * @param  service_type service type (_http, _arduino, _ftp etc.)
+ * @param  proto        service protocol (_tcp, _udp, etc.)
+ * @param  timeout      time in milliseconds to wait for answer.
+ * @param  max_results  maximum results to be collected
+ * @param  results      pointer to the results of the query
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running
+ *     - ESP_ERR_NO_MEM         memory error
+ *     - ESP_ERR_INVALID_ARG    parameter error
+ */
+esp_err_t mdns_query_ptr(const char * service_type, const char * proto, uint32_t timeout, size_t max_results, mdns_result_t ** results);
+
+/**
+ * @brief  Query mDNS for SRV record
+ *
+ * @param  instance_name    service instance name
+ * @param  service_type     service type (_http, _arduino, _ftp etc.)
+ * @param  proto            service protocol (_tcp, _udp, etc.)
+ * @param  timeout          time in milliseconds to wait for answer.
+ * @param  result           pointer to the result of the query
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running
+ *     - ESP_ERR_NO_MEM         memory error
+ *     - ESP_ERR_INVALID_ARG    parameter error
+ */
+esp_err_t mdns_query_srv(const char * instance_name, const char * service_type, const char * proto, uint32_t timeout, mdns_result_t ** result);
+
+/**
+ * @brief  Query mDNS for TXT record
+ *
+ * @param  instance_name    service instance name
+ * @param  service_type     service type (_http, _arduino, _ftp etc.)
+ * @param  proto            service protocol (_tcp, _udp, etc.)
+ * @param  timeout          time in milliseconds to wait for answer.
+ * @param  result           pointer to the result of the query
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running
+ *     - ESP_ERR_NO_MEM         memory error
+ *     - ESP_ERR_INVALID_ARG    parameter error
+ */
+esp_err_t mdns_query_txt(const char * instance_name, const char * service_type, const char * proto, uint32_t timeout, mdns_result_t ** result);
+
+/**
+ * @brief  Query mDNS for A record
+ *
+ * @param  host_name    host name to look for
+ * @param  timeout      time in milliseconds to wait for answer.
+ * @param  addr         pointer to the resulting IP4 address
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running
+ *     - ESP_ERR_NO_MEM         memory error
+ *     - ESP_ERR_INVALID_ARG    parameter error
+ */
+esp_err_t mdns_query_a(const char * host_name, uint32_t timeout, esp_ip4_addr_t * addr);
+
+#if CONFIG_LWIP_IPV6
+/**
+ * @brief  Query mDNS for A record
+ *
+ * Please note that hostname must not contain domain name, as mDNS uses '.local' domain.
+ *
+ * @param  host_name    host name to look for
+ * @param  timeout      time in milliseconds to wait for answer. If 0, max_results needs to be defined
+ * @param  addr         pointer to the resulting IP6 address
+ *
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running
+ *     - ESP_ERR_NO_MEM         memory error
+ *     - ESP_ERR_INVALID_ARG    parameter error
+ */
+esp_err_t mdns_query_aaaa(const char * host_name, uint32_t timeout, esp_ip6_addr_t * addr);
+#endif
+
+
+/**
+ * @brief   Register custom esp_netif with mDNS functionality
+ *          mDNS service runs by default on preconfigured interfaces (STA, AP, ETH).
+ *          This API enables running the service on any customized interface,
+ *          either using standard WiFi or Ethernet driver or any kind of user defined driver.
+ *
+ * @param   esp_netif Pointer to esp-netif interface
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running or this netif is already registered
+ *     - ESP_ERR_NO_MEM         not enough memory for this in interface in the netif list (see CONFIG_MDNS_MAX_INTERFACES)
+ */
+esp_err_t mdns_register_netif(esp_netif_t *esp_netif);
+
+/**
+ * @brief   Unregister esp-netif already registered in mDNS service
+ *
+ * @param   esp_netif Pointer to esp-netif interface
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running
+ *     - ESP_ERR_NOT_FOUND      this esp-netif was not registered in mDNS service
+ */
+esp_err_t mdns_unregister_netif(esp_netif_t *esp_netif);
+
+/**
+ * @brief   Set esp_netif to a desired state, or perform a desired action, such as enable/disable this interface
+ *          or send announcement packets to this netif
+ *
+ *  * This function is used to enable (probe, resolve conflicts and announce), announce, or disable (send bye) mDNS
+ *  services on the specified network interface.
+ *  * This function must be called if users registers a specific interface using mdns_register_netif()
+ *  to enable mDNS services on that interface.
+ *  * This function could be used in IP/connection event handlers to automatically enable/announce mDNS services
+ *  when network properties change and/or disable them on disconnection.
+ *
+ * @param esp_netif  Pointer to esp-netif interface
+ * @param event_action  Disable/Enable/Announce on this interface over IPv4/IPv6 protocol.
+ *                      Actions enumerated in mdns_event_actions_t type.
+ * @return
+ *     - ESP_OK success
+ *     - ESP_ERR_INVALID_STATE  mDNS is not running or this netif is not registered
+ *     - ESP_ERR_NO_MEM         memory error
+ */
+esp_err_t mdns_netif_action(esp_netif_t *esp_netif, mdns_event_actions_t event_action);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ESP_MDNS_H_ */

components/mdns/include/mdns_console.h

@@ -0,0 +1,22 @@
+// 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.
+#ifndef _MDNS_CONSOLE_H_
+#define _MDNS_CONSOLE_H_
+
+/**
+ * @brief  Register MDNS functions with the console component
+ */
+void mdns_console_register(void);
+
+#endif /* _MDNS_CONSOLE_H_ */

components/mdns/mdns_networking_lwip.c

@@ -0,0 +1,370 @@
+
+/*
+ * MDNS Server Networking
+ *
+ */
+#include <string.h>
+#include "esp_log.h"
+#include "lwip/ip_addr.h"
+#include "lwip/pbuf.h"
+#include "lwip/igmp.h"
+#include "lwip/udp.h"
+#include "lwip/mld6.h"
+#include "lwip/priv/tcpip_priv.h"
+#include "esp_system.h"
+#include "esp_event.h"
+#include "mdns_networking.h"
+#include "esp_netif_net_stack.h"
+
+extern mdns_server_t * _mdns_server;
+
+/*
+ * MDNS Server Networking
+ *
+ */
+static const char *TAG = "MDNS_Networking";
+
+static struct udp_pcb * _pcb_main = NULL;
+
+static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip_addr_t *raddr, uint16_t rport);
+
+/**
+ * @brief  Low level UDP PCB Initialize
+ */
+static esp_err_t _udp_pcb_main_init(void)
+{
+    if(_pcb_main) {
+        return ESP_OK;
+    }
+    _pcb_main = udp_new();
+    if (!_pcb_main) {
+        return ESP_ERR_NO_MEM;
+    }
+    if (udp_bind(_pcb_main, IP_ANY_TYPE, MDNS_SERVICE_PORT) != 0) {
+        udp_remove(_pcb_main);
+        _pcb_main = NULL;
+        return ESP_ERR_INVALID_STATE;
+    }
+    _pcb_main->mcast_ttl = 255;
+    _pcb_main->remote_port = MDNS_SERVICE_PORT;
+    ip_addr_copy(_pcb_main->remote_ip, *(IP_ANY_TYPE));
+    udp_recv(_pcb_main, &_udp_recv, _mdns_server);
+    return ESP_OK;
+}
+
+/**
+ * @brief  Low level UDP PCB Free
+ */
+static void _udp_pcb_main_deinit(void)
+{
+    if(_pcb_main){
+        udp_recv(_pcb_main, NULL, NULL);
+        udp_disconnect(_pcb_main);
+        udp_remove(_pcb_main);
+        _pcb_main = NULL;
+    }
+}
+
+/**
+ * @brief  Low level UDP Multicast membership control
+ */
+static esp_err_t _udp_join_group(mdns_if_t if_inx, mdns_ip_protocol_t ip_protocol, bool join)
+{
+    struct netif * netif = NULL;
+    esp_netif_t *tcpip_if = _mdns_get_esp_netif(if_inx);
+
+    if (!esp_netif_is_netif_up(tcpip_if)) {
+        // Network interface went down before event propagated, skipping IGMP config
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    netif = esp_netif_get_netif_impl(tcpip_if);
+    assert(netif);
+
+    if (ip_protocol == MDNS_IP_PROTOCOL_V4) {
+        ip4_addr_t multicast_addr;
+        IP4_ADDR(&multicast_addr, 224, 0, 0, 251);
+
+        if(join){
+            if (igmp_joingroup_netif(netif, &multicast_addr)) {
+                return ESP_ERR_INVALID_STATE;
+            }
+        } else {
+            if (igmp_leavegroup_netif(netif, &multicast_addr)) {
+                return ESP_ERR_INVALID_STATE;
+            }
+        }
+    }
+#if CONFIG_LWIP_IPV6
+    else {
+        ip_addr_t multicast_addr = IPADDR6_INIT(0x000002ff, 0, 0, 0xfb000000);
+
+        if(join){
+            if (mld6_joingroup_netif(netif, &(multicast_addr.u_addr.ip6))) {
+                return ESP_ERR_INVALID_STATE;
+            }
+        } else {
+            if (mld6_leavegroup_netif(netif, &(multicast_addr.u_addr.ip6))) {
+                return ESP_ERR_INVALID_STATE;
+            }
+        }
+    }
+#endif
+    return ESP_OK;
+}
+
+/**
+ * @brief  the receive callback of the raw udp api. Packets are received here
+ *
+ */
+static void _udp_recv(void *arg, struct udp_pcb *upcb, struct pbuf *pb, const ip_addr_t *raddr, uint16_t rport)
+{
+
+    uint8_t i;
+    while (pb != NULL) {
+        struct pbuf * this_pb = pb;
+        pb = pb->next;
+        this_pb->next = NULL;
+
+        mdns_rx_packet_t * packet = (mdns_rx_packet_t *)malloc(sizeof(mdns_rx_packet_t));
+        if (!packet) {
+            HOOK_MALLOC_FAILED;
+            //missed packet - no memory
+            pbuf_free(this_pb);
+            continue;
+        }
+
+        packet->tcpip_if = MDNS_MAX_INTERFACES;
+        packet->pb = this_pb;
+        packet->src_port = rport;
+#if CONFIG_LWIP_IPV6
+        packet->src.type = raddr->type;
+        memcpy(&packet->src.u_addr, &raddr->u_addr, sizeof(raddr->u_addr));
+#else
+        packet->src.type = IPADDR_TYPE_V4;
+        memcpy(&packet->src.u_addr.ip4, &raddr->addr, sizeof(ip_addr_t));
+#endif
+        packet->dest.type = packet->src.type;
+
+        if (packet->src.type == IPADDR_TYPE_V4) {
+            packet->ip_protocol = MDNS_IP_PROTOCOL_V4;
+            struct ip_hdr * iphdr = (struct ip_hdr *)(((uint8_t *)(packet->pb->payload)) - UDP_HLEN - IP_HLEN);
+            packet->dest.u_addr.ip4.addr = iphdr->dest.addr;
+            packet->multicast = ip4_addr_ismulticast(&(packet->dest.u_addr.ip4));
+        }
+#if CONFIG_LWIP_IPV6
+        else {
+            packet->ip_protocol = MDNS_IP_PROTOCOL_V6;
+            struct ip6_hdr * ip6hdr = (struct ip6_hdr *)(((uint8_t *)(packet->pb->payload)) - UDP_HLEN - IP6_HLEN);
+            memcpy(&packet->dest.u_addr.ip6.addr, (uint8_t *)ip6hdr->dest.addr, 16);
+            packet->multicast = ip6_addr_ismulticast(&(packet->dest.u_addr.ip6));
+        }
+#endif
+
+        //lwip does not return the proper pcb if you have more than one for the same multicast address (but different interfaces)
+        struct netif * netif = NULL;
+        struct udp_pcb * pcb = NULL;
+        for (i=0; i<MDNS_MAX_INTERFACES; i++) {
+            pcb = _mdns_server->interfaces[i].pcbs[packet->ip_protocol].pcb;
+            netif = esp_netif_get_netif_impl(_mdns_get_esp_netif(i));
+            if (pcb && netif && netif == ip_current_input_netif ()) {
+                if (packet->src.type == IPADDR_TYPE_V4) {
+#if CONFIG_LWIP_IPV6
+                    if ((packet->src.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr) != (netif->ip_addr.u_addr.ip4.addr & netif->netmask.u_addr.ip4.addr)) {
+#else
+                    if ((packet->src.u_addr.ip4.addr & netif->netmask.addr) != (netif->ip_addr.addr & netif->netmask.addr)) {
+#endif                  //packet source is not in the same subnet
+                        pcb = NULL;
+                        break;
+                    }
+                }
+                packet->tcpip_if = i;
+                break;
+            }
+            pcb = NULL;
+        }
+
+        if (!pcb || !_mdns_server || !_mdns_server->action_queue
+          || _mdns_send_rx_action(packet) != ESP_OK) {
+            pbuf_free(this_pb);
+            free(packet);
+        }
+    }
+
+}
+
+/**
+ * @brief  Check if any of the interfaces is up
+ */
+static bool _udp_pcb_is_in_use(void){
+    int i, p;
+    for (i=0; i<MDNS_MAX_INTERFACES; i++) {
+        for (p=0; p<MDNS_IP_PROTOCOL_MAX; p++) {
+            if(_mdns_server->interfaces[i].pcbs[p].pcb){
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * @brief  Stop PCB Main code
+ */
+static void _udp_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+{
+    if (!_mdns_server) {
+        return;
+    }
+    mdns_pcb_t * _pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol];
+    if (_pcb->pcb) {
+        free(_pcb->probe_services);
+        _pcb->state = PCB_OFF;
+        _pcb->pcb = NULL;
+        _pcb->probe_ip = false;
+        _pcb->probe_services = NULL;
+        _pcb->probe_services_len = 0;
+        _pcb->probe_running = false;
+        _pcb->failed_probes = 0;
+        _udp_join_group(tcpip_if, ip_protocol, false);
+        if(!_udp_pcb_is_in_use()) {
+            _udp_pcb_main_deinit();
+        }
+    }
+}
+
+/**
+ * @brief  Start PCB Main code
+ */
+static esp_err_t _udp_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+{
+    if (!_mdns_server || _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t err = _udp_join_group(tcpip_if, ip_protocol, true);
+    if(err){
+        return err;
+    }
+
+    err = _udp_pcb_main_init();
+    if(err){
+        return err;
+    }
+
+    _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb = _pcb_main;
+    _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].failed_probes = 0;
+    return ESP_OK;
+}
+
+typedef struct {
+    struct tcpip_api_call_data call;
+    mdns_if_t tcpip_if;
+    mdns_ip_protocol_t ip_protocol;
+    struct pbuf *pbt;
+    const ip_addr_t *ip;
+    uint16_t port;
+    esp_err_t err;
+} mdns_api_call_t;
+
+/**
+ * @brief  Start PCB from LwIP thread
+ */
+static err_t _mdns_pcb_init_api(struct tcpip_api_call_data *api_call_msg)
+{
+    mdns_api_call_t * msg = (mdns_api_call_t *)api_call_msg;
+    msg->err = _udp_pcb_init(msg->tcpip_if, msg->ip_protocol);
+    return msg->err;
+}
+
+/**
+ * @brief  Stop PCB from LwIP thread
+ */
+static err_t _mdns_pcb_deinit_api(struct tcpip_api_call_data *api_call_msg)
+{
+    mdns_api_call_t * msg = (mdns_api_call_t *)api_call_msg;
+    _udp_pcb_deinit(msg->tcpip_if, msg->ip_protocol);
+    msg->err = ESP_OK;
+    return ESP_OK;
+}
+
+/*
+ * Non-static functions below are
+ *  - _mdns prefixed
+ *  - commented in mdns_networking.h header
+ */
+esp_err_t _mdns_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+{
+    mdns_api_call_t msg = {
+        .tcpip_if = tcpip_if,
+        .ip_protocol = ip_protocol
+    };
+    tcpip_api_call(_mdns_pcb_init_api, &msg.call);
+    return msg.err;
+}
+
+esp_err_t _mdns_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+{
+    mdns_api_call_t msg = {
+        .tcpip_if = tcpip_if,
+        .ip_protocol = ip_protocol
+    };
+    tcpip_api_call(_mdns_pcb_deinit_api, &msg.call);
+    return msg.err;
+}
+
+static err_t _mdns_udp_pcb_write_api(struct tcpip_api_call_data *api_call_msg)
+{
+    void * nif = NULL;
+    mdns_api_call_t * msg = (mdns_api_call_t *)api_call_msg;
+    mdns_pcb_t * _pcb = &_mdns_server->interfaces[msg->tcpip_if].pcbs[msg->ip_protocol];
+    nif = esp_netif_get_netif_impl(_mdns_get_esp_netif(msg->tcpip_if));
+    if (!nif) {
+        pbuf_free(msg->pbt);
+        msg->err = ERR_IF;
+        return ERR_IF;
+    }
+    esp_err_t err = udp_sendto_if (_pcb->pcb, msg->pbt, msg->ip, msg->port, (struct netif *)nif);
+    pbuf_free(msg->pbt);
+    msg->err = err;
+    return err;
+}
+
+size_t _mdns_udp_pcb_write(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, const esp_ip_addr_t *ip, uint16_t port, uint8_t * data, size_t len)
+{
+    struct pbuf* pbt = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
+    if (pbt == NULL) {
+        return 0;
+    }
+    memcpy((uint8_t *)pbt->payload, data, len);
+
+    mdns_api_call_t msg = {
+        .tcpip_if = tcpip_if,
+        .ip_protocol = ip_protocol,
+        .pbt = pbt,
+        .ip = (ip_addr_t *)ip,
+        .port = port
+    };
+    tcpip_api_call(_mdns_udp_pcb_write_api, &msg.call);
+
+    if (msg.err) {
+        return 0;
+    }
+    return len;
+}
+
+void* _mdns_get_packet_data(mdns_rx_packet_t *packet)
+{
+    return packet->pb->payload;
+}
+
+size_t _mdns_get_packet_len(mdns_rx_packet_t *packet)
+{
+    return packet->pb->len;
+}
+
+void _mdns_packet_free(mdns_rx_packet_t *packet)
+{
+    pbuf_free(packet->pb);
+    free(packet);
+}

components/mdns/mdns_networking_socket.c

@@ -0,0 +1,495 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @brief MDNS Server Networking module implemented using BSD sockets
+ */
+
+#include <string.h>
+#include "esp_event.h"
+#include "mdns_networking.h"
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/param.h>
+#include "esp_log.h"
+
+#if defined(CONFIG_IDF_TARGET_LINUX)
+#include <sys/ioctl.h>
+#include <net/if.h>
+#endif
+
+extern mdns_server_t * _mdns_server;
+
+static const char *TAG = "MDNS_Networking";
+static bool s_run_sock_recv_task = false;
+static int create_socket(esp_netif_t *netif);
+static int join_mdns_multicast_group(int sock, esp_netif_t *netif, mdns_ip_protocol_t ip_protocol);
+
+#if defined(CONFIG_IDF_TARGET_LINUX)
+// Need to define packet buffer struct on linux
+struct pbuf  {
+    struct pbuf * next;
+    void * payload;
+    size_t tot_len;
+    size_t len;
+};
+#else
+// Compatibility define to access sock-addr struct the same way for lwip and linux
+#define s6_addr32 un.u32_addr
+#endif // CONFIG_IDF_TARGET_LINUX
+
+static void delete_socket(int sock)
+{
+    close(sock);
+}
+
+static struct udp_pcb* sock_to_pcb(int sock)
+{
+    if (sock < 0) {
+        return NULL;
+    }
+    // Note: sock=0 is a valid descriptor, so save it as +1 ("1" is a valid pointer)
+    intptr_t sock_plus_one = sock + 1;
+    return (struct udp_pcb*)sock_plus_one;
+}
+
+static int pcb_to_sock(struct udp_pcb* pcb)
+{
+    if (pcb == NULL) {
+        return -1;
+    }
+    intptr_t sock_plus_one = (intptr_t)pcb;
+    return sock_plus_one - 1;
+}
+
+void* _mdns_get_packet_data(mdns_rx_packet_t *packet)
+{
+    return packet->pb->payload;
+}
+
+size_t _mdns_get_packet_len(mdns_rx_packet_t *packet)
+{
+    return packet->pb->len;
+}
+
+void _mdns_packet_free(mdns_rx_packet_t *packet)
+{
+    free(packet->pb->payload);
+    free(packet->pb);
+    free(packet);
+}
+
+esp_err_t _mdns_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+{
+    struct udp_pcb * pcb = _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb;
+    _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb = NULL;
+    if (_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].pcb == NULL &&
+        _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].pcb == NULL) {
+        // if the interface for both protocol uninitialized, close the interface socket
+        int sock = pcb_to_sock(pcb);
+        if (sock >= 0) {
+            delete_socket(sock);
+        }
+    }
+
+    for (int i=0; i<MDNS_MAX_INTERFACES; i++) {
+        for (int j=0; j<MDNS_IP_PROTOCOL_MAX; j++) {
+            if (_mdns_server->interfaces[i].pcbs[j].pcb)
+                // If any of the interfaces/protocol initialized
+                return ESP_OK;
+        }
+    }
+
+    // no interface alive, stop the rx task
+    s_run_sock_recv_task = false;
+    vTaskDelay(pdMS_TO_TICKS(500));
+    return ESP_OK;
+}
+
+#if defined(CONFIG_IDF_TARGET_LINUX)
+#ifdef CONFIG_LWIP_IPV6
+static char* inet6_ntoa_r(struct in6_addr addr, char* ptr, size_t size)
+{
+    inet_ntop(AF_INET6, &(addr.s6_addr32[0]), ptr, size);
+    return ptr;
+}
+#endif // CONFIG_LWIP_IPV6
+static char* inet_ntoa_r(struct in_addr addr, char* ptr, size_t size)
+{
+    char * res = inet_ntoa(addr);
+    if (res && strlen(res) < size) {
+        strcpy(ptr, res);
+    }
+    return res;
+}
+#endif // CONFIG_IDF_TARGET_LINUX
+
+static inline char* get_string_address(struct sockaddr_storage *source_addr)
+{
+    static char address_str[40]; // 40=(8*4+7+term) is the max size of ascii IPv6 addr "XXXX:XX...XX:XXXX"
+    char *res = NULL;
+    // Convert ip address to string
+    if (source_addr->ss_family == PF_INET) {
+        res = inet_ntoa_r(((struct sockaddr_in *)source_addr)->sin_addr, address_str, sizeof(address_str));
+    }
+#ifdef CONFIG_LWIP_IPV6
+    else if (source_addr->ss_family == PF_INET6) {
+        res = inet6_ntoa_r(((struct sockaddr_in6 *)source_addr)->sin6_addr, address_str, sizeof(address_str));
+    }
+#endif
+    if (!res) {
+        address_str[0] = '\0'; // Returns empty string if conversion didn't succeed
+    }
+    return address_str;
+}
+
+
+static inline size_t espaddr_to_inet(const esp_ip_addr_t *addr, const uint16_t port, const mdns_ip_protocol_t ip_protocol, struct sockaddr_storage *in_addr)
+{
+    size_t ss_addr_len = 0;
+    memset(in_addr, 0, sizeof(struct sockaddr_storage));
+    if (ip_protocol == MDNS_IP_PROTOCOL_V4 && addr->type == ESP_IPADDR_TYPE_V4) {
+        in_addr->ss_family = PF_INET;
+#if !defined(CONFIG_IDF_TARGET_LINUX)
+        in_addr->s2_len = sizeof(struct sockaddr_in);
+#endif
+        ss_addr_len = sizeof(struct sockaddr_in);
+        struct sockaddr_in *in_addr_ip4 = (struct sockaddr_in *) in_addr;
+        in_addr_ip4->sin_port = port;
+        in_addr_ip4->sin_addr.s_addr = addr->u_addr.ip4.addr;
+    }
+#if CONFIG_LWIP_IPV6
+    else if (ip_protocol == MDNS_IP_PROTOCOL_V6 && addr->type == ESP_IPADDR_TYPE_V6) {
+        memset(in_addr, 0, sizeof(struct sockaddr_storage));
+        in_addr->ss_family = PF_INET6;
+#if !defined(CONFIG_IDF_TARGET_LINUX)
+        in_addr->s2_len = sizeof(struct sockaddr_in6);
+#endif
+        ss_addr_len = sizeof(struct sockaddr_in6);
+        struct sockaddr_in6 * in_addr_ip6 = (struct sockaddr_in6 *)in_addr;
+        uint32_t *u32_addr = in_addr_ip6->sin6_addr.s6_addr32;
+        in_addr_ip6->sin6_port = port;
+        u32_addr[0] = addr->u_addr.ip6.addr[0];
+        u32_addr[1] = addr->u_addr.ip6.addr[1];
+        u32_addr[2] = addr->u_addr.ip6.addr[2];
+        u32_addr[3] = addr->u_addr.ip6.addr[3];
+    }
+#endif // CONFIG_LWIP_IPV6
+    return ss_addr_len;
+}
+
+size_t _mdns_udp_pcb_write(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, const esp_ip_addr_t *ip, uint16_t port, uint8_t * data, size_t len)
+{
+    int sock = pcb_to_sock(_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb);
+    if (sock < 0) {
+        return 0;
+    }
+    struct sockaddr_storage in_addr;
+    size_t ss_size = espaddr_to_inet(ip, htons(port), ip_protocol, &in_addr);
+    if (!ss_size) {
+        ESP_LOGE(TAG, "espaddr_to_inet() failed: Mismatch of IP protocols");
+        return 0;
+    }
+    ESP_LOGD(TAG, "[sock=%d]: Sending to IP %s port %d", sock, get_string_address(&in_addr), port);
+    ssize_t actual_len = sendto(sock, data, len, 0, (struct sockaddr *)&in_addr, ss_size);
+    if (actual_len < 0) {
+        ESP_LOGE(TAG, "[sock=%d]: _mdns_udp_pcb_write sendto() has failed\n errno=%d: %s", sock, errno, strerror(errno));
+    }
+    return actual_len;
+}
+
+static inline void inet_to_espaddr(const struct sockaddr_storage *in_addr, esp_ip_addr_t *addr, uint16_t *port)
+{
+    if (in_addr->ss_family == PF_INET) {
+        struct sockaddr_in * in_addr_ip4 = (struct sockaddr_in *)in_addr;
+        memset(addr, 0, sizeof(esp_ip_addr_t));
+        *port = in_addr_ip4->sin_port;
+        addr->u_addr.ip4.addr = in_addr_ip4->sin_addr.s_addr;
+        addr->type = ESP_IPADDR_TYPE_V4;
+    }
+#if CONFIG_LWIP_IPV6
+    else if (in_addr->ss_family == PF_INET6) {
+        struct sockaddr_in6 * in_addr_ip6 = (struct sockaddr_in6 *)in_addr;
+        memset(addr, 0, sizeof(esp_ip_addr_t));
+        *port = in_addr_ip6->sin6_port;
+        uint32_t *u32_addr = in_addr_ip6->sin6_addr.s6_addr32;
+        if (u32_addr[0] == 0 && u32_addr[1] == 0 && u32_addr[2] == esp_netif_htonl(0x0000FFFFUL)) {
+            // Mapped IPv4 address, convert directly to IPv4
+            addr->type = ESP_IPADDR_TYPE_V4;
+            addr->u_addr.ip4.addr = u32_addr[3];
+        } else {
+            addr->type = ESP_IPADDR_TYPE_V6;
+            addr->u_addr.ip6.addr[0] = u32_addr[0];
+            addr->u_addr.ip6.addr[1] = u32_addr[1];
+            addr->u_addr.ip6.addr[2] = u32_addr[2];
+            addr->u_addr.ip6.addr[3] = u32_addr[3];
+        }
+    }
+#endif // CONFIG_LWIP_IPV6
+}
+
+void sock_recv_task(void* arg)
+{
+    while (s_run_sock_recv_task) {
+        struct timeval tv = {
+            .tv_sec = 1,
+            .tv_usec = 0,
+        };
+        fd_set rfds;
+        FD_ZERO(&rfds);
+        int max_sock = -1;
+        for (int i=0; i<MDNS_MAX_INTERFACES; i++) {
+            for (int j=0; j<MDNS_IP_PROTOCOL_MAX; j++) {
+                int sock = pcb_to_sock(_mdns_server->interfaces[i].pcbs[j].pcb);
+                if (sock >= 0) {
+                    FD_SET(sock, &rfds);
+                    max_sock = MAX(max_sock, sock);
+                }
+            }
+        }
+        if (max_sock < 0) {
+            vTaskDelay(pdMS_TO_TICKS(1000));
+            ESP_LOGI(TAG, "No sock!");
+            continue;
+        }
+
+        int s = select(max_sock + 1, &rfds, NULL, NULL, &tv);
+        if (s < 0) {
+            ESP_LOGE(TAG, "Select failed. errno=%d: %s", errno, strerror(errno));
+            break;
+        } else if (s > 0) {
+            for (int tcpip_if=0; tcpip_if<MDNS_MAX_INTERFACES; tcpip_if++) {
+                // Both protocols share once socket
+                int sock = pcb_to_sock(_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].pcb);
+                if (sock < 0) {
+                    sock = pcb_to_sock(_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].pcb);
+                }
+                if (sock < 0) {
+                    continue;
+                }
+                if (FD_ISSET(sock, &rfds)) {
+                    static char recvbuf[MDNS_MAX_PACKET_SIZE];
+                    uint16_t port = 0;
+
+                    struct sockaddr_storage raddr; // Large enough for both IPv4 or IPv6
+                    socklen_t socklen = sizeof(struct sockaddr_storage);
+                    esp_ip_addr_t addr = {0};
+                    int len = recvfrom(sock, recvbuf, sizeof(recvbuf), 0,
+                                       (struct sockaddr *) &raddr, &socklen);
+                    if (len < 0) {
+                        ESP_LOGE(TAG, "multicast recvfrom failed. errno=%d: %s", errno, strerror(errno));
+                        break;
+                    }
+                    ESP_LOGD(TAG, "[sock=%d]: Received from IP:%s", sock, get_string_address(&raddr));
+                    ESP_LOG_BUFFER_HEXDUMP(TAG, recvbuf, len, ESP_LOG_VERBOSE);
+                    inet_to_espaddr(&raddr, &addr, &port);
+
+                    // Allocate the packet structure and pass it to the mdns main engine
+                    mdns_rx_packet_t *packet = (mdns_rx_packet_t *) calloc(1, sizeof(mdns_rx_packet_t));
+                    struct pbuf *packet_pbuf = calloc(1, sizeof(struct pbuf));
+                    uint8_t *buf = malloc(len);
+                    if (packet == NULL || packet_pbuf == NULL || buf == NULL ) {
+                        free(buf);
+                        free(packet_pbuf);
+                        free(packet);
+                        HOOK_MALLOC_FAILED;
+                        ESP_LOGE(TAG, "Failed to allocate the mdns packet");
+                        continue;
+                    }
+                    memcpy(buf, recvbuf, len);
+                    packet_pbuf->next = NULL;
+                    packet_pbuf->payload = buf;
+                    packet_pbuf->tot_len = len;
+                    packet_pbuf->len = len;
+                    packet->tcpip_if = tcpip_if;
+                    packet->pb = packet_pbuf;
+                    packet->src_port = ntohs(port);
+                    memcpy(&packet->src, &addr, sizeof(esp_ip_addr_t));
+                    // TODO(IDF-3651): Add the correct dest addr -- for mdns to decide multicast/unicast
+                    // Currently it's enough to assume the packet is multicast and mdns to check the source port of the packet
+                    memset(&packet->dest, 0, sizeof(esp_ip_addr_t));
+                    packet->multicast = 1;
+                    packet->dest.type = packet->src.type;
+                    packet->ip_protocol =
+                            packet->src.type == ESP_IPADDR_TYPE_V4 ? MDNS_IP_PROTOCOL_V4 : MDNS_IP_PROTOCOL_V6;
+                    if (!_mdns_server || !_mdns_server->action_queue || _mdns_send_rx_action(packet) != ESP_OK) {
+                        ESP_LOGE(TAG, "_mdns_send_rx_action failed!");
+                        free(packet->pb->payload);
+                        free(packet->pb);
+                        free(packet);
+                    }
+                }
+            }
+        }
+    }
+    vTaskDelete(NULL);
+}
+
+static void mdns_networking_init(void)
+{
+    if (s_run_sock_recv_task == false) {
+        s_run_sock_recv_task = true;
+        xTaskCreate( sock_recv_task, "mdns recv task", 3*1024, NULL, 5, NULL );
+    }
+}
+
+static struct udp_pcb* create_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+{
+    if (_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb) {
+        return _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb;
+    }
+    mdns_ip_protocol_t other_ip_proto = ip_protocol==MDNS_IP_PROTOCOL_V4?MDNS_IP_PROTOCOL_V6:MDNS_IP_PROTOCOL_V4;
+    esp_netif_t *netif = _mdns_get_esp_netif(tcpip_if);
+    if (_mdns_server->interfaces[tcpip_if].pcbs[other_ip_proto].pcb) {
+        struct udp_pcb* other_pcb = _mdns_server->interfaces[tcpip_if].pcbs[other_ip_proto].pcb;
+        int err = join_mdns_multicast_group(pcb_to_sock(other_pcb), netif, ip_protocol);
+        if (err < 0) {
+            ESP_LOGE(TAG, "Failed to add ipv6 multicast group for protocol %d", ip_protocol);
+            return NULL;
+        }
+        return other_pcb;
+    }
+    int sock = create_socket(netif);
+    if (sock < 0) {
+        ESP_LOGE(TAG, "Failed to create the socket!");
+        return NULL;
+    }
+    int err = join_mdns_multicast_group(sock, netif, ip_protocol);
+    if (err < 0) {
+        ESP_LOGE(TAG, "Failed to add ipv6 multicast group for protocol %d", ip_protocol);
+    }
+    return sock_to_pcb(sock);
+}
+
+esp_err_t _mdns_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol)
+{
+    ESP_LOGI(TAG, "_mdns_pcb_init(tcpip_if=%d, ip_protocol=%d)", tcpip_if, ip_protocol);
+    _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].pcb = create_pcb(tcpip_if, ip_protocol);
+    _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].failed_probes = 0;
+
+    mdns_networking_init();
+    return ESP_OK;
+}
+
+static int create_socket(esp_netif_t *netif)
+{
+#if CONFIG_LWIP_IPV6
+    int sock = socket(PF_INET6, SOCK_DGRAM, 0);
+#else
+    int sock = socket(PF_INET, SOCK_DGRAM, 0);
+#endif
+    if (sock < 0) {
+        ESP_LOGE(TAG, "Failed to create socket. errno=%d: %s", errno, strerror(errno));
+        return -1;
+    }
+
+    int on = 1;
+    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) ) < 0) {
+        ESP_LOGE(TAG, "Failed setsockopt() to set SO_REUSEADDR. errno=%d: %s\n", errno, strerror(errno));
+    }
+    // Bind the socket to any address
+#if CONFIG_LWIP_IPV6
+    struct sockaddr_in6 saddr = { INADDR_ANY };
+    saddr.sin6_family = AF_INET6;
+    saddr.sin6_port = htons(5353);
+    bzero(&saddr.sin6_addr.s6_addr, sizeof(saddr.sin6_addr.s6_addr));
+    int err = bind(sock, (struct sockaddr *)&saddr, sizeof(struct sockaddr_in6));
+    if (err < 0) {
+        ESP_LOGE(TAG, "Failed to bind socket. errno=%d: %s", errno, strerror(errno));
+        goto err;
+    }
+#else
+    struct sockaddr_in saddr = { 0 };
+    saddr.sin_family = AF_INET;
+    saddr.sin_port = htons(5353);
+    bzero(&saddr.sin_addr.s_addr, sizeof(saddr.sin_addr.s_addr));
+    int err = bind(sock, (struct sockaddr *)&saddr, sizeof(struct sockaddr_in));
+    if (err < 0) {
+        ESP_LOGE(TAG, "Failed to bind socket. errno=%d: %s", errno, strerror(errno));
+        goto err;
+    }
+#endif // CONFIG_LWIP_IPV6
+    struct ifreq ifr;
+    esp_netif_get_netif_impl_name(netif, ifr.ifr_name);
+    int ret = setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE,  (void*)&ifr, sizeof(struct ifreq));
+    if (ret < 0) {
+        ESP_LOGE(TAG, "\"%s\" Unable to bind socket to specified interface. errno=%d: %s", esp_netif_get_desc(netif), errno, strerror(errno));
+        goto err;
+    }
+
+    return sock;
+
+err:
+    close(sock);
+    return -1;
+}
+
+#if CONFIG_LWIP_IPV6
+static int socket_add_ipv6_multicast_group(int sock, esp_netif_t *netif)
+{
+    int ifindex = esp_netif_get_netif_impl_index(netif);
+    int err = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, sizeof(ifindex));
+    if (err < 0) {
+        ESP_LOGE(TAG, "Failed to set IPV6_MULTICAST_IF. errno=%d: %s", errno, strerror(errno));
+        return err;
+    }
+
+    struct ipv6_mreq v6imreq = { 0 };
+    esp_ip_addr_t multi_addr = ESP_IP6ADDR_INIT(0x000002ff, 0, 0, 0xfb000000);
+    memcpy(&v6imreq.ipv6mr_multiaddr, &multi_addr.u_addr.ip6.addr, sizeof(v6imreq.ipv6mr_multiaddr));
+    v6imreq.ipv6mr_interface = ifindex;
+    err = setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &v6imreq, sizeof(struct ipv6_mreq));
+    if (err < 0) {
+        ESP_LOGE(TAG, "Failed to set IPV6_ADD_MEMBERSHIP. errno=%d: %s", errno, strerror(errno));
+        return err;
+    }
+    return err;
+}
+#endif // CONFIG_LWIP_IPV6
+
+static int socket_add_ipv4_multicast_group(int sock, esp_netif_t *netif)
+{
+    struct ip_mreq imreq = { 0 };
+    int err = 0;
+    esp_netif_ip_info_t ip_info = { 0 };
+
+    if (esp_netif_get_ip_info(netif, &ip_info) != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to esp_netif_get_ip_info()");
+        goto err;
+    }
+    imreq.imr_interface.s_addr = ip_info.ip.addr;
+
+    esp_ip_addr_t multicast_addr = ESP_IP4ADDR_INIT(224, 0, 0, 251);
+    imreq.imr_multiaddr.s_addr = multicast_addr.u_addr.ip4.addr;
+
+    err = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &imreq, sizeof(struct ip_mreq));
+    if (err < 0) {
+        ESP_LOGE(TAG, "[sock=%d] Failed to set IP_ADD_MEMBERSHIP. errno=%d: %s", sock, errno, strerror(errno));
+        goto err;
+    }
+
+ err:
+    return err;
+}
+
+static int join_mdns_multicast_group(int sock, esp_netif_t *netif, mdns_ip_protocol_t ip_protocol)
+{
+    if (ip_protocol == MDNS_IP_PROTOCOL_V4) {
+        return socket_add_ipv4_multicast_group(sock, netif);
+    }
+#if CONFIG_LWIP_IPV6
+    if (ip_protocol == MDNS_IP_PROTOCOL_V6) {
+        return socket_add_ipv6_multicast_group(sock, netif);
+    }
+#endif // CONFIG_LWIP_IPV6
+    return -1;
+}

components/mdns/private_include/mdns_networking.h

@@ -0,0 +1,53 @@
+#ifndef ESP_MDNS_NETWORKING_H_
+#define ESP_MDNS_NETWORKING_H_
+
+/*
+ * MDNS Server Networking -- private include
+ *
+ */
+#include "mdns.h"
+#include "mdns_private.h"
+
+
+/**
+ * @brief  Queue RX packet action
+ */
+esp_err_t _mdns_send_rx_action(mdns_rx_packet_t * packet);
+
+/**
+ * @brief  Start PCB
+ */
+esp_err_t _mdns_pcb_init(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
+
+/**
+ * @brief  Stop PCB
+ */
+esp_err_t _mdns_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol);
+
+/**
+ * @brief  send packet over UDP
+ *
+ * @param  server       The server
+ * @param  data         byte array containing the packet data
+ * @param  len          length of the packet data
+ *
+ * @return length of sent packet or 0 on error
+ */
+size_t _mdns_udp_pcb_write(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, const esp_ip_addr_t *ip, uint16_t port, uint8_t * data, size_t len);
+
+/**
+ * @brief  Gets data pointer to the mDNS packet
+ */
+void* _mdns_get_packet_data(mdns_rx_packet_t *packet);
+
+/**
+ * @brief  Gets data length of c
+ */
+size_t _mdns_get_packet_len(mdns_rx_packet_t *packet);
+
+/**
+ * @brief  Free the  mDNS packet
+ */
+void _mdns_packet_free(mdns_rx_packet_t *packet);
+
+#endif /* ESP_MDNS_NETWORKING_H_ */

components/mdns/private_include/mdns_private.h

@@ -0,0 +1,493 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef MDNS_PRIVATE_H_
+#define MDNS_PRIVATE_H_
+
+#include "sdkconfig.h"
+#include "mdns.h"
+#include "esp_task.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "esp_timer.h"
+
+//#define MDNS_ENABLE_DEBUG
+
+#ifdef MDNS_ENABLE_DEBUG
+#define _mdns_dbg_printf(...) printf(__VA_ARGS__)
+#endif
+
+/** mDNS strict mode: Set this to 1 for the mDNS library to strictly follow the RFC6762:
+ * Strict features:
+ *   - to do not set original questions in response packets per RFC6762, sec 6
+ *
+ * The actual configuration is 0, i.e. non-strict mode, since some implementations,
+ * such as lwIP mdns resolver (used by standard POSIX API like getaddrinfo, gethostbyname)
+ * could not correctly resolve advertised names.
+ */
+#ifndef CONFIG_MDNS_STRICT_MODE
+#define MDNS_STRICT_MODE 0
+#else
+#define MDNS_STRICT_MODE 1
+#endif
+
+#if !MDNS_STRICT_MODE
+/* mDNS responders sometimes repeat queries in responses
+ * but according to RFC6762, sec 6: Responses MUST NOT contain
+ * any item in question field */
+#define  MDNS_REPEAT_QUERY_IN_RESPONSE 1
+#endif
+
+/** Number of predefined interfaces */
+#ifndef CONFIG_MDNS_PREDEF_NETIF_STA
+#define CONFIG_MDNS_PREDEF_NETIF_STA 0
+#endif
+#ifndef CONFIG_MDNS_PREDEF_NETIF_AP
+#define CONFIG_MDNS_PREDEF_NETIF_AP 0
+#endif
+#ifndef CONFIG_MDNS_PREDEF_NETIF_ETH
+#define CONFIG_MDNS_PREDEF_NETIF_ETH 0
+#endif
+#define MDNS_MAX_PREDEF_INTERFACES (CONFIG_MDNS_PREDEF_NETIF_STA + CONFIG_MDNS_PREDEF_NETIF_AP + CONFIG_MDNS_PREDEF_NETIF_ETH)
+
+/** Number of configured interfaces */
+#if MDNS_MAX_PREDEF_INTERFACES > CONFIG_MDNS_MAX_INTERFACES
+#warning Number of configured interfaces is less then number of predefined interfaces. Please update CONFIG_MDNS_MAX_INTERFACES.
+#define MDNS_MAX_INTERFACES (MDNS_MAX_PREDEF_INTERFACES)
+#else
+#define MDNS_MAX_INTERFACES (CONFIG_MDNS_MAX_INTERFACES)
+#endif
+
+/** The maximum number of services */
+#define MDNS_MAX_SERVICES           CONFIG_MDNS_MAX_SERVICES
+
+#define MDNS_ANSWER_PTR_TTL         4500
+#define MDNS_ANSWER_TXT_TTL         4500
+#define MDNS_ANSWER_SRV_TTL         120
+#define MDNS_ANSWER_A_TTL           120
+#define MDNS_ANSWER_AAAA_TTL        120
+
+#define MDNS_FLAGS_AUTHORITATIVE    0x8400
+#define MDNS_FLAGS_DISTRIBUTED      0x0200
+
+#define MDNS_NAME_REF               0xC000
+
+//custom type! only used by this implementation
+//to help manage service discovery handling
+#define MDNS_TYPE_SDPTR             0x0032
+
+#define MDNS_CLASS_IN               0x0001
+#define MDNS_CLASS_ANY              0x00FF
+#define MDNS_CLASS_IN_FLUSH_CACHE   0x8001
+
+#define MDNS_ANSWER_ALL             0x3F
+#define MDNS_ANSWER_PTR             0x08
+#define MDNS_ANSWER_TXT             0x04
+#define MDNS_ANSWER_SRV             0x02
+#define MDNS_ANSWER_A               0x01
+#define MDNS_ANSWER_AAAA            0x10
+#define MDNS_ANSWER_NSEC            0x20
+#define MDNS_ANSWER_SDPTR           0x80
+#define MDNS_ANSWER_AAAA_SIZE       16
+
+#define MDNS_SERVICE_PORT           5353                    // UDP port that the server runs on
+#define MDNS_SERVICE_STACK_DEPTH    CONFIG_MDNS_TASK_STACK_SIZE
+#define MDNS_TASK_PRIORITY          CONFIG_MDNS_TASK_PRIORITY
+#if (MDNS_TASK_PRIORITY > ESP_TASK_PRIO_MAX)
+#error "mDNS task priority is higher than ESP_TASK_PRIO_MAX"
+#elif (MDNS_TASK_PRIORITY > ESP_TASKD_EVENT_PRIO)
+#warning "mDNS task priority is higher than ESP_TASKD_EVENT_PRIO, mDNS library might not work correctly"
+#endif
+#define MDNS_TASK_AFFINITY          CONFIG_MDNS_TASK_AFFINITY
+#define MDNS_SERVICE_ADD_TIMEOUT_MS CONFIG_MDNS_SERVICE_ADD_TIMEOUT_MS
+
+#define MDNS_PACKET_QUEUE_LEN       16                      // Maximum packets that can be queued for parsing
+#define MDNS_ACTION_QUEUE_LEN       16                      // Maximum actions pending to the server
+#define MDNS_TXT_MAX_LEN            1024                    // Maximum string length of text data in TXT record
+#define MDNS_NAME_MAX_LEN           64                      // Maximum string length of hostname, instance, service and proto
+#define MDNS_NAME_BUF_LEN           (MDNS_NAME_MAX_LEN+1)   // Maximum char buffer size to hold hostname, instance, service or proto
+#define MDNS_MAX_PACKET_SIZE        1460                    // Maximum size of mDNS  outgoing packet
+
+#define MDNS_HEAD_LEN               12
+#define MDNS_HEAD_ID_OFFSET         0
+#define MDNS_HEAD_FLAGS_OFFSET      2
+#define MDNS_HEAD_QUESTIONS_OFFSET  4
+#define MDNS_HEAD_ANSWERS_OFFSET    6
+#define MDNS_HEAD_SERVERS_OFFSET    8
+#define MDNS_HEAD_ADDITIONAL_OFFSET 10
+
+#define MDNS_TYPE_OFFSET            0
+#define MDNS_CLASS_OFFSET           2
+#define MDNS_TTL_OFFSET             4
+#define MDNS_LEN_OFFSET             8
+#define MDNS_DATA_OFFSET            10
+
+#define MDNS_SRV_PRIORITY_OFFSET    0
+#define MDNS_SRV_WEIGHT_OFFSET      2
+#define MDNS_SRV_PORT_OFFSET        4
+#define MDNS_SRV_FQDN_OFFSET        6
+
+#define MDNS_TIMER_PERIOD_US        (CONFIG_MDNS_TIMER_PERIOD_MS*1000)
+
+#define MDNS_SERVICE_LOCK()     xSemaphoreTake(_mdns_service_semaphore, portMAX_DELAY)
+#define MDNS_SERVICE_UNLOCK()   xSemaphoreGive(_mdns_service_semaphore)
+
+#define queueToEnd(type, queue, item)       \
+    if (!queue) {                           \
+        queue = item;                       \
+    } else {                                \
+        type * _q = queue;                  \
+        while (_q->next) { _q = _q->next; } \
+        _q->next = item;                    \
+    }
+
+#define queueDetach(type, queue, item)              \
+    if (queue) {                                    \
+        if (queue == item) {                        \
+            queue = queue->next;                    \
+        } else {                                    \
+            type * _q = queue;                      \
+            while (_q->next && _q->next != item) {  \
+                _q = _q->next;                      \
+            }                                       \
+            if (_q->next == item) {                 \
+                _q->next = item->next;              \
+                item->next = NULL;                  \
+            }                                       \
+        }                                           \
+    }
+
+#define queueFree(type, queue)  while (queue) { type * _q = queue; queue = queue->next; free(_q); }
+
+#define PCB_STATE_IS_PROBING(s) (s->state > PCB_OFF && s->state < PCB_ANNOUNCE_1)
+#define PCB_STATE_IS_ANNOUNCING(s) (s->state > PCB_PROBE_3 && s->state < PCB_RUNNING)
+#define PCB_STATE_IS_RUNNING(s) (s->state == PCB_RUNNING)
+
+#ifndef HOOK_MALLOC_FAILED
+#define HOOK_MALLOC_FAILED  ESP_LOGE(TAG, "Cannot allocate memory (line: %d, free heap: %d bytes)", __LINE__, esp_get_free_heap_size());
+#endif
+
+typedef size_t mdns_if_t;
+
+typedef enum {
+    PCB_OFF, PCB_DUP, PCB_INIT,
+    PCB_PROBE_1, PCB_PROBE_2, PCB_PROBE_3,
+    PCB_ANNOUNCE_1, PCB_ANNOUNCE_2, PCB_ANNOUNCE_3,
+    PCB_RUNNING
+} mdns_pcb_state_t;
+
+typedef enum {
+    MDNS_ANSWER, MDNS_NS, MDNS_EXTRA
+} mdns_parsed_record_type_t;
+
+typedef enum {
+    ACTION_SYSTEM_EVENT,
+    ACTION_HOSTNAME_SET,
+    ACTION_INSTANCE_SET,
+    ACTION_SERVICE_ADD,
+    ACTION_SERVICE_DEL,
+    ACTION_SERVICE_INSTANCE_SET,
+    ACTION_SERVICE_PORT_SET,
+    ACTION_SERVICE_TXT_REPLACE,
+    ACTION_SERVICE_TXT_SET,
+    ACTION_SERVICE_TXT_DEL,
+    ACTION_SERVICE_SUBTYPE_ADD,
+    ACTION_SERVICES_CLEAR,
+    ACTION_SEARCH_ADD,
+    ACTION_SEARCH_SEND,
+    ACTION_SEARCH_END,
+    ACTION_TX_HANDLE,
+    ACTION_RX_HANDLE,
+    ACTION_TASK_STOP,
+    ACTION_DELEGATE_HOSTNAME_ADD,
+    ACTION_DELEGATE_HOSTNAME_REMOVE,
+    ACTION_MAX
+} mdns_action_type_t;
+
+
+typedef struct {
+    uint16_t id;
+    union {
+        struct {
+            uint16_t qr :1;
+            uint16_t opCode :4;
+            uint16_t aa :1;
+            uint16_t tc :1;
+            uint16_t rd :1;
+            uint16_t ra :1;
+            uint16_t z :1;
+            uint16_t ad :1;
+            uint16_t cd :1;
+            uint16_t rCode :4;//response/error code
+        };
+        uint16_t value;
+    } flags;
+    uint16_t questions; //QDCOUNT
+    uint16_t answers;   //ANCOUNT
+    uint16_t servers;   //NSCOUNT
+    uint16_t additional;//ARCOUNT
+} mdns_header_t;
+
+typedef struct {
+    char host[MDNS_NAME_BUF_LEN]; // hostname for A/AAAA records, instance name for SRV records
+    char service[MDNS_NAME_BUF_LEN];
+    char proto[MDNS_NAME_BUF_LEN];
+    char domain[MDNS_NAME_BUF_LEN];
+    uint8_t parts;
+    uint8_t sub;
+    bool    invalid;
+} mdns_name_t;
+
+typedef struct mdns_parsed_question_s {
+    struct mdns_parsed_question_s * next;
+    uint16_t type;
+    bool sub;
+    bool unicast;
+    char * host;
+    char * service;
+    char * proto;
+    char * domain;
+} mdns_parsed_question_t;
+
+typedef struct mdns_parsed_record_s {
+    struct mdns_parsed_record_s * next;
+    mdns_parsed_record_type_t record_type;
+    uint16_t type;
+    uint16_t clas;
+    uint8_t flush;
+    uint32_t ttl;
+    char * host;
+    char * service;
+    char * proto;
+    char * domain;
+    uint16_t data_len;
+    uint8_t *data;
+} mdns_parsed_record_t;
+
+typedef struct {
+    mdns_if_t tcpip_if;
+    mdns_ip_protocol_t ip_protocol;
+    esp_ip_addr_t src;
+    uint16_t src_port;
+    uint8_t multicast;
+    uint8_t authoritative;
+    uint8_t probe;
+    uint8_t discovery;
+    uint8_t distributed;
+    mdns_parsed_question_t * questions;
+    mdns_parsed_record_t * records;
+    uint16_t id;
+} mdns_parsed_packet_t;
+
+typedef struct {
+    mdns_if_t tcpip_if;
+    mdns_ip_protocol_t ip_protocol;
+    struct pbuf *pb;
+    esp_ip_addr_t src;
+    esp_ip_addr_t dest;
+    uint16_t src_port;
+    uint8_t multicast;
+} mdns_rx_packet_t;
+
+typedef struct mdns_txt_linked_item_s {
+    const char * key;                       /*!< item key name */
+    char * value;                           /*!< item value string */
+    uint8_t value_len;                      /*!< item value length */
+    struct mdns_txt_linked_item_s * next;   /*!< next result, or NULL for the last result in the list */
+} mdns_txt_linked_item_t;
+
+typedef struct mdns_subtype_s {
+    const char *subtype;                    /*!< subtype */
+    struct mdns_subtype_s * next;           /*!< next result, or NULL for the last result in the list */
+} mdns_subtype_t;
+
+typedef struct {
+    const char * instance;
+    const char * service;
+    const char * proto;
+    const char * hostname;
+    uint16_t priority;
+    uint16_t weight;
+    uint16_t port;
+    mdns_txt_linked_item_t * txt;
+    mdns_subtype_t *subtype;
+} mdns_service_t;
+
+typedef struct mdns_srv_item_s {
+    struct mdns_srv_item_s * next;
+    mdns_service_t * service;
+} mdns_srv_item_t;
+
+typedef struct mdns_out_question_s {
+    struct mdns_out_question_s * next;
+    uint16_t type;
+    bool unicast;
+    const char * host;
+    const char * service;
+    const char * proto;
+    const char * domain;
+    bool own_dynamic_memory;
+} mdns_out_question_t;
+
+typedef struct mdns_host_item_t {
+    const char * hostname;
+    mdns_ip_addr_t *address_list;
+    struct mdns_host_item_t *next;
+} mdns_host_item_t;
+
+typedef struct mdns_out_answer_s {
+    struct mdns_out_answer_s * next;
+    uint16_t type;
+    uint8_t bye;
+    uint8_t flush;
+    mdns_service_t * service;
+    mdns_host_item_t* host;
+    const char * custom_instance;
+    const char * custom_service;
+    const char * custom_proto;
+} mdns_out_answer_t;
+
+typedef struct mdns_tx_packet_s {
+    struct mdns_tx_packet_s * next;
+    uint32_t send_at;
+    mdns_if_t tcpip_if;
+    mdns_ip_protocol_t ip_protocol;
+    esp_ip_addr_t dst;
+    uint16_t port;
+    uint16_t flags;
+    uint8_t distributed;
+    mdns_out_question_t * questions;
+    mdns_out_answer_t * answers;
+    mdns_out_answer_t * servers;
+    mdns_out_answer_t * additional;
+    bool queued;
+    uint16_t id;
+} mdns_tx_packet_t;
+
+typedef struct {
+    mdns_pcb_state_t state;
+    struct udp_pcb * pcb;
+    mdns_srv_item_t ** probe_services;
+    uint8_t probe_services_len;
+    uint8_t probe_ip;
+    uint8_t probe_running;
+    uint16_t failed_probes;
+} mdns_pcb_t;
+
+typedef enum {
+    SEARCH_OFF,
+    SEARCH_INIT,
+    SEARCH_RUNNING,
+    SEARCH_MAX
+} mdns_search_once_state_t;
+
+typedef struct mdns_search_once_s {
+    struct mdns_search_once_s * next;
+
+    mdns_search_once_state_t state;
+    uint32_t started_at;
+    uint32_t sent_at;
+    uint32_t timeout;
+    mdns_query_notify_t notifier;
+    SemaphoreHandle_t done_semaphore;
+    uint16_t type;
+    bool unicast;
+    uint8_t max_results;
+    uint8_t num_results;
+    char * instance;
+    char * service;
+    char * proto;
+    mdns_result_t * result;
+} mdns_search_once_t;
+
+typedef struct mdns_server_s {
+    struct {
+        mdns_pcb_t pcbs[MDNS_IP_PROTOCOL_MAX];
+    } interfaces[MDNS_MAX_INTERFACES];
+    const char * hostname;
+    const char * instance;
+    mdns_srv_item_t * services;
+    SemaphoreHandle_t lock;
+    QueueHandle_t action_queue;
+    mdns_tx_packet_t * tx_queue_head;
+    mdns_search_once_t * search_once;
+    esp_timer_handle_t timer_handle;
+} mdns_server_t;
+
+typedef struct {
+    mdns_action_type_t type;
+    union {
+        struct {
+            char * hostname;
+            TaskHandle_t calling_task;
+        } hostname_set;
+        char * instance;
+        struct {
+            mdns_if_t interface;
+            mdns_event_actions_t event_action;
+        } sys_event;
+        struct {
+            mdns_srv_item_t * service;
+        } srv_add;
+        struct {
+            mdns_srv_item_t * service;
+        } srv_del;
+        struct {
+            mdns_srv_item_t * service;
+            char * instance;
+        } srv_instance;
+        struct {
+            mdns_srv_item_t * service;
+            uint16_t port;
+        } srv_port;
+        struct {
+            mdns_srv_item_t * service;
+            mdns_txt_linked_item_t * txt;
+        } srv_txt_replace;
+        struct {
+            mdns_srv_item_t * service;
+            char * key;
+            char * value;
+            uint8_t value_len;
+        } srv_txt_set;
+        struct {
+            mdns_srv_item_t * service;
+            char * key;
+        } srv_txt_del;
+        struct {
+            mdns_srv_item_t * service;
+            char * subtype;
+        } srv_subtype_add;
+        struct {
+            mdns_search_once_t * search;
+        } search_add;
+        struct {
+            mdns_tx_packet_t * packet;
+        } tx_handle;
+        struct {
+            mdns_rx_packet_t * packet;
+        } rx_handle;
+        struct {
+            const char * hostname;
+            mdns_ip_addr_t *address_list;
+        } delegate_hostname;
+    } data;
+} mdns_action_t;
+
+/*
+ * @brief  Convert mnds if to esp-netif handle
+ *
+ * @param  tcpip_if     mdns supported interface as internal enum
+ *
+ * @return
+ *     - ptr to esp-netif on success
+ *     - NULL if no available netif for current interface index
+ */
+esp_netif_t *_mdns_get_esp_netif(mdns_if_t tcpip_if);
+
+
+#endif /* MDNS_PRIVATE_H_ */

components/mdns/tests/host_test/CMakeLists.txt

@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+set(COMPONENTS main)
+project(mdns_host)

components/mdns/tests/host_test/README.md

@@ -0,0 +1,25 @@
+# Setup dummy network interfaces
+```
+sudo ip link add eth2 type dummy
+sudo ip addr add 192.168.1.200/24 dev eth2
+sudo ip link set eth2 up
+sudo ifconfig eth2 multicast
+```
+
+# Dig on a specified interface
+
+```
+dig +short -b 192.168.1.200 -p 5353 @224.0.0.251 myesp.local
+```
+
+# Run avahi to browse services
+
+Avahi needs the netif to have the "multicast" flag set
+
+```bash
+david@david-comp:~/esp/idf (feature/mdns_networking_socket)$ avahi-browse -a -r -p
++;eth2;IPv6;myesp-service2;Web Site;local
++;eth2;IPv4;myesp-service2;Web Site;local
+=;eth2;IPv6;myesp-service2;Web Site;local;myesp.local;192.168.1.200;80;"board=esp32" "u=user" "p=password"
+=;eth2;IPv4;myesp-service2;Web Site;local;myesp.local;192.168.1.200;80;"board=esp32" "u=user" "p=password"
+```

components/mdns/tests/host_test/components/esp_event_mock/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRCS esp_event_mock.c
+                       INCLUDE_DIRS include
+                       REQUIRES esp_system_protocols_linux)

components/mdns/tests/host_test/components/esp_event_mock/esp_event_mock.c

@@ -0,0 +1,29 @@
+// Copyright 2021 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 "esp_err.h"
+#include "esp_event.h"
+
+const char * WIFI_EVENT = "WIFI_EVENT";
+const char * IP_EVENT = "IP_EVENT";
+
+esp_err_t esp_event_handler_register(const char * event_base, int32_t event_id, void* event_handler, void* event_handler_arg)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_event_handler_unregister(const char * event_base, int32_t event_id, void* event_handler)
+{
+    return ESP_OK;
+}

components/mdns/tests/host_test/components/esp_event_mock/include/esp_event.h

@@ -0,0 +1,32 @@
+// Copyright 2021 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.
+#pragma once
+
+#include "stdbool.h"
+#include "esp_err.h"
+#include "esp_event_base.h"
+#include "bsd_strings.h"
+
+#define ESP_EVENT_DECLARE_BASE(x)
+#define ESP_EVENT_ANY_ID       (-1)
+
+typedef void * esp_event_base_t;
+typedef void * system_event_t;
+
+const char* WIFI_EVENT;
+const char* IP_EVENT;
+
+esp_err_t esp_event_handler_register(const char * event_base, int32_t event_id, void* event_handler, void* event_handler_arg);
+
+esp_err_t esp_event_handler_unregister(const char * event_base, int32_t event_id, void* event_handler);

components/mdns/tests/host_test/components/esp_event_mock/include/esp_event_base.h

@@ -0,0 +1,21 @@
+// Copyright 2021 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.
+#pragma once
+
+typedef enum {
+    WIFI_EVENT_STA_CONNECTED,            /**< ESP32 station connected to AP */
+    WIFI_EVENT_STA_DISCONNECTED,         /**< ESP32 station disconnected from AP */
+    WIFI_EVENT_AP_START,                 /**< ESP32 soft-AP start */
+    WIFI_EVENT_AP_STOP,                  /**< ESP32 soft-AP stop */
+} mdns_used_event_t;

components/mdns/tests/host_test/components/esp_netif_linux/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRCS esp_netif_linux.c
+                       INCLUDE_DIRS include
+                       REQUIRES esp_system_protocols_linux)

components/mdns/tests/host_test/components/esp_netif_linux/Kconfig

@@ -0,0 +1,9 @@
+menu "LWIP-MOCK-CONFIG"
+
+    config LWIP_IPV6
+        bool "Enable IPv6"
+        default y
+        help
+            Enable/disable IPv6
+
+endmenu

components/mdns/tests/host_test/components/esp_netif_linux/esp_netif_linux.c

@@ -0,0 +1,163 @@
+// Copyright 2021 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<stdio.h>
+#include <stdlib.h>
+
+#include "esp_netif.h"
+#include "esp_err.h"
+#include <string.h>	//strlen
+#include <sys/socket.h>
+#include <arpa/inet.h>	//inet_addr
+#include <sys/types.h>
+#include <ifaddrs.h>
+#include <net/if.h>
+#include "esp_netif_types.h"
+
+#define MAX_NETIFS  4
+
+static esp_netif_t* s_netif_list[MAX_NETIFS] = { 0 };
+
+struct esp_netif_obj
+{
+    const char *if_key;
+    const char *if_desc;
+};
+
+esp_netif_t *esp_netif_get_handle_from_ifkey(const char *if_key)
+{
+    for (int i=0; i<MAX_NETIFS; ++i) {
+        if (s_netif_list[i] && strcmp(s_netif_list[i]->if_key, if_key) == 0) {
+            return s_netif_list[i];
+        }
+    }
+    return NULL;
+}
+
+esp_err_t esp_netif_get_ip_info(esp_netif_t *esp_netif, esp_netif_ip_info_t *ip_info)
+{
+    if (esp_netif == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    struct ifaddrs *addrs, *tmp;
+    getifaddrs(&addrs);
+    tmp = addrs;
+
+    while (tmp) {
+        if (tmp->ifa_addr && tmp->ifa_addr->sa_family == AF_INET) {
+            char addr[20];
+            struct sockaddr_in *pAddr = (struct sockaddr_in *) tmp->ifa_addr;
+            inet_ntop(AF_INET, &pAddr->sin_addr, addr, sizeof(addr) );
+            if (strcmp(esp_netif->if_desc, tmp->ifa_name) == 0) {
+                printf("AF_INET: %s: %s\n", tmp->ifa_name, addr);
+                memcpy(&ip_info->ip.addr, &pAddr->sin_addr, 4);
+                break;
+            }
+        }
+        tmp = tmp->ifa_next;
+    }
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_dhcpc_get_status(esp_netif_t *esp_netif, esp_netif_dhcp_status_t *status)
+{
+    return ESP_OK;
+}
+
+
+esp_err_t esp_netif_get_ip6_linklocal(esp_netif_t *esp_netif, esp_ip6_addr_t *if_ip6)
+{
+    if (esp_netif == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    struct ifaddrs *addrs, *tmp;
+    getifaddrs(&addrs);
+    tmp = addrs;
+
+    while (tmp)
+    {
+        if (tmp->ifa_addr && tmp->ifa_addr->sa_family == AF_INET6) {
+            char addr[64];
+            struct sockaddr_in6 *pAddr = (struct sockaddr_in6 *)tmp->ifa_addr;
+            inet_ntop(AF_INET6, &pAddr->sin6_addr, addr, sizeof(addr) );
+            if (strcmp(esp_netif->if_desc, tmp->ifa_name) == 0) {
+                printf("AF_INET6: %s: %s\n", tmp->ifa_name, addr);
+                memcpy(if_ip6->addr, &pAddr->sin6_addr, 4*4);
+                break;
+            }
+        }
+        tmp = tmp->ifa_next;
+    }
+
+    freeifaddrs(addrs);
+    return ESP_OK;
+}
+
+
+int esp_netif_get_netif_impl_index(esp_netif_t *esp_netif)
+{
+    if (esp_netif == NULL) {
+        return -1;
+    }
+    uint32_t interfaceIndex = if_nametoindex(esp_netif->if_desc);
+    return interfaceIndex;
+}
+
+esp_err_t esp_netif_get_netif_impl_name(esp_netif_t *esp_netif, char* name)
+{
+    if (esp_netif == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    strcpy(name, esp_netif->if_desc);
+    return ESP_OK;
+}
+
+const char *esp_netif_get_desc(esp_netif_t *esp_netif)
+{
+    if (esp_netif == NULL) {
+        return NULL;
+    }
+    return esp_netif->if_desc;
+}
+
+esp_netif_t *esp_netif_new(const esp_netif_config_t *config)
+{
+    if (esp_netif_get_handle_from_ifkey(config->base->if_key)) {
+        return NULL;
+    }
+    esp_netif_t* netif = calloc(1, sizeof(struct esp_netif_obj));
+    if (netif) {
+        netif->if_desc = config->base->if_desc;
+        netif->if_key = config->base->if_key;
+    }
+
+    for (int i=0; i<MAX_NETIFS; ++i) {
+        if (s_netif_list[i] == NULL) {
+            s_netif_list[i] = netif;
+            break;
+        }
+    }
+
+    return netif;
+}
+
+void esp_netif_destroy(esp_netif_t *esp_netif)
+{
+    for (int i=0; i<MAX_NETIFS; ++i) {
+        if (s_netif_list[i] == esp_netif) {
+            s_netif_list[i] = NULL;
+            break;
+        }
+    }
+    free(esp_netif);
+}

components/mdns/tests/host_test/components/esp_netif_linux/include/esp_wifi_types.h

@@ -0,0 +1,15 @@
+// Copyright 2021 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.
+#pragma once
+#include "esp_event.h"

components/mdns/tests/host_test/components/esp_system_protocols_linux/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRCS esp_log_impl.c strlcat.c
+                       INCLUDE_DIRS include
+                       REQUIRES esp_netif_linux esp_timer_linux freertos_linux esp_event_mock esp_netif log esp_common)

components/mdns/tests/host_test/components/esp_system_protocols_linux/esp_log_impl.c

@@ -0,0 +1,35 @@
+// Copyright 2021 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 "esp_err.h"
+#include "esp_log.h"
+#include <stdlib.h>
+
+void _esp_error_check_failed(esp_err_t rc, const char *file, int line, const char *function, const char *expression)
+{
+    ESP_LOGE("ESP_ERROR_CHECK", "Failed with esp_err_t: 0x%x", rc);
+    ESP_LOGE("ESP_ERROR_CHECK", "Expression: %s", expression);
+    ESP_LOGE("ESP_ERROR_CHECK", "Functions: %s %s(%d)", function, file, line);
+    abort();
+}
+
+void esp_log_buffer_hexdump_internal(const char *tag, const void *buffer, uint16_t buff_len, esp_log_level_t log_level)
+{
+    if ( LOG_LOCAL_LEVEL >= log_level ) {
+        ESP_LOG_LEVEL(log_level, tag, "Buffer:%p length:%d", buffer, buff_len);
+        for (int i=0; i<buff_len; ++i) {
+            printf("%02x ", ((uint8_t*)buffer)[i]);
+        }
+        printf("\n");
+    }
+}

components/mdns/tests/host_test/components/esp_system_protocols_linux/include/bsd_strings.h

@@ -0,0 +1,16 @@
+// Copyright 2021 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.
+#pragma once
+
+size_t strlcat(char *dest, const char *src, size_t size);

components/mdns/tests/host_test/components/esp_system_protocols_linux/include/machine/endian.h

@@ -0,0 +1,16 @@
+// Copyright 2021 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.
+#pragma once
+
+#include_next "endian.h"

components/mdns/tests/host_test/components/esp_system_protocols_linux/strlcat.c

@@ -0,0 +1,68 @@
+/*	$OpenBSD: strlcat.c,v 1.2 1999/06/17 16:28:58 millert Exp $	*/
+
+/*-
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "string.h"
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+size_t
+strlcat(dst, src, siz)
+        char *dst;
+        const char *src;
+        size_t siz;
+{
+    char *d = dst;
+    const char *s = src;
+    size_t n = siz;
+    size_t dlen;
+
+    /* Find the end of dst and adjust bytes left but don't go past end */
+    while (n-- != 0 && *d != '\0')
+        d++;
+    dlen = d - dst;
+    n = siz - dlen;
+
+    if (n == 0)
+        return(dlen + strlen(s));
+    while (*s != '\0') {
+        if (n != 1) {
+            *d++ = *s;
+            n--;
+        }
+        s++;
+    }
+    *d = '\0';
+
+    return(dlen + (s - src));	/* count does not include NUL */
+}

components/mdns/tests/host_test/components/esp_timer_linux/CMakeLists.txt

@@ -0,0 +1,9 @@
+idf_component_register(SRCS esp_timer_linux.c timer_task.cpp
+                       INCLUDE_DIRS include
+                       REQUIRES esp_system_protocols_linux freertos_linux)
+
+set_target_properties(${COMPONENT_LIB} PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED ON
+    CXX_EXTENSIONS ON
+)

components/mdns/tests/host_test/components/esp_timer_linux/esp_timer_linux.c

@@ -0,0 +1,47 @@
+// Copyright 2021 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 "esp_err.h"
+#include "esp_timer.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+void * create_tt(esp_timer_cb_t cb);
+
+void destroy_tt(void* tt);
+
+void set_tout(void* tt, uint32_t ms);
+
+esp_err_t esp_timer_create(const esp_timer_create_args_t* create_args,
+                           esp_timer_handle_t* out_handle)
+{
+    *out_handle = (esp_timer_handle_t)create_tt(create_args->callback);
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_start_periodic(esp_timer_handle_t timer, uint64_t period)
+{
+    set_tout(timer, period/1000);
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_stop(esp_timer_handle_t timer)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_delete(esp_timer_handle_t timer)
+{
+    destroy_tt(timer);
+    return ESP_OK;
+}

components/mdns/tests/host_test/components/esp_timer_linux/include/esp_timer.h

@@ -0,0 +1,41 @@
+// Copyright 2021 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.
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef struct esp_timer* esp_timer_handle_t;
+
+typedef void (*esp_timer_cb_t)(void* arg);
+
+typedef enum {
+    ESP_TIMER_TASK,
+} esp_timer_dispatch_t;
+
+typedef struct {
+    esp_timer_cb_t callback;        //!< Function to call when timer expires
+    void* arg;                      //!< Argument to pass to the callback
+    esp_timer_dispatch_t dispatch_method;   //!< Call the callback from task or from ISR
+    const char* name;               //!< Timer name, used in esp_timer_dump function
+    bool skip_unhandled_events;     //!< Skip unhandled events for periodic timers
+} esp_timer_create_args_t;
+
+esp_err_t esp_timer_create(const esp_timer_create_args_t* create_args,
+                           esp_timer_handle_t* out_handle);
+esp_err_t esp_timer_start_periodic(esp_timer_handle_t timer, uint64_t period);
+
+esp_err_t esp_timer_stop(esp_timer_handle_t timer);
+
+esp_err_t esp_timer_delete(esp_timer_handle_t timer);

components/mdns/tests/host_test/components/esp_timer_linux/timer_task.cpp

@@ -0,0 +1,38 @@
+// Copyright 2021 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 "timer_task.hpp"
+#include <cstdint>
+#include <vector>
+#include <memory>
+#include <cstring>
+
+extern "C" void * create_tt(cb_t cb)
+{
+    auto * tt = new TimerTaskMock(cb);
+    return tt;
+}
+
+extern "C" void destroy_tt(void* tt)
+{
+    auto * timer_task = static_cast<TimerTaskMock *>(tt);
+    delete(timer_task);
+}
+
+
+extern "C" void set_tout(void* tt, uint32_t ms)
+{
+    auto * timer_task = static_cast<TimerTaskMock *>(tt);
+    timer_task->SetTimeout(ms);
+}

components/mdns/tests/host_test/components/esp_timer_linux/timer_task.hpp

@@ -0,0 +1,61 @@
+// Copyright 2021 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.
+#pragma once
+
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#include <atomic>
+
+typedef void (*cb_t)(void* arg);
+
+class TimerTaskMock
+{
+public:
+    TimerTaskMock(cb_t cb): cb(cb), t(run_static, this), active(false), ms(INT32_MAX) {}
+    ~TimerTaskMock(void) { active = false; t.join(); }
+
+    void SetTimeout(uint32_t m)
+    {
+        ms = m;
+        active = true;
+    }
+
+private:
+
+    static void run_static(TimerTaskMock* timer)
+    {
+        timer->run();
+    }
+
+    void run(void)
+    {
+        while (!active.load()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+
+        while (active.load()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+            cb(nullptr);
+        }
+    }
+
+    cb_t cb;
+    std::thread t;
+    std::atomic<bool> active;
+    uint32_t ms;
+
+};

components/mdns/tests/host_test/components/freertos_linux/CMakeLists.txt

@@ -0,0 +1,13 @@
+idf_component_register(SRCS freertos_linux.c queue_unique_ptr.cpp
+                       INCLUDE_DIRS include
+                       REQUIRES esp_system_protocols_linux)
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+target_link_libraries(${COMPONENT_LIB} PRIVATE Threads::Threads)
+
+set_target_properties(${COMPONENT_LIB} PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED ON
+    CXX_EXTENSIONS ON
+)

components/mdns/tests/host_test/components/freertos_linux/Kconfig

@@ -0,0 +1,7 @@
+menu "FreeRTOS"
+
+    config FREERTOS_NO_AFFINITY
+        hex
+        default 0x7FFFFFFF
+
+endmenu

components/mdns/tests/host_test/components/freertos_linux/freertos_linux.c

@@ -0,0 +1,192 @@
+// Copyright 2021 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 <unistd.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <pthread.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+void * create_q(void);
+
+void destroy_q(void* q);
+
+bool send_q(void* q, uint8_t *data, size_t len);
+
+bool recv_q(void* q, uint8_t *data, size_t len, uint32_t ms);
+
+static uint64_t s_semaphore_data = 0;
+
+struct queue_handle {
+    size_t item_size;
+    void * q;
+};
+
+QueueHandle_t xQueueCreate( uint32_t uxQueueLength, uint32_t uxItemSize )
+{
+    struct queue_handle * h = calloc(1, sizeof(struct queue_handle));
+    h->item_size = uxItemSize;
+    h->q = create_q();
+    return (QueueHandle_t)h;
+}
+
+uint32_t xQueueSend(QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait)
+{
+    struct queue_handle * h = xQueue;
+    return send_q(h->q, (uint8_t*)pvItemToQueue, h->item_size) ? pdTRUE : pdFAIL;
+}
+
+uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait)
+{
+    struct queue_handle * h = xQueue;
+    return recv_q(h->q, (uint8_t*)pvBuffer, h->item_size, xTicksToWait) ? pdTRUE : pdFAIL;
+}
+
+BaseType_t xSemaphoreGive( QueueHandle_t xQueue)
+{
+    return xQueueSend(xQueue, &s_semaphore_data, portMAX_DELAY);
+}
+
+BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask )
+{
+    return xQueueReceive(xQueue, &s_semaphore_data, portMAX_DELAY);
+}
+
+void vQueueDelete( QueueHandle_t xQueue )
+{
+    struct queue_handle * h = xQueue;
+    if (h->q) {
+        destroy_q(h->q);
+    }
+    free(xQueue);
+}
+
+QueueHandle_t xSemaphoreCreateBinary(void)
+{
+    QueueHandle_t sempaphore =  xQueueCreate(1, 1);
+    return sempaphore;
+}
+
+QueueHandle_t xSemaphoreCreateMutex(void)
+{
+    QueueHandle_t sempaphore =  xQueueCreate(1, 1);
+    if (sempaphore) {
+        xSemaphoreGive(sempaphore);
+    }
+    return sempaphore;
+}
+
+void vTaskDelete(TaskHandle_t *task)
+{
+    if (task == NULL) {
+        pthread_exit(0);
+    }
+    void *thread_rval = NULL;
+    pthread_join((pthread_t)task, &thread_rval);
+}
+
+TickType_t xTaskGetTickCount( void )
+{
+    struct timespec spec;
+    clock_gettime(CLOCK_REALTIME, &spec);
+    return spec.tv_nsec / 1000000 + spec.tv_sec * 1000;
+}
+
+void vTaskDelay( const TickType_t xTicksToDelay )
+{
+    usleep(xTicksToDelay*1000);
+}
+
+void * pthread_task(void * params)
+{
+    struct {
+        void * const param;
+        TaskFunction_t task;
+        bool started;
+    } *pthread_params = params;
+
+    void * const param = pthread_params->param;
+    TaskFunction_t task = pthread_params->task;
+    pthread_params->started = true;
+
+    task(param);
+
+    return NULL;
+}
+
+BaseType_t xTaskCreatePinnedToCore(	TaskFunction_t pvTaskCode,
+                                       const char * const pcName,
+                                       const uint32_t usStackDepth,
+                                       void * const pvParameters,
+                                       UBaseType_t uxPriority,
+                                       TaskHandle_t * const pvCreatedTask,
+                                       const BaseType_t xCoreID)
+{
+    xTaskCreate(pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pvCreatedTask);
+    return pdTRUE;
+}
+
+
+void xTaskCreate(TaskFunction_t pvTaskCode, const char * const pcName, const uint32_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pvCreatedTask)
+{
+    pthread_t new_thread = (pthread_t)NULL;
+    pthread_attr_t attr;
+    struct {
+        void * const param;
+        TaskFunction_t task;
+        bool started;
+    } pthread_params = { .param = pvParameters, .task = pvTaskCode};
+    int res = pthread_attr_init(&attr);
+    assert(res == 0);
+    res = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    assert(res == 0);
+    res = pthread_create(&new_thread, &attr, pthread_task, &pthread_params);
+    assert(res == 0);
+
+    if (pvCreatedTask) {
+        *pvCreatedTask = (void*)new_thread;
+    }
+
+    // just wait till the task started so we can unwind params from the stack
+    while (pthread_params.started == false) {
+        usleep(1000);
+    }
+}
+
+uint32_t esp_get_free_heap_size(void)
+{
+    return 0;
+}
+
+uint32_t esp_random(void)
+{
+    return rand();
+}
+
+void xTaskNotifyGive(TaskHandle_t task)
+{
+
+}
+
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time )
+{
+    return true;
+}
+
+TaskHandle_t xTaskGetCurrentTaskHandle(void)
+{
+    return NULL;
+}

components/mdns/tests/host_test/components/freertos_linux/include/esp_task.h

@@ -0,0 +1,20 @@
+// Copyright 2021 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.
+#pragma once
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+#define ESP_TASK_PRIO_MAX 25
+#define ESP_TASKD_EVENT_PRIO 5

components/mdns/tests/host_test/components/freertos_linux/include/freertos/FreeRTOS.h

@@ -0,0 +1,34 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#define portTICK_PERIOD_MS 1
+#define portMAX_DELAY ( TickType_t ) 0xffffffffUL
+
+typedef void * SemaphoreHandle_t;
+typedef void * QueueHandle_t;
+typedef void * TaskHandle_t;
+typedef uint32_t TickType_t;
+
+typedef void (*TaskFunction_t)( void * );
+typedef unsigned int	UBaseType_t;
+typedef int 			BaseType_t;
+
+#define pdFALSE			( ( BaseType_t ) 0 )
+#define pdTRUE			( ( BaseType_t ) 1 )
+
+#define pdPASS			( pdTRUE )
+#define pdFAIL			( pdFALSE )
+
+#define pdMS_TO_TICKS(tick)    (tick)
+
+uint32_t esp_get_free_heap_size(void);
+uint32_t esp_random(void);

components/mdns/tests/host_test/components/freertos_linux/include/freertos/task.h

@@ -0,0 +1,50 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include "freertos/FreeRTOS.h"
+
+#define TaskHandle_t TaskHandle_t
+#define vSemaphoreDelete( xSemaphore ) vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
+
+void vTaskDelay( const TickType_t xTicksToDelay );
+
+void xTaskNotifyGive(TaskHandle_t task);
+
+TaskHandle_t xTaskGetCurrentTaskHandle(void);
+
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time );
+
+BaseType_t xTaskCreatePinnedToCore(	TaskFunction_t pvTaskCode,
+                                       const char * const pcName,
+                                       const uint32_t usStackDepth,
+                                       void * const pvParameters,
+                                       UBaseType_t uxPriority,
+                                       TaskHandle_t * const pvCreatedTask,
+                                       const BaseType_t xCoreID);
+
+void xTaskCreate(TaskFunction_t pvTaskCode, const char * const pcName, const uint32_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pvCreatedTask);
+
+TickType_t xTaskGetTickCount( void );
+
+void vQueueDelete( QueueHandle_t xQueue );
+
+QueueHandle_t xSemaphoreCreateBinary(void);
+
+QueueHandle_t xSemaphoreCreateMutex(void);
+
+BaseType_t xSemaphoreGive( QueueHandle_t xQueue);
+
+BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask );
+
+void vTaskDelete(TaskHandle_t *task);
+
+QueueHandle_t xQueueCreate( uint32_t uxQueueLength,
+                            uint32_t uxItemSize );
+
+uint32_t xQueueSend(QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait);
+
+uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait);

components/mdns/tests/host_test/components/freertos_linux/queue_unique_ptr.cpp

@@ -0,0 +1,51 @@
+// Copyright 2021 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 "queue_unique_ptr.hpp"
+#include <cstdint>
+#include <vector>
+#include <memory>
+#include <cstring>
+
+extern "C" void * create_q(void)
+{
+    auto * q = new QueueMock<std::vector<uint8_t>>();
+    return q;
+}
+
+extern "C" void destroy_q(void* q)
+{
+    auto * queue = static_cast<QueueMock<std::vector<uint8_t>> *>(q);
+    delete(queue);
+}
+
+extern "C" bool send_q(void* q, uint8_t *data, size_t len)
+{
+    auto v = std::make_unique<std::vector<uint8_t>>(len);
+    v->assign(data, data+len);
+    auto queue = static_cast<QueueMock<std::vector<uint8_t>> *>(q);
+    queue->send(std::move(v));
+    return true;
+}
+
+extern "C" bool recv_q(void* q, uint8_t *data, size_t len, uint32_t ms)
+{
+    auto queue = static_cast<QueueMock<std::vector<uint8_t>> *>(q);
+    auto v = queue->receive(ms);
+    if (v == nullptr) {
+        return false;
+    }
+    memcpy(data, (void *)v->data(), len);
+    return true;
+}

components/mdns/tests/host_test/components/freertos_linux/queue_unique_ptr.hpp

@@ -0,0 +1,55 @@
+// Copyright 2021 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.
+
+#pragma once
+
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+#include <atomic>
+
+template <class T>
+class QueueMock
+{
+public:
+    QueueMock(void): q(), m(), c() {}
+    ~QueueMock(void) {}
+
+void send(std::unique_ptr<T> t)
+{
+    std::lock_guard<std::mutex> lock(m);
+    q.push(std::move(t));
+    c.notify_one();
+}
+
+std::unique_ptr<T> receive(uint32_t ms)
+{
+    std::unique_lock<std::mutex> lock(m);
+    while(q.empty()) {
+        if (c.wait_for(lock, std::chrono::milliseconds(ms)) == std::cv_status::timeout) {
+            return nullptr;
+        }
+    }
+    std::unique_ptr<T> val = std::move(q.front());
+    q.pop();
+    return val;
+}
+
+private:
+    std::queue<std::unique_ptr<T>> q;
+    mutable std::mutex m;
+    std::condition_variable c;
+};

components/mdns/tests/host_test/main/CMakeLists.txt

@@ -0,0 +1,4 @@
+idf_component_register(SRCS "main.c"
+                    INCLUDE_DIRS
+                    "."
+                    REQUIRES mdns)

components/mdns/tests/host_test/main/main.c

@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include "mdns.h"
+#include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+static const char *TAG = "mdns-test";
+
+static void query_mdns_host(const char * host_name)
+{
+    ESP_LOGI(TAG, "Query A: %s.local", host_name);
+
+    struct esp_ip4_addr addr;
+    addr.addr = 0;
+
+    esp_err_t err = mdns_query_a(host_name, 2000,  &addr);
+    if(err){
+        if(err == ESP_ERR_NOT_FOUND){
+            ESP_LOGW(TAG, "%x: Host was not found!", (err));
+            return;
+        }
+        ESP_LOGE(TAG, "Query Failed: %x", (err));
+        return;
+    }
+
+    ESP_LOGI(TAG, "Query A: %s.local resolved to: " IPSTR, host_name, IP2STR(&addr));
+}
+
+int main(int argc , char *argv[])
+{
+
+    setvbuf(stdout, NULL, _IONBF, 0);
+    const esp_netif_inherent_config_t base_cg = { .if_key = "WIFI_STA_DEF", .if_desc = "eth2" };
+    esp_netif_config_t cfg = { .base = &base_cg  };
+    esp_netif_t *sta = esp_netif_new(&cfg);
+
+    mdns_init();
+
+    mdns_hostname_set("myesp");
+    ESP_LOGI(TAG, "mdns hostname set to: [%s]", "myesp");
+    //set default mDNS instance name
+    mdns_instance_name_set("myesp-inst");
+    //structure with TXT records
+    mdns_txt_item_t serviceTxtData[3] = {
+            {"board","esp32"},
+            {"u","user"},
+            {"p","password"}
+    };
+    vTaskDelay(1000);
+    ESP_ERROR_CHECK(mdns_service_add("myesp-service2", "_http", "_tcp", 80, serviceTxtData, 3));
+    vTaskDelay(2000);
+
+    query_mdns_host("david-comp");
+    vTaskDelay(2000);
+    esp_netif_destroy(sta);
+    mdns_free();
+    ESP_LOGI(TAG, "Exit");
+    return 0;
+}

components/mdns/tests/test_afl_fuzz_host/CMakeLists.txt

@@ -0,0 +1,7 @@
+# The following four lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.5)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+project(fuzz_test_update)

components/mdns/tests/test_afl_fuzz_host/Makefile

@@ -0,0 +1,83 @@
+TEST_NAME=test
+FUZZ=afl-fuzz
+COMPONENTS_DIR=$(IDF_PATH)/components
+COMPILER_ICLUDE_DIR=$(shell echo `which xtensa-esp32-elf-gcc | xargs dirname | xargs dirname`/xtensa-esp32-elf)
+
+CFLAGS=-g -Wno-unused-value -Wno-missing-declarations -Wno-pointer-bool-conversion -Wno-macro-redefined -Wno-int-to-void-pointer-cast -DHOOK_MALLOC_FAILED -DESP_EVENT_H_ -D__ESP_LOG_H__ \
+                 -I. -I../.. -I../../include -I../../private_include -I ./build/config  \
+                 -I$(COMPONENTS_DIR) \
+                 -I$(COMPONENTS_DIR)/driver/include \
+                 -I$(COMPONENTS_DIR)/esp_common/include \
+                 -I$(COMPONENTS_DIR)/esp_event/include \
+                 -I$(COMPONENTS_DIR)/esp_eth/include \
+                 -I$(COMPONENTS_DIR)/esp_hw_support/include \
+                 -I$(COMPONENTS_DIR)/esp_netif/include \
+                 -I$(COMPONENTS_DIR)/esp_netif/private_include \
+                 -I$(COMPONENTS_DIR)/esp_netif/lwip \
+                 -I$(COMPONENTS_DIR)/esp_rom/include \
+                 -I$(COMPONENTS_DIR)/esp_system/include \
+                 -I$(COMPONENTS_DIR)/esp_timer/include \
+                 -I$(COMPONENTS_DIR)/esp_wifi/include \
+                 -I$(COMPONENTS_DIR)/freertos/FreeRTOS-Kernel \
+                 -I$(COMPONENTS_DIR)/freertos/FreeRTOS-Kernel/include \
+                 -I$(COMPONENTS_DIR)/freertos/esp_additions/include/freertos \
+                 -I$(COMPONENTS_DIR)/hal/include \
+                 -I$(COMPONENTS_DIR)/hal/esp32/include \
+                 -I$(COMPONENTS_DIR)/heap/include \
+                 -I$(COMPONENTS_DIR)/log/include \
+                 -I$(COMPONENTS_DIR)/lwip/lwip/src/include \
+                 -I$(COMPONENTS_DIR)/lwip/port/esp32/include \
+                 -I$(COMPONENTS_DIR)/lwip/lwip/src/include/lwip/apps \
+                 -I$(COMPONENTS_DIR)/newlib/platform_include \
+                 -I$(COMPONENTS_DIR)/soc/include \
+                 -I$(COMPONENTS_DIR)/soc/include \
+                 -I$(COMPONENTS_DIR)/soc/esp32/include \
+                 -I$(COMPONENTS_DIR)/soc/src/esp32/include \
+                 -I$(COMPONENTS_DIR)/xtensa/include \
+                 -I$(COMPONENTS_DIR)/xtensa/esp32/include \
+                 -I$(COMPILER_ICLUDE_DIR)/include
+
+
+MDNS_C_DEPENDENCY_INJECTION=-include mdns_di.h
+ifeq ($(MDNS_NO_SERVICES),on)
+    CFLAGS+=-DMDNS_NO_SERVICES
+endif
+
+ifeq ($(INSTR),off)
+    CC=gcc
+    CFLAGS+=-DINSTR_IS_OFF
+    TEST_NAME=test_sim
+else
+    CC=afl-clang-fast
+endif
+CPP=$(CC)
+LD=$(CC)
+OBJECTS=esp32_mock.o mdns.o test.o esp_netif_mock.o
+
+OS := $(shell uname)
+ifeq ($(OS),Darwin)
+  LDLIBS=
+else
+   LDLIBS=-lbsd
+   CFLAGS+=-DUSE_BSD_STRING
+endif
+
+all: $(TEST_NAME)
+
+%.o: %.c
+	@echo "[CC] $<"
+	@$(CC) $(CFLAGS) -c $< -o $@
+
+mdns.o: ../../mdns.c
+	@echo "[CC] $<"
+	@$(CC) $(CFLAGS) -include mdns_mock.h $(MDNS_C_DEPENDENCY_INJECTION) -c $< -o $@
+
+$(TEST_NAME): $(OBJECTS)
+	@echo "[LD] $@"
+	@$(LD)  $(OBJECTS) -o $@ $(LDLIBS)
+
+fuzz: $(TEST_NAME)
+	@$(FUZZ) -i "in" -o "out" -- ./$(TEST_NAME)
+
+clean:
+	@rm -rf *.o *.SYM $(TEST_NAME) out

components/mdns/tests/test_afl_fuzz_host/README.md

@@ -0,0 +1,80 @@
+## Introduction
+This test uses [american fuzzy lop](http://lcamtuf.coredump.cx/afl/) to mangle real mdns packets and look for exceptions caused by the parser.
+
+A few actual packets are collected and exported as bins in the `in` folder, which is then passed as input to AFL when testing. The setup procedure for the test includes all possible services and scenarios that could be used with the given input packets.The output of the parser before fuzzing can be found in [input_packets.txt](input_packets.txt)
+
+## Building and running the tests using AFL
+To build and run the tests using AFL(afl-clang-fast) instrumentation
+
+```bash
+cd $IDF_PATH/components/mdns/test_afl_host
+make fuzz
+```
+
+(Please note you have to install AFL instrumentation first, check `Installing AFL` section)
+
+## Building the tests using GCC INSTR(off)
+
+To build the tests without AFL instrumentations and instead of that use GCC compiler(In this case it will only check for compilation issues and will not run AFL tests).
+
+```bash
+cd $IDF_PATH/components/mdns/test_afl_host
+make INSTR=off
+```
+
+Note, that this setup is useful if we want to reproduce issues reported by fuzzer tests executed in the CI, or to simulate how the packet parser treats the input packets on the host machine.
+
+## Installing AFL
+To run the test yourself, you need to download the [latest afl archive](http://lcamtuf.coredump.cx/afl/releases/afl-latest.tgz) and extract it to a folder on your computer.
+
+The rest of the document will refer to that folder as ```PATH_TO_AFL```.
+
+### Preparation
+- On Mac, you will need to install the latest Xcode and llvm support from [Homebrew](https://brew.sh)
+
+    ```bash
+    /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+    brew install --with-clang --with-lld --HEAD llvm
+    export PATH="/usr/local/opt/llvm/bin:$PATH"
+    ```
+
+- On Ubuntu you need the following packages:
+    
+    ```bash
+    sudo apt-get install make clang-4.0(or <=4.0) llvm-4.0(or <=4.0) libbsd-dev
+    ```
+
+Please note that if specified package version can't be installed(due to system is the latest), you can download, build and install it manually.
+
+### Compile AFL
+Compiling AFL is as easy as running make:
+
+```bash
+cd [PATH_TO_AFL]
+make
+cd llvm_mode/
+make
+```
+
+After successful compilation, you can export the following variables to your shell (you can also add them to your profile if you want to use AFL in other projects).
+
+```bash
+export AFL_PATH=[PATH_TO_AFL]
+export PATH="$AFL_PATH:$PATH"
+```
+
+Please note LLVM must be <=4.0.0, otherwise afl does not compile, as there are some limitations with building AFL on MacOS/Linux with the latest LLVM. Also, Windows build on cygwin is not fully supported.
+
+## Additional info
+Apple has a crash reporting service that could interfere with AFLs normal operation. To turn that off, run the following command:
+
+```bash
+launchctl unload -w /System/Library/LaunchAgents/com.apple.ReportCrash.plist
+sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.ReportCrash.Root.plist
+```
+
+Ubuntu has a similar service. To turn that off, run as root:
+
+```bash
+echo core >/proc/sys/kernel/core_pattern
+```

components/mdns/tests/test_afl_fuzz_host/esp32_mock.c

@@ -0,0 +1,111 @@
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "esp32_mock.h"
+
+void*     g_queue;
+int       g_queue_send_shall_fail = 0;
+int       g_size = 0;
+
+const char * WIFI_EVENT = "wifi_event";
+const char * ETH_EVENT = "eth_event";
+
+esp_err_t esp_event_handler_register(const char * event_base,
+                                        int32_t event_id,
+                                        void* event_handler,
+                                        void* event_handler_arg)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_event_handler_unregister(const char * event_base, int32_t event_id, void* event_handler)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_delete(esp_timer_handle_t timer)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_stop(esp_timer_handle_t timer)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_start_periodic(esp_timer_handle_t timer, uint64_t period)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_timer_create(const esp_timer_create_args_t* create_args,
+                           esp_timer_handle_t* out_handle)
+{
+    return ESP_OK;
+}
+
+uint32_t xTaskGetTickCount(void)
+{
+    static uint32_t tick = 0;
+    return tick++;
+}
+
+/// Queue mock
+ QueueHandle_t xQueueCreate( uint32_t uxQueueLength, uint32_t uxItemSize )
+ {
+     g_size = uxItemSize;
+     g_queue = malloc((uxQueueLength)*(uxItemSize));
+     return g_queue;
+ }
+
+
+void vQueueDelete( QueueHandle_t xQueue )
+{
+    free(xQueue);
+}
+
+uint32_t xQueueSend(QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait)
+{
+    if (g_queue_send_shall_fail)
+    {
+        return pdFALSE;
+    }
+    else
+    {
+        memcpy(xQueue, pvItemToQueue, g_size);
+        return pdPASS;
+    }
+}
+
+
+uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait)
+{
+    return pdFALSE;
+}
+
+void GetLastItem(void *pvBuffer)
+{
+    memcpy(pvBuffer, g_queue, g_size);
+}
+
+void ForceTaskDelete(void)
+{
+    g_queue_send_shall_fail = 1;
+}
+
+TaskHandle_t xTaskGetCurrentTaskHandle(void)
+{
+    return NULL;
+}
+
+void xTaskNotifyGive(TaskHandle_t task)
+{
+    return;
+}
+
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t * value, TickType_t wait_time)
+{
+    return pdTRUE;
+}

components/mdns/tests/test_afl_fuzz_host/esp32_mock.h

@@ -0,0 +1,146 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef _ESP32_COMPAT_H_
+#define _ESP32_COMPAT_H_
+
+// Skip these include files
+#define ESP_MDNS_NETWORKING_H_
+#define INC_FREERTOS_H
+#define QUEUE_H
+#define SEMAPHORE_H
+#define _ESP_TASK_H_
+
+#ifdef USE_BSD_STRING
+#include <features.h>
+#include <bsd/string.h>
+#endif
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/time.h>
+#include "esp_timer.h"
+
+#define ESP_FAIL                    -1
+
+#define ESP_ERR_NO_MEM              0x101
+#define ESP_ERR_INVALID_ARG         0x102
+#define ESP_ERR_INVALID_STATE       0x103
+#define ESP_ERR_INVALID_SIZE        0x104
+#define ESP_ERR_NOT_FOUND           0x105
+#define ESP_ERR_NOT_SUPPORTED       0x106
+#define ESP_ERR_TIMEOUT             0x107
+#define ESP_ERR_INVALID_RESPONSE    0x108
+#define ESP_ERR_INVALID_CRC         0x109
+
+#define pdTRUE                      true
+#define pdFALSE                     false
+#define pdPASS			( pdTRUE )
+#define pdFAIL			( pdFALSE )
+
+#define portMAX_DELAY               0xFFFFFFFF
+#define portTICK_PERIOD_MS          1
+#define ESP_LOGW(a,b)
+#define ESP_LOGD(a,b)
+#define ESP_LOGE(a,b,c)
+#define ESP_LOGV(a,b,c,d)
+
+#define LWIP_HDR_PBUF_H
+#define __ESP_RANDOM_H__
+#define INC_TASK_H
+
+#define pdMS_TO_TICKS(a) a
+#define portTICK_PERIOD_MS 10
+#define xSemaphoreTake(s,d)        true
+#define xTaskDelete(a)
+#define vTaskDelete(a)             free(a)
+#define xSemaphoreGive(s)
+#define xQueueCreateMutex(s)
+#define _mdns_pcb_init(a,b)         true
+#define _mdns_pcb_deinit(a,b)       true
+#define xSemaphoreCreateMutex()     malloc(1)
+#define xSemaphoreCreateBinary()    malloc(1)
+#define vSemaphoreDelete(s)         free(s)
+#define queueQUEUE_TYPE_MUTEX       ( ( uint8_t ) 1U
+#define xTaskCreatePinnedToCore(a,b,c,d,e,f,g)     *(f) = malloc(1)
+#define vTaskDelay(m)               usleep((m)*0)
+#define esp_random()                (rand()%UINT32_MAX)
+
+
+#define ESP_TASK_PRIO_MAX 25
+#define ESP_TASKD_EVENT_PRIO 5
+#define _mdns_udp_pcb_write(tcpip_if, ip_protocol, ip, port, data, len) len
+#define TaskHandle_t TaskHandle_t
+
+
+typedef int32_t esp_err_t;
+
+typedef void * SemaphoreHandle_t;
+typedef void * QueueHandle_t;
+typedef void * TaskHandle_t;
+typedef int    BaseType_t;
+typedef uint32_t TickType_t;
+
+
+extern const char * WIFI_EVENT;
+extern const char * IP_EVENT;
+extern const char * ETH_EVENT;
+
+struct udp_pcb {
+    uint8_t dummy;
+};
+
+struct ip4_addr {
+  uint32_t addr;
+};
+typedef struct ip4_addr ip4_addr_t;
+
+struct ip6_addr {
+  uint32_t addr[4];
+};
+typedef struct ip6_addr ip6_addr_t;
+
+typedef void* system_event_t;
+
+struct pbuf {
+  struct pbuf *next;
+  void *payload;
+  uint16_t tot_len;
+  uint16_t  len;
+  uint8_t  /*pbuf_type*/ type;
+  uint8_t  flags;
+  uint16_t  ref;
+};
+
+uint32_t xTaskGetTickCount(void);
+typedef void (*esp_timer_cb_t)(void* arg);
+
+// Queue mock
+QueueHandle_t xQueueCreate( uint32_t uxQueueLength,
+                            uint32_t uxItemSize );
+
+void vQueueDelete( QueueHandle_t xQueue );
+
+uint32_t xQueueSend(QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait);
+
+uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait);
+
+void GetLastItem(void *pvBuffer);
+
+void ForceTaskDelete(void);
+
+esp_err_t esp_event_handler_register(const char * event_base, int32_t event_id, void* event_handler, void* event_handler_arg);
+
+esp_err_t esp_event_handler_unregister(const char * event_base, int32_t event_id, void* event_handler);
+
+
+TaskHandle_t xTaskGetCurrentTaskHandle(void);
+void xTaskNotifyGive(TaskHandle_t task);
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time );
+
+#endif //_ESP32_COMPAT_H_

components/mdns/tests/test_afl_fuzz_host/esp_attr.h

@@ -0,0 +1,9 @@
+#pragma once
+#define IRAM_ATTR
+#define FLAG_ATTR(TYPE)
+#define QUEUE_H
+#define __ARCH_CC_H__
+#define __XTENSA_API_H__
+#define SSIZE_MAX INT_MAX
+#define LWIP_HDR_IP6_ADDR_H
+#define LWIP_HDR_IP4_ADDR_H

components/mdns/tests/test_afl_fuzz_host/esp_netif_mock.c

@@ -0,0 +1,63 @@
+// Copyright 2020 Espressif Systems (Shanghai) CO 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 <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "esp32_mock.h"
+
+typedef struct esp_netif_s esp_netif_t;
+typedef struct esp_netif_ip_info esp_netif_ip_info_t;
+typedef struct esp_netif_dhcp_status esp_netif_dhcp_status_t;
+
+
+const char * IP_EVENT = "IP_EVENT";
+
+
+esp_err_t esp_netif_add_to_list(esp_netif_t *netif)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_netif_remove_from_list(esp_netif_t *netif)
+{
+    return ESP_ERR_NOT_FOUND;
+}
+
+esp_netif_t* esp_netif_next(esp_netif_t* netif)
+{
+    return NULL;
+}
+
+esp_netif_t* esp_netif_next_unsafe(esp_netif_t* netif)
+{
+    return NULL;
+}
+
+esp_netif_t *esp_netif_get_handle_from_ifkey(const char *if_key)
+{
+    return NULL;
+}
+
+esp_err_t esp_netif_get_ip_info(esp_netif_t *esp_netif, esp_netif_ip_info_t *ip_info)
+{
+    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;
+}

components/mdns/tests/test_afl_fuzz_host/input_packets.txt

@@ -0,0 +1,166 @@
+Input: in/test-14.bin
+Packet Length: 568
+Questions: 18
+  Q: _airport._tcp.local. PTR IN
+  Q: _http._tcp.local. PTR IN
+  Q: _printer._tcp.local. PTR IN
+  Q: _sub._http._tcp.local. PTR IN
+  Q: _airplay._tcp.local. PTR IN
+  Q: _raop._tcp.local. PTR IN
+  Q: _uscan._tcp.local. PTR IN
+  Q: _uscans._tcp.local. PTR IN
+  Q: _ippusb._tcp.local. PTR IN
+  Q: _scanner._tcp.local. PTR IN
+  Q: _ipp._tcp.local. PTR IN
+  Q: _ipps._tcp.local. PTR IN
+  Q: _pdl-datastream._tcp.local. PTR IN
+  Q: _ptp._tcp.local. PTR IN
+  Q: _sleep-proxy._udp.local. PTR IN
+  Q: 9801A7E58FA1@Hristo's AirPort Express._raop._tcp.local. TXT IN
+  Q: Hristo's AirPort Express._airport._tcp.local. TXT IN
+  Q: Hristo's Time Capsule._airport._tcp.local. TXT IN
+Answers: 7 + 0
+  A: _airport._tcp.local. PTR IN 2272 [2] Hristo's AirPort Express._airport._tcp.local.
+  A: _airport._tcp.local. PTR IN 2272 [2] Hristo's Time Capsule._airport._tcp.local.
+  A: _http._tcp.local. PTR IN 2535 [23] HP LaserJet CP1025nw._http._tcp.local.
+  A: _printer._tcp.local. PTR IN 2535 [23] HP LaserJet CP1025nw._printer._tcp.local.
+  A: _ipp._tcp.local. PTR IN 2535 [23] HP LaserJet CP1025nw._ipp._tcp.local.
+  A: _pdl-datastream._tcp.local. PTR IN 2535 [23] HP LaserJet CP1025nw._pdl-datastream._tcp.local.
+  A: _sleep-proxy._udp.local. PTR IN 2535 [38] 50-34-10-70.1 Hristo's Time Capsule._sleep-proxy._udp.local.
+
+Input: in/test-15.bin
+Packet Length: 524
+Answers: 3 + 3
+  A: Hristo's AirPort Express._airport._tcp.local. TXT IN FLUSH 4500 [166] waMA=98-01-A7-E5-8F-A1,raMA=98-01-A7-E8-C2-2E,raM2=98-01-A7-E8-C2-2F,raNm=your-ssid,raCh=1,rCh2=52,raSt=0,raNA=1,syFl=0x8A0C,syAP=115,syVs=7.6.8,srcv=76800.1,bjSd=23
+  A: 9801A7E58FA1@Hristo's AirPort Express._raop._tcp.local. TXT IN FLUSH 4500 [134] txtvers=1; ch=2; cn=0,1; et=0,4; sv=false; da=true; sr=44100; ss=16; pw=false; vn=65537; tp=TCP,UDP; vs=105.1; am=AirPort10,115; fv=76800.1; sf=0x1
+  A: _raop._tcp.local. PTR IN 4500 [2] 9801A7E58FA1@Hristo's AirPort Express._raop._tcp.local.
+  A: 9801A7E58FA1@Hristo's AirPort Express._raop._tcp.local. SRV IN FLUSH 120 [32] 5000 Hristos-AirPort-Express.local.
+  A: Hristo's AirPort Express.local. NSEC IN FLUSH 4500 [9] Hristo's AirPort Express._airport._tcp.local.  00 05 00 00 80 00 40
+  A: 9801A7E58FA1@Hristo's AirPort Express.local. NSEC IN FLUSH 4500 [9] 9801A7E58FA1@Hristo's AirPort Express._raop._tcp.local.  00 05 00 00 80 00 40
+
+Input: in/test-16.bin
+Packet Length: 254
+Answers: 1 + 1
+  A: Hristo's Time Capsule._airport._tcp.local. TXT IN FLUSH 4500 [168] waMA=70-73-CB-B4-C9-B3,raMA=70-73-CB-BB-04-E7,raM2=70-73-CB-BB-04-E8,raNm=nbis-test,raCh=11,rCh2=132,raSt=0,raNA=0,syFl=0x820C,syAP=116,syVs=7.6.8,srcv=76800.1,bjSd=30
+  A: Hristo's Time Capsule.local. NSEC IN FLUSH 4500 [9] Hristo's Time Capsule._airport._tcp.local.  00 05 00 00 80 00 40
+
+Input: in/test-28.bin
+Packet Length: 62
+Questions: 1
+  Q: Hristo's Time Capsule._afpovertcp._tcp.local. SRV IN FLUSH
+
+Input: in/test-29.bin
+Packet Length: 39
+Questions: 2
+  Q: minifritz.local. A IN FLUSH
+  Q: minifritz.local. AAAA IN FLUSH
+
+Input: in/test-31.bin
+Packet Length: 91
+Answers: 2 + 1
+  A: minifritz.local. AAAA IN FLUSH 120 [16] fe80:0000:0000:0000:142e:54ff:b8c4:fd09
+  A: minifritz.local. A IN FLUSH 120 [4] 192.168.254.16
+  A: minifritz.local. NSEC IN FLUSH 120 [8] minifritz...local.  00 04 40 00 00 08
+
+Input: in/test-53.bin
+Packet Length: 140
+Questions: 2
+  Q: _smb._tcp.local. PTR IN
+  Q: Sofiya-Ivanovas-MacBook.local. A IN
+Answers: 2 + 0
+  A: _smb._tcp.local. PTR IN 3061 [29] Sofiya Ivanova’s MacBook._smb._tcp.local.
+  A: _smb._tcp.local. PTR IN 3062 [24] Hristo's Time Capsule._smb._tcp.local.
+
+Input: in/test-56.bin
+Packet Length: 262
+Answers: 2 + 6
+  A: Hristo’s Mac mini._device-info._tcp.local. TXT IN 4500 [28] model=Macmini6,2; osxvers=16
+  A: _smb._tcp.local. PTR IN 4500 [22] Hristo’s Mac mini._smb._tcp.local.
+  A: Hristo’s Mac mini._smb._tcp.local. TXT IN FLUSH 4500 [1]
+  A: Hristo’s Mac mini._smb._tcp.local. SRV IN FLUSH 120 [18] 445 minifritz.local.
+  A: minifritz.local. AAAA IN FLUSH 120 [16] fe80:0000:0000:0000:142e:54ff:b8c4:fd09
+  A: minifritz.local. A IN FLUSH 120 [4] 192.168.254.16
+  A: Hristo’s Mac mini.local. NSEC IN FLUSH 4500 [9] Hristo’s Mac mini._smb._tcp.local.  00 05 00 00 80 00 40
+  A: minifritz.local. NSEC IN FLUSH 120 [8] minifritz...local.  00 04 40 00 00 08
+
+Input: in/test-63.bin
+Packet Length: 147
+Questions: 2
+  Q: _afpovertcp._tcp.local. PTR IN
+  Q: Sofiya-Ivanovas-MacBook.local. A IN
+Answers: 2 + 0
+  A: _afpovertcp._tcp.local. PTR IN 2881 [29] Sofiya Ivanova’s MacBook._afpovertcp._tcp.local.
+  A: _afpovertcp._tcp.local. PTR IN 2881 [24] Hristo's Time Capsule._afpovertcp._tcp.local.
+
+Input: in/test-66.bin
+Packet Length: 269
+Answers: 2 + 6
+  A: Hristo’s Mac mini._device-info._tcp.local. TXT IN 4500 [28] model=Macmini6,2; osxvers=16
+  A: _afpovertcp._tcp.local. PTR IN 4500 [22] Hristo’s Mac mini._afpovertcp._tcp.local.
+  A: Hristo’s Mac mini._afpovertcp._tcp.local. TXT IN FLUSH 4500 [1]
+  A: Hristo’s Mac mini._afpovertcp._tcp.local. SRV IN FLUSH 120 [18] 548 minifritz.local.
+  A: minifritz.local. AAAA IN FLUSH 120 [16] fe80:0000:0000:0000:142e:54ff:b8c4:fd09
+  A: minifritz.local. A IN FLUSH 120 [4] 192.168.254.16
+  A: Hristo’s Mac mini.local. NSEC IN FLUSH 4500 [9] Hristo’s Mac mini._afpovertcp._tcp.local.  00 05 00 00 80 00 40
+  A: minifritz.local. NSEC IN FLUSH 120 [8] minifritz...local.  00 04 40 00 00 08
+
+Input: in/test-83.bin
+Packet Length: 105
+Answers: 1 + 2
+  A: Sofiya-Ivanovas-MacBook.local. A IN FLUSH 120 [4] 192.168.254.20
+  A: Sofiya-Ivanovas-MacBook.local. AAAA IN FLUSH 120 [16] fe80:0000:0000:0000:021c:b3ff:feb2:72a3
+  A: Sofiya-Ivanovas-MacBook.local. NSEC IN FLUSH 120 [8] Sofiya-Ivanovas-MacBook...local.  00 04 40 00 00 08
+
+Input: in/test-88.bin
+Packet Length: 48
+Questions: 2
+  Q: _rfb._tcp.local. PTR IN
+  Q: _airport._tcp.local. PTR IN
+
+Input: in/test-89.bin
+Packet Length: 459
+Answers: 2 + 7
+  A: _airport._tcp.local. PTR IN 4500 [24] Hristo's Time Capsule._airport._tcp.local.
+  A: Hristo's Time Capsule._device-info._tcp.local. TXT IN 4500 [23] model=TimeCapsule6,116
+  A: Hristos-Time-Capsule.local. A IN FLUSH 120 [4] 192.168.254.49
+  A: Hristo's Time Capsule._airport._tcp.local. TXT IN FLUSH 4500 [168] waMA=70-73-CB-B4-C9-B3,raMA=70-73-CB-BB-04-E7,raM2=70-73-CB-BB-04-E8,raNm=nbis-test,raCh=11,rCh2=132,raSt=0,raNA=0,syFl=0x820C,syAP=116,syVs=7.6.8,srcv=76800.1,bjSd=30
+  A: Hristos-Time-Capsule.local. AAAA IN FLUSH 120 [16] fe80:0000:0000:0000:7273:cbff:feb4:c9b3
+  A: Hristo's Time Capsule._airport._tcp.local. SRV IN FLUSH 120 [8] 5009 Hristos-Time-Capsule.local.
+  A: Hristos-Time-Capsule.local. A IN FLUSH 120 [4] 169.254.23.40
+  A: Hristos-Time-Capsule.local. NSEC IN FLUSH 120 [8] Hristos-Time-Capsule...local.  00 04 40 00 00 08
+  A: Hristo's Time Capsule.local. NSEC IN FLUSH 4500 [9] Hristo's Time Capsule._airport._tcp.local.  00 05 00 00 80 00 40
+
+Input: in/test-91.bin
+Packet Length: 279
+Answers: 2 + 6
+  A: Sofiya Ivanova’s MacBook._device-info._tcp.local. TXT IN 4500 [17] model=Macmini2,1
+  A: _rfb._tcp.local. PTR IN 4500 [29] Sofiya Ivanova’s MacBook._rfb._tcp.local.
+  A: Sofiya Ivanova’s MacBook._rfb._tcp.local. TXT IN FLUSH 4500 [1]
+  A: Sofiya Ivanova’s MacBook._rfb._tcp.local. SRV IN FLUSH 120 [32] 5900 Sofiya-Ivanovas-MacBook.local.
+  A: Sofiya-Ivanovas-MacBook.local. AAAA IN FLUSH 120 [16] fe80:0000:0000:0000:021c:b3ff:feb2:72a3
+  A: Sofiya-Ivanovas-MacBook.local. A IN FLUSH 120 [4] 192.168.254.20
+  A: Sofiya Ivanova’s MacBook.local. NSEC IN FLUSH 4500 [9] Sofiya Ivanova’s MacBook._rfb._tcp.local.  00 05 00 00 80 00 40
+  A: Sofiya-Ivanovas-MacBook.local. NSEC IN FLUSH 120 [8] Sofiya-Ivanovas-MacBook...local.  00 04 40 00 00 08
+
+Input: in/test-95.bin
+Packet Length: 286
+Questions: 3
+  Q: _afpovertcp._tcp.local. PTR IN
+  Q: _smb._tcp.local. PTR IN
+  Q: _adisk._tcp.local. PTR IN
+Answers: 6 + 0
+  A: _afpovertcp._tcp.local. PTR IN 2353 [29] Sofiya Ivanova’s MacBook._afpovertcp._tcp.local.
+  A: _afpovertcp._tcp.local. PTR IN 3973 [22] Hristo’s Mac mini._afpovertcp._tcp.local.
+  A: _afpovertcp._tcp.local. PTR IN 2353 [24] Hristo's Time Capsule._afpovertcp._tcp.local.
+  A: _smb._tcp.local. PTR IN 2353 [29] Sofiya Ivanova’s MacBook._smb._tcp.local.
+  A: _smb._tcp.local. PTR IN 3792 [22] Hristo’s Mac mini._smb._tcp.local.
+  A: _smb._tcp.local. PTR IN 2353 [24] Hristo's Time Capsule._smb._tcp.local.
+
+Input: in/test-96.bin
+Packet Length: 319
+Answers: 2 + 3
+  A: Hristo's Time Capsule._device-info._tcp.local. TXT IN 4500 [23] model=TimeCapsule6,116
+  A: _adisk._tcp.local. PTR IN 4500 [24] Hristo's Time Capsule._adisk._tcp.local.
+  A: Hristo's Time Capsule._adisk._tcp.local. TXT IN FLUSH 4500 [110] sys=waMA=70:73:CB:B4:C9:B3,adVF=0x1000; dk2=adVF=0x1083,adVN=Capsule,adVU=55fabb8b-a63b-5441-9874-6edb504eb30a
+  A: Hristo's Time Capsule._adisk._tcp.local. SRV IN FLUSH 120 [29] 9 Hristos-Time-Capsule.local.
+  A: Hristo's Time Capsule.local. NSEC IN FLUSH 4500 [9] Hristo's Time Capsule._adisk._tcp.local.  00 05 00 00 80 00 40