Initial public release of the 2024A software.

managed_components/espressif__mdns/tests/test_apps/main/CMakeLists.txt

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

managed_components/espressif__mdns/tests/test_apps/main/Kconfig.projbuild

@@ -0,0 +1,40 @@
+menu "Example Configuration"
+
+    config TEST_MDNS_HOSTNAME
+        string "mDNS Hostname"
+        default "esp32-mdns"
+        help
+            mDNS Hostname for example to use
+
+    config TEST_MDNS_INSTANCE
+        string "mDNS Instance Name"
+        default "ESP32 with mDNS"
+        help
+            mDNS Instance Name for example to use
+
+    config TEST_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 TEST_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_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_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.
+
+
+endmenu

managed_components/espressif__mdns/tests/test_apps/main/idf_component.yml

@@ -0,0 +1,8 @@
+dependencies:
+  ## Required IDF version
+  idf: ">=5.0"
+  espressif/mdns:
+    version: "^1.0.0"
+    override_path: "../../../"
+  protocol_examples_common:
+    path: ${IDF_PATH}/examples/common_components/protocol_examples_common

managed_components/espressif__mdns/tests/test_apps/main/main.c

@@ -0,0 +1,117 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <stdio.h>
+#include <string.h>
+#include "esp_mac.h"
+#include "nvs_flash.h"
+#include "esp_event.h"
+#include "esp_netif.h"
+#include "esp_log.h"
+#include "protocol_examples_common.h"
+#include "mdns.h"
+
+static const char *TAG = "mdns_test";
+void mdns_test(char *line);
+
+static void get_string(char *line, size_t size)
+{
+    int count = 0;
+    while (count < size) {
+        int c = fgetc(stdin);
+        if (c == '\n') {
+            line[count] = '\0';
+            break;
+        } else if (c > 0 && c < 127) {
+            line[count] = c;
+            ++count;
+        }
+        vTaskDelay(20 / portTICK_PERIOD_MS);
+    }
+}
+
+/** 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_TEST_MDNS_ADD_MAC_TO_HOSTNAME
+    return strdup(CONFIG_TEST_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_TEST_MDNS_HOSTNAME, mac[3], mac[4], mac[5])) {
+        abort();
+    }
+    return hostname;
+#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(CONFIG_TEST_MDNS_INSTANCE) );
+
+    //initialize service
+    ESP_ERROR_CHECK( mdns_service_add("ESP32-WebServer", "_http", "_tcp", 80, NULL, 0) );
+
+#if CONFIG_TEST_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, NULL, 0) );
+    free(delegated_hostname);
+#endif // CONFIG_TEST_MDNS_PUBLISH_DELEGATE_HOST
+
+    ESP_ERROR_CHECK( mdns_service_subtype_add_for_host("ESP32-WebServer", "_http", "_tcp", NULL, "_server") );
+
+    free(hostname);
+}
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "[APP] Free memory: %" PRIu32 " bytes", esp_get_free_heap_size());
+    ESP_LOGI(TAG, "[APP] IDF version: %s", esp_get_idf_version());
+
+    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());
+
+    while (1) {
+        char line[256];
+
+        get_string(line, sizeof(line));
+        mdns_test(line);
+        continue;
+    }
+}

managed_components/espressif__mdns/tests/test_apps/main/mdns_test.c

@@ -0,0 +1,189 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "mdns.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+
+static const char *TAG = "mdns_test_app";
+static const int RETRY_COUNT = 10;
+
+static void mdns_print_results(mdns_result_t *results)
+{
+    mdns_result_t *r = results;
+    mdns_ip_addr_t *a = NULL;
+    int t;
+    while (r) {
+        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 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 false;
+    }
+
+    // If yes, print the result
+    mdns_ip_addr_t *a = result->addr;
+    while (a) {
+        if (a->addr.type == ESP_IPADDR_TYPE_V6) {
+            printf("Async query resolved to AAAA:" IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6));
+        } else {
+            printf("Async query resolved to A:" IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4)));
+        }
+        a = a->next;
+    }
+    // and free the result
+    mdns_query_results_free(result);
+    return true;
+}
+
+static bool query_mdns_hosts_async(const char *host_name)
+{
+    ESP_LOGI(TAG, "Query both A and AAA: %s.local", host_name);
+    bool res = false;
+
+    mdns_search_once_t *s_a = mdns_query_async_new(host_name, NULL, NULL, MDNS_TYPE_A, 1000, 1, NULL);
+    mdns_query_async_delete(s_a);
+    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;
+            res = true;
+        }
+        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;
+            res = true;
+        }
+    }
+    return res;
+}
+
+static esp_err_t 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));
+        }
+        ESP_LOGE(TAG, "Query Failed: %s", esp_err_to_name(err));
+        return err;
+    }
+
+    ESP_LOGI(TAG, "Query A: %s.local resolved to: " IPSTR, host_name, IP2STR(&addr));
+    return ESP_OK;
+}
+
+static esp_err_t query_mdns_service(const char *instance, const char *service_name, const char *proto)
+{
+    ESP_LOGI(TAG, "Query SRV: %s.%s.local", service_name, proto);
+
+    mdns_result_t *results = NULL;
+    esp_err_t err = mdns_query_srv(instance, service_name, proto, 3000,  &results);
+    if (err) {
+        ESP_LOGE(TAG, "Query Failed: %s", esp_err_to_name(err));
+        return err;
+    }
+    if (!results) {
+        ESP_LOGW(TAG, "No results found!");
+    }
+
+    mdns_print_results(results);
+    mdns_query_results_free(results);
+    return ESP_OK;
+}
+
+void query_mdns_service_sub_type(const char *subtype, 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));
+    }
+    if (!results) {
+        ESP_LOGW(TAG, "No results found!");
+    }
+
+    mdns_print_results(results);
+    mdns_query_results_free(results);
+}
+
+void mdns_test(const char *line)
+{
+    char test_case[32];
+    int i = 0;
+    const TickType_t xDelay = 1000 / portTICK_PERIOD_MS;
+
+    sscanf(line, "%s", test_case);
+    ESP_LOGI(TAG, "test case = %s", test_case);
+
+    if (strcmp(test_case, "CONFIG_TEST_QUERY_HOST") == 0) {
+        i = 0;
+        while (query_mdns_host("tinytester") != ESP_OK && i != RETRY_COUNT) {
+            query_mdns_host("tinytester");
+            i++;
+            vTaskDelay(xDelay);
+        }
+    } else if (strcmp(test_case, "CONFIG_TEST_QUERY_HOST_ASYNC") == 0) {
+        i = 0;
+        while (query_mdns_hosts_async("tinytester") == false && i != RETRY_COUNT) {
+            query_mdns_hosts_async("tinytester");
+            i++;
+            vTaskDelay(xDelay);
+        }
+    } else if (strcmp(test_case, "CONFIG_TEST_QUERY_SERVICE") == 0) {
+        i = 0;
+        while (query_mdns_service("ESP32", "_http", "_tcp") != ESP_OK && i != RETRY_COUNT) {
+            query_mdns_service("ESP32", "_http", "_tcp");
+            i++;
+            vTaskDelay(xDelay);
+        }
+    } else {
+        ESP_LOGE(TAG, "%s: No such test case", test_case);
+    }
+}