diff --git a/dependencies.lock b/dependencies.lock index 6666658..fdedac0 100644 --- a/dependencies.lock +++ b/dependencies.lock @@ -1,6 +1,6 @@ dependencies: esp-idf-lib/esp_idf_lib_helpers: - component_hash: a8049b1e609679fb54b2d57b0399dd29c4d1fda09a797edac9926f7810aa5703 + component_hash: 689853bb8993434f9556af0f2816e808bf77b5d22100144b21f3519993daf237 dependencies: [] source: registry_url: https://components.espressif.com @@ -16,9 +16,9 @@ dependencies: - esp32p4 - esp32s2 - esp32s3 - version: 1.3.10 + version: 1.4.0 esp-idf-lib/i2cdev: - component_hash: 11c08f9e1a7d346b5dd763196dc2567cf2209ae49042402c2c2d296624601c14 + component_hash: 4f3838b2e68ab2b77fd43737139fa97dd0243b46af7b4a04588c67ff6b275ba1 dependencies: - name: esp-idf-lib/esp_idf_lib_helpers registry_url: https://components.espressif.com @@ -38,7 +38,7 @@ dependencies: - esp32p4 - esp32s2 - esp32s3 - version: 2.0.8 + version: 2.1.0 esp-idf-lib/tca95x5: component_hash: 4bbdbd82828cf1fd5c03fd07e3ea2cb0f36daf16cb3ac7219d1e5decb9ec04ee dependencies: @@ -65,6 +65,16 @@ dependencies: - esp32s2 - esp32s3 version: 1.0.7 + espressif/mdns: + component_hash: 29e47564b1a7ee778135e17fbbf2a2773f71c97ebabfe626c8eda7c958a7ad16 + dependencies: + - name: idf + require: private + version: '>=5.0' + source: + registry_url: https://components.espressif.com/ + type: service + version: 1.9.1 idf: source: type: idf @@ -81,8 +91,9 @@ dependencies: version: 1.20.3 direct_dependencies: - esp-idf-lib/tca95x5 +- espressif/mdns - idf - joltwallet/littlefs -manifest_hash: b32a1e2b2eb19ff5cd4984c921bf3a1bcd9c1546566ee977021d2d4bf4b3de31 +manifest_hash: c3a20310a8ecc5e8e0221a7589abf8d2e372eb48f06d6b6fbb3fbf5f48a61aaf target: esp32 version: 2.0.0 diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index 2e96531..b82a9cf 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -2,11 +2,14 @@ # for more information about component CMakeLists.txt files. idf_component_register( - SRCS main.c i2c.c rtc.c storage.c uart_comms.c control_fsm.c power_mgmt.c rf_433.c rtc.c sensors.c solar.c webserver.c # list the source files of this component + SRCS main.c i2c.c rtc.c storage.c uart_comms.c control_fsm.c power_mgmt.c rf_433.c rtc.c sensors.c solar.c webserver.c simple_dns_server.c # list the source files of this component INCLUDE_DIRS # optional, add here public include directories PRIV_INCLUDE_DIRS # optional, add here private include directories - REQUIRES # optional, list the public requirements (component names) - PRIV_REQUIRES # optional, list the private requirements + + REQUIRES driver esp_http_server esp_netif lwip json esp_timer esp_adc app_update esp_wifi nvs_flash mdns # optional, list the public requirements (component names) + # esp_https_server + PRIV_REQUIRES # optional, list the private requirements + #EMBED_TXTFILES servercert.pem prvtkey.pem ) diff --git a/main/control_fsm.c b/main/control_fsm.c index e77b2b8..1aec2f8 100644 --- a/main/control_fsm.c +++ b/main/control_fsm.c @@ -8,6 +8,7 @@ #include "control_fsm.h" #include "esp_task_wdt.h" #include "esp_timer.h" +#include "i2c.h" #include "power_mgmt.h" #include "rtc_wdt.h" #include "driver/gpio.h" @@ -18,6 +19,9 @@ #define TRANSITION_DELAY_US 1000000 +#define CALIBRATE_JACK_MAX_TIME 3000000 +#define CALIBRATE_DRIVE_MAX_TIME 6000000 + #define TAG "FSM" static QueueHandle_t fsm_cmd_queue = NULL; @@ -37,8 +41,12 @@ bool relay_states[8] = {false}; int64_t override_times[8] = {-1}; bool enabled = false; +RTC_DATA_ATTR float remaining_distance = 0.0f; +float fsm_get_remaining_distance(void) { return remaining_distance; } +void fsm_set_remaining_distance(float x) { remaining_distance = x;} - +// Track the starting encoder count for the current move +static int32_t move_start_encoder = 0; volatile fsm_state_t current_state = STATE_IDLE; volatile int64_t current_time = 0; @@ -89,6 +97,12 @@ void pulseOverride(relay_t relay) { set_timer(TRANSITION_DELAY_US); }*/ +int64_t fsm_cal_t, fsm_cal_e; +float fsm_cal_val; +void fsm_set_cal_val(float v) {fsm_cal_val = v;} +int64_t fsm_get_cal_t(){return fsm_cal_t;} +int64_t fsm_get_cal_e(){return fsm_cal_e;} + void fsm_request(fsm_cmd_t cmd) { if (fsm_cmd_queue != NULL) @@ -120,7 +134,7 @@ int8_t fsm_get_current_progress(int8_t denominator) { } -#define JACK_TIME get_param_value_t(PARAM_JACK_KT).f32 * get_param_value_t(PARAM_JACK_DIST ).f32 +#define JACK_TIME get_param_value_t(PARAM_JACK_KT).f32 * get_param_value_t(PARAM_JACK_DIST ).f32 #define DRIVE_TIME get_param_value_t(PARAM_DRIVE_KT).f32 * get_param_value_t(PARAM_DRIVE_DIST).f32 #define DRIVE_DIST get_param_value_t(PARAM_DRIVE_KE).f32 * get_param_value_t(PARAM_DRIVE_DIST).f32 @@ -141,8 +155,13 @@ void control_task(void *param) { switch (cmd) { case FSM_CMD_START: if (current_state == STATE_IDLE) { - current_state = STATE_MOVE_START_DELAY; - set_timer(TRANSITION_DELAY_US); + // Check if we have remaining distance before starting + if (remaining_distance > 0.0f) { + current_state = STATE_MOVE_START_DELAY; + set_timer(TRANSITION_DELAY_US); + } else { + ESP_LOGW(TAG, "Cannot start move: no remaining distance (%.2f)", remaining_distance); + } } break; case FSM_CMD_STOP: @@ -158,6 +177,68 @@ void control_task(void *param) { case FSM_CMD_SHUTDOWN: enabled = false; break; + + case FSM_CMD_CALIBRATE_JACK_PREP: + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_JACK_PREP"); + if (current_state == STATE_IDLE) { + current_state = STATE_CALIBRATE_JACK_DELAY; + } + break; + + case FSM_CMD_CALIBRATE_JACK_START: + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_JACK_START"); + if (current_state == STATE_CALIBRATE_JACK_DELAY) { + current_state = STATE_CALIBRATE_JACK_MOVE; + set_timer(CALIBRATE_JACK_MAX_TIME); + } + break; + case FSM_CMD_CALIBRATE_JACK_END: + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_JACK_END"); + if (current_state == STATE_CALIBRATE_JACK_MOVE) { + fsm_cal_t = current_time - timer_start; + current_state = STATE_IDLE; + } + break; + case FSM_CMD_CALIBRATE_JACK_FINISH: + set_param_value_t(PARAM_JACK_KT, + (param_value_t){.f32 = fsm_cal_t / fsm_cal_val}); + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_JACK_FINISH -> %f", get_param_value_t(PARAM_JACK_KT).f32); + break; + + + + case FSM_CMD_CALIBRATE_DRIVE_PREP: + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_DRIVE_PREP"); + if (current_state == STATE_IDLE) { + current_state = STATE_CALIBRATE_DRIVE_DELAY; + } + break; + + case FSM_CMD_CALIBRATE_DRIVE_START: + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_DRIVE_START"); + if (current_state == STATE_CALIBRATE_DRIVE_DELAY) { + current_state = STATE_CALIBRATE_DRIVE_MOVE; + set_timer(CALIBRATE_DRIVE_MAX_TIME); + set_sensor_counter(SENSOR_DRIVE, 0); + } + break; + case FSM_CMD_CALIBRATE_DRIVE_END: + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_DRIVE_END"); + if (current_state == STATE_CALIBRATE_DRIVE_MOVE) { + fsm_cal_t = current_time - timer_start; + fsm_cal_e = get_sensor_counter(SENSOR_DRIVE); + current_state = STATE_IDLE; + } + break; + case FSM_CMD_CALIBRATE_DRIVE_FINISH: + set_param_value_t(PARAM_DRIVE_KT, + (param_value_t){.f32 = fsm_cal_t / fsm_cal_val}); + set_param_value_t(PARAM_DRIVE_KE, + (param_value_t){.f32 = fsm_cal_e / fsm_cal_val}); + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_DRIVE_FINISH -> %f / %f", + get_param_value_t(PARAM_DRIVE_KT).f32, + get_param_value_t(PARAM_DRIVE_KE).f32); + break; } } @@ -188,16 +269,58 @@ void control_task(void *param) { if (timer_done()) { current_state = STATE_DRIVE; set_timer(DRIVE_TIME); + // Set the encoder counter to track remaining distance in this move set_sensor_counter(SENSOR_DRIVE, -DRIVE_DIST); + // Record starting encoder position AFTER setting it + move_start_encoder = get_sensor_counter(SENSOR_DRIVE); + ESP_LOGI(TAG, "STATE_DRIVE starting: encoder=%ld, remaining_distance=%.2f, DRIVE_DIST=%.2f", + (long)move_start_encoder, remaining_distance, DRIVE_DIST); } break; case STATE_DRIVE: - if (timer_done() || get_sensor_counter(SENSOR_DRIVE) > 0) { - current_state = STATE_DRIVE_END_DELAY; - set_timer(TRANSITION_DELAY_US); - } - if (efuse_is_tripped(BRIDGE_DRIVE)) { - current_state = STATE_UNDO_JACK_START; + { + int32_t current_encoder = get_sensor_counter(SENSOR_DRIVE); + int32_t ticks_traveled = current_encoder - move_start_encoder; + float ke = get_param_value_t(PARAM_DRIVE_KE).f32; + float distance_traveled = ticks_traveled / ke; + + ESP_LOGI(TAG, "STATE_DRIVE: current_encoder=%ld, move_start=%ld, ticks=%ld, ke=%.2f, dist_traveled=%.2f, remaining=%.2f", + (long)current_encoder, (long)move_start_encoder, (long)ticks_traveled, + ke, distance_traveled, remaining_distance); + + // Check if we'll exceed remaining distance with a full move + bool will_exceed = distance_traveled >= remaining_distance; + + // Stop if timer expires OR encoder target reached OR we've used up remaining distance + if (timer_done() || current_encoder > 0 || will_exceed) { + ESP_LOGI(TAG, "Drive stopping: timer_done=%d, encoder>0=%d, will_exceed=%d", + timer_done(), current_encoder > 0, will_exceed); + + // Update remaining distance based on actual travel + float old_remaining = remaining_distance; + if (will_exceed) { + ESP_LOGI(TAG, "Move stopped early - reached remaining distance limit (%.2f)", remaining_distance); + remaining_distance = 0.0f; + } else { + remaining_distance -= distance_traveled; + if (remaining_distance < 0.0f) remaining_distance = 0.0f; + } + ESP_LOGI(TAG, "Drive complete: traveled %.2f, old_remaining %.2f, new_remaining %.2f", + distance_traveled, old_remaining, remaining_distance); + + current_state = STATE_DRIVE_END_DELAY; + set_timer(TRANSITION_DELAY_US); + } + + if (efuse_is_tripped(BRIDGE_DRIVE)) { + float old_remaining = remaining_distance; + // Update remaining distance even on fault + remaining_distance -= distance_traveled; + if (remaining_distance < 0.0f) remaining_distance = 0.0f; + ESP_LOGW(TAG, "Drive fault: traveled %.2f, old_remaining %.2f, new_remaining %.2f", + distance_traveled, old_remaining, remaining_distance); + current_state = STATE_UNDO_JACK_START; + } } break; case STATE_DRIVE_END_DELAY: @@ -205,8 +328,9 @@ void control_task(void *param) { current_state = STATE_JACK_DOWN; set_timer(JACK_TIME); } + break; case STATE_JACK_DOWN: - if (timer_done() || get_sensor(SENSOR_JACK)) { + if (timer_done()) { // || get_sensor(SENSOR_JACK)) { current_state = STATE_IDLE; } @@ -225,7 +349,7 @@ void control_task(void *param) { } break; case STATE_UNDO_JACK: - if (timer_done() || get_sensor(SENSOR_JACK)) { + if (timer_done()){ // || get_sensor(SENSOR_JACK)) { current_state = STATE_IDLE; } @@ -234,6 +358,32 @@ void control_task(void *param) { current_state = STATE_IDLE; } break; + + + case STATE_CALIBRATE_JACK_DELAY: + // no way out of this except a command + break; + case STATE_CALIBRATE_JACK_MOVE: + if (timer_done()) { + ESP_LOGI(TAG, "STATE_CALIBRATE_JACK_END"); + current_state = STATE_IDLE; + fsm_cal_t = current_time - timer_start; + } + break; + + + case STATE_CALIBRATE_DRIVE_DELAY: + // no way out of this except a command + break; + case STATE_CALIBRATE_DRIVE_MOVE: + if (timer_done()) { + ESP_LOGI(TAG, "STATE_CALIBRATE_DRIVE_END"); + current_state = STATE_IDLE; + fsm_cal_t = current_time - timer_start; + fsm_cal_e = get_sensor_counter(SENSOR_DRIVE); + } + break; + default: break; } @@ -261,6 +411,7 @@ void control_task(void *param) { } break; + case STATE_CALIBRATE_JACK_MOVE: case STATE_JACK_UP: // jack up and fluff setRelay(RELAY_A1, false); @@ -272,6 +423,7 @@ void control_task(void *param) { setRelay(RELAY_A3, true); reset_shutdown_timer(); break; + case STATE_CALIBRATE_DRIVE_MOVE: case STATE_DRIVE: // drive and fluff setRelay(RELAY_A1, true); @@ -308,6 +460,7 @@ void control_task(void *param) { setRelay(RELAY_A3, true); reset_shutdown_timer(); break; + case STATE_CALIBRATE_JACK_DELAY: default: // invalid state; turn all relays off setRelay(RELAY_A1, false); diff --git a/main/control_fsm.h b/main/control_fsm.h index 20823e9..93e1507 100644 --- a/main/control_fsm.h +++ b/main/control_fsm.h @@ -7,7 +7,22 @@ #include "freertos/queue.h" -typedef enum { FSM_CMD_START, FSM_CMD_STOP, FSM_CMD_UNDO, FSM_CMD_SHUTDOWN} fsm_cmd_t; +typedef enum { + FSM_CMD_START, + FSM_CMD_STOP, + FSM_CMD_UNDO, + FSM_CMD_SHUTDOWN, + + FSM_CMD_CALIBRATE_JACK_PREP, + FSM_CMD_CALIBRATE_JACK_START, + FSM_CMD_CALIBRATE_JACK_END, + FSM_CMD_CALIBRATE_JACK_FINISH, + + FSM_CMD_CALIBRATE_DRIVE_PREP, + FSM_CMD_CALIBRATE_DRIVE_START, + FSM_CMD_CALIBRATE_DRIVE_END, + FSM_CMD_CALIBRATE_DRIVE_FINISH +} fsm_cmd_t; typedef enum { STATE_IDLE = 0, @@ -19,6 +34,12 @@ typedef enum { STATE_JACK_DOWN = 6, STATE_UNDO_JACK = 7, STATE_UNDO_JACK_START = 8, + + STATE_CALIBRATE_JACK_DELAY, + STATE_CALIBRATE_JACK_MOVE, + + STATE_CALIBRATE_DRIVE_DELAY, + STATE_CALIBRATE_DRIVE_MOVE } fsm_state_t; typedef enum { @@ -46,8 +67,15 @@ void pulseOverride(relay_t relay/*, int64_t pulse*/); esp_err_t fsm_init(); esp_err_t fsm_stop(); +void fsm_set_cal_val(float v); +int64_t fsm_get_cal_t(); +int64_t fsm_get_cal_e(); void fsm_request(fsm_cmd_t cmd); + +float fsm_get_remaining_distance(void); +void fsm_set_remaining_distance(float x); + //void fsm_begin_auto_move(); int8_t fsm_get_current_progress(int8_t remainder); diff --git a/main/i2c.c b/main/i2c.c index e8ea6d1..e4337a0 100644 --- a/main/i2c.c +++ b/main/i2c.c @@ -24,9 +24,11 @@ #define TCA_REG_CONFIG1 0x07 // Debounce & Repeat Settings -#define DEBOUNCE_MS 50 -#define REPEAT_MS 200 -#define REPEAT_START_MS 700 +#define DEBOUNCE_US 50000 +#define REPEAT_US 200000 +#define REPEAT_START_US 700000 + +#define MAX_REPEATS 100 // Static Variables static bool i2c_initted = false; @@ -85,8 +87,8 @@ esp_err_t i2c_stop() { #define N_BTNS 2 static bool debounced_state[N_BTNS] = {false}; static bool last_known_state[N_BTNS] = {false}; -static uint64_t last_stable_time[N_BTNS] = {0}; -static uint64_t last_change_time[N_BTNS] = {0}; +static int64_t last_stable_time[N_BTNS] = {0}; +static int64_t last_change_time[N_BTNS] = {0}; static uint8_t claimed_repeats[N_BTNS] = {0}; esp_err_t i2c_poll_buttons() { for (uint8_t btn = 0; btn < N_BTNS; ++btn) { @@ -98,13 +100,13 @@ esp_err_t i2c_poll_buttons() { uint8_t raw_buttons = (uint8_t)(port_val & 0x0F); uint8_t raw_states = ~raw_buttons & 0x0F; - uint64_t now = esp_timer_get_time() / 1000; + int64_t now = esp_timer_get_time() / 1000; for (uint8_t btn = 0; btn < N_BTNS; ++btn) { bool raw_pressed = (raw_states & (1 << btn)) != 0; if (raw_pressed != debounced_state[btn]) { - if (now - last_stable_time[btn] >= DEBOUNCE_MS) { + if (now - last_stable_time[btn] >= DEBOUNCE_US) { debounced_state[btn] = raw_pressed; last_stable_time[btn] = now; last_change_time[btn] = now; @@ -131,9 +133,9 @@ bool i2c_get_button_state(uint8_t button) { bool i2c_get_button_repeat(uint8_t btn) { if (btn >= N_BTNS || !debounced_state[btn]) return false; - uint64_t now = esp_timer_get_time() / 1000; - if (now + DEBOUNCE_MS < last_change_time[btn]) return false; - if ((now - last_change_time[btn]) > (REPEAT_START_MS + REPEAT_MS * claimed_repeats[btn])) { + int64_t now = esp_timer_get_time(); + if (now + DEBOUNCE_US < last_change_time[btn]) return false; + if ((now - last_change_time[btn]) > (REPEAT_START_US + REPEAT_US * claimed_repeats[btn])) { claimed_repeats[btn]++; return true; } @@ -145,18 +147,15 @@ int8_t i2c_get_button_repeats(uint8_t btn) { return 0; if (btn >= N_BTNS || !debounced_state[btn]) return false; - uint64_t now = esp_timer_get_time() / 1000; - if (now + DEBOUNCE_MS < last_change_time[btn]) return false; - if ((now - last_change_time[btn]) > (REPEAT_START_MS + REPEAT_MS * claimed_repeats[btn])) { + int64_t now = esp_timer_get_time(); + if (now + DEBOUNCE_US < last_change_time[btn]) return false; + if ((now - last_change_time[btn]) > (REPEAT_START_US + REPEAT_US * claimed_repeats[btn])) { claimed_repeats[btn]++; - if (claimed_repeats[btn] > 100) - claimed_repeats[btn] = 100; - ESP_LOGI("BTN", "RPT %d", (uint8_t)claimed_repeats[btn]+2); + if (claimed_repeats[btn] > MAX_REPEATS) + claimed_repeats[btn] = MAX_REPEATS; return claimed_repeats[btn]+1; } if (debounced_state[btn] && !last_known_state[btn]) { - - ESP_LOGI("BTN", "FST %d", 1); return 1; } @@ -167,6 +166,6 @@ int64_t i2c_get_button_ms(uint8_t btn) { if (!i2c_get_button_state(btn)) return 0; - uint64_t now = esp_timer_get_time() / 1000; + int64_t now = esp_timer_get_time(); return now - last_change_time[btn]; } \ No newline at end of file diff --git a/main/idf_component.yml b/main/idf_component.yml index 8ee682a..cc3338f 100644 --- a/main/idf_component.yml +++ b/main/idf_component.yml @@ -1,5 +1,6 @@ ## IDF Component Manager Manifest File dependencies: + espressif/mdns: "*" joltwallet/littlefs: "==1.20.3" esp-idf-lib/tca95x5: "*" ## Required IDF version diff --git a/main/landingpage.html b/main/landingpage.html index ca9e812..6fdab2d 100644 --- a/main/landingpage.html +++ b/main/landingpage.html @@ -1,27 +1,81 @@ + Control Panel + - + +
+
+

ClusterCommand

+ + + + + +
+ + + + + + + + + + + @@ -35,39 +89,26 @@ - + + + + + - - + - - - - - - - + - - - - - - - - - - - - -
+
Schedule Start
Move DistanceRemain. Distance (ft)
Move Distance (ft) ft
Jack HeightJack Height (in) in
Time
BatteryBattery (V) V
+ + +

@@ -77,17 +118,13 @@ Program RF Remote - - - - - + Calibration - - + + Firmware @@ -101,304 +138,485 @@
+ + + +
+
+
+ - - + \ No newline at end of file diff --git a/main/main.c b/main/main.c index 8d3507e..b6babef 100644 --- a/main/main.c +++ b/main/main.c @@ -15,7 +15,6 @@ #define TAG "MAIN" - int64_t last_log_time = 0; esp_err_t send_log() { @@ -39,8 +38,8 @@ esp_err_t send_log() { int32_t be_counter = htobe32(get_sensor_counter(SENSOR_DRIVE)); memcpy(&entry[25], &be_counter, 4); - entry[29] = get_sensor(SENSOR_DRIVE); - entry[30] = get_sensor(SENSOR_JACK); + entry[29] = get_sensor(SENSOR_SAFETY); + entry[30] = get_sensor(SENSOR_DRIVE); entry[31] = fsm_get_state(); last_log_time = esp_timer_get_time(); @@ -75,7 +74,7 @@ void driveLEDs(led_state_t state) { i2c_set_led1(patterns[state][(esp_timer_get_time()/100000) % 6]); break; case LED_STATE_ERROR: - ESP_LOGE(TAG, "SOME SORT OF ERROR"); + //ESP_LOGE(TAG, "SOME SORT OF ERROR"); i2c_set_led1(patterns[state][(esp_timer_get_time()/1000000) % 2]); break; case LED_STATE_AWAKE: @@ -147,7 +146,7 @@ void app_main(void) { } /*** FULL BOOT ***/ - if (uart_init() != ESP_OK) ESP_LOGE(TAG, "UART FAILED"); + //if (uart_init() != ESP_OK) ESP_LOGE(TAG, "UART FAILED"); if (power_init() != ESP_OK) ESP_LOGE(TAG, "POWER FAILED"); if (rf_433_init() != ESP_OK) ESP_LOGE(TAG, "RF FAILED"); if (fsm_init() != ESP_OK) ESP_LOGE(TAG, "FSM FAILED"); @@ -186,10 +185,16 @@ void app_main(void) { } else{ - if (rtc_is_set()) + if ( + rtc_is_set() && + !efuse_is_tripped(BRIDGE_JACK) && + !efuse_is_tripped(BRIDGE_AUX) && + !efuse_is_tripped(BRIDGE_DRIVE) + ) { driveLEDs(LED_STATE_AWAKE); - else + } else { driveLEDs(LED_STATE_ERROR); + } } // when not actively moving we log at a low frequency @@ -210,6 +215,25 @@ void app_main(void) { } break; + case STATE_CALIBRATE_JACK_DELAY: + if (i2c_get_button_tripped(0)) + fsm_request(FSM_CMD_CALIBRATE_JACK_START); + break; + case STATE_CALIBRATE_JACK_MOVE: + if (i2c_get_button_tripped(0)) + fsm_request(FSM_CMD_CALIBRATE_JACK_END); + break; + + + case STATE_CALIBRATE_DRIVE_DELAY: + if (i2c_get_button_tripped(0)) + fsm_request(FSM_CMD_CALIBRATE_DRIVE_START); + break; + case STATE_CALIBRATE_DRIVE_MOVE: + if (i2c_get_button_tripped(0)) + fsm_request(FSM_CMD_CALIBRATE_DRIVE_END); + break; + default: // it's running in every other case send_log(); diff --git a/main/prvtkey.pem b/main/prvtkey.pem new file mode 100644 index 0000000..4225de8 --- /dev/null +++ b/main/prvtkey.pem @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCc4kQulPmDvj52 +HrvgQPMrGrMsSQdtOKFOFBT0o7uTXXWK2y48TMdy3RKKNVaIu0nhKpsFSBfekyAe +iUJH4N/1ih+byJtUZJ3iMyfDrPoElmAPBQJYkjwvM8V94ug648GV5YF20C9hNOyi +7Z9BIdRvd3DiNexuYz+3C2vRGW/lHu9r7HdK1u4nv9SF10jZhjfa0DidotKaDrul +558QoHskrQkxOQa5hKRcB4KmceRihs5bU9qngrgdSlax0LUBhpBBBsgUxsKdvht3 +C4R55MmAkDWuYYvqa8cAX8+XWylILRjlvktZhDrWFOlXbTxShD9ax3zUfuJRj8Jx +t0/SLamZAgMBAAECggEAA/dwk+DuYhdYSvJB+8yImWlmaFM8XdWVtnypfvn4zyQI +ycb650llrZDLXDU3B+P8XTYPj1WgTN9Za4w64chcwT+Jxw2OZ9bXaxWyBq+D7sPC +j/6nbYfc/7CGaMVo67xAc8LGwDNJT2LgLMpnQWVSkrLpZr7ISI432S/vvOywuJFC +gQVdslNvVDAwC0KU+0Y0P4CTq2gQYeThODMMstRm0Ui/L/nENUNWCNmNd+WQYx4E +8DQfCCLh2u9W7whpYFbaOSQxUzDMRcgZMTzVjU48/oZTagNMEFfYmv5pSQN6Lhf2 +PvBbYRip3h0sdj1gmFuyGOEl0Mw4AzZyeBohxMNSUQKBgQDXy5A+Cd/8dPM8mL88 +RtKrV3+Dy+otML1bK7eDN1jJ6XDCmvOAtWIwH2v1quls7uWX54lDDYLs6F2w5+Hz +dRnfkMO/JtWInYjLqh1pu5iVPbP+6HVSX6wslMvg8K+M5DOsG/q6J62j6e643o9G +fCiNR8rX8V/BdaCvtCBiCtNPjQKBgQC6HOd3302D6PKQSWLJss7QYdEQ5sYesoIu +GW6KfJEh6FafJ/fwJoDOH+9klvN9EBJLlXZa/9NM23DqovI/Ca+ABfFjjzea70+U +f9UbzaAMl6ENKU7vmAyM2WwHdZPJ4PCQ9J7nBkODzKAm++eQh12iOglcIMKdUPiL +72Ygx1bJPQKBgA9Ae/lmiUY2ndpykVGZT9p8XK7cArke8MM428eSadwbe7TFbuBx +8XalQeQjKExitid+Xd03X0GPSs/uE7I5XJLIkI06GW2GdNywMVP/xlEGA2rI00H3 +MRwViDNlz4KNvnkzoQz3MPac2hqG4GmC7PrPUC7jCHmL7sd8W62SRk0hAoGAEwEI +kbD3lVSgECOuNrJPc+/JDVTDPjc0G8j1BKcbmr7CuZW3N4p29JVGOJtBWa/ebmFg +qIIe7WYq7Yqd+dnfVc9FiskBAI0XLy6ucBxbD24cP9/L86MvBOLeqRRUdvTFG8ge +wbBeDINEhzaJurRX10zdz854kN/HwWI8p3QzZHECgYBeDTRyYbi9c7eo6Uyo+pjz +bFWyVtAjzjChHa9ifI6GCgs1qakaNBrwb4yOlheEkuakscZY1myzHwHRH1QTQK2c +4du0I3/JFkk1JmYXw1VLo/BKs2S6RGBx+4jE5bkSXrxnQmT0EtbexkfIJHEAlIqU +DMmi7yrQo4dydJ20IHEF6A== +-----END PRIVATE KEY----- diff --git a/main/rf_433.c b/main/rf_433.c index 67a5e6d..9c9dbe9 100644 --- a/main/rf_433.c +++ b/main/rf_433.c @@ -38,6 +38,7 @@ typedef struct { } rf_code_t; int learn_flag = -1; +bool controls_enabled = true; // For rmt_rx_register_event_callbacks static bool rfrx_done(rmt_channel_handle_t channel, const rmt_rx_done_event_data_t *edata, void *udata) { @@ -129,16 +130,16 @@ static void rf_433_receiver_task(void* param) { // If we got a valid code, process it if (code) { - int64_t encoded = ((int64_t)len << 56) | code; - ESP_LOGI(TAG, "GOT KEYCODE 0x%lx [%d]", (long) code, len); if (learn_flag >= 0) { + // Store just the 32-bit code set_param_value_t(PARAM_KEYCODE_0 + learn_flag, - (param_value_t){.i64 = encoded}); + (param_value_t){.i32 = (int32_t)code}); ESP_LOGI(TAG, "LEARNED KEYCODE"); learn_flag = -1; - } else { + } else if (controls_enabled) { + // Only process RF commands if controls are enabled rf_code_t rf_msg = { .code = code, .high_avg = high / 24, @@ -148,8 +149,9 @@ static void rf_433_receiver_task(void* param) { }; for (uint8_t i = 0; i < NUM_RF_BUTTONS; i++) { - int64_t match = get_param_value_t(PARAM_KEYCODE_0+i).i64; - if (encoded == match) { + int32_t match = get_param_value_t(PARAM_KEYCODE_0+i).i32; + // Compare just the code (lower 32 bits) + if ((uint32_t)match == code) { switch (i) { case 0: pulseOverride(RELAY_A1); pulseOverride(RELAY_A3); break; case 1: pulseOverride(RELAY_B1); pulseOverride(RELAY_A3); break; @@ -223,4 +225,12 @@ void rf_433_learn_keycode(uint8_t index) { void rf_433_cancel_learn_keycode() { learn_flag = -1; +} + +void rf_433_disable_controls() { + controls_enabled = false; +} + +void rf_433_enable_controls() { + controls_enabled = true; } \ No newline at end of file diff --git a/main/rf_433.h b/main/rf_433.h index d982d40..bb2a169 100644 --- a/main/rf_433.h +++ b/main/rf_433.h @@ -1,4 +1,3 @@ - #ifndef RF_H #define RF_H @@ -27,4 +26,7 @@ int64_t rf_433_get_raw_keycode(); void rf_433_learn_keycode(uint8_t index); void rf_433_cancel_learn_keycode(); +void rf_433_disable_controls(); +void rf_433_enable_controls(); + #endif \ No newline at end of file diff --git a/main/sensors.h b/main/sensors.h index b35ee3d..7135a94 100644 --- a/main/sensors.h +++ b/main/sensors.h @@ -16,9 +16,9 @@ #define SENSOR_DEBOUNCE_US 500 // Reduced to 0.5 ms for responsiveness typedef enum { - SENSOR_DRIVE = 0, - SENSOR_JACK = 1, - N_SENSORS = 2 + SENSOR_SAFETY = 0, + SENSOR_DRIVE = 1, + N_SENSORS = 2 } sensor_t; void reset_sensor_counter(sensor_t i); diff --git a/main/servercert.pem b/main/servercert.pem new file mode 100644 index 0000000..731e6b4 --- /dev/null +++ b/main/servercert.pem @@ -0,0 +1,19 @@ +-----BEGIN CERTIFICATE----- +MIIDIjCCAgqgAwIBAgIUDpXEqSZ2cdhTBSkwUpC6uSIsfvEwDQYJKoZIhvcNAQEL +BQAwEzERMA8GA1UEAwwIc2MubG9jYWwwHhcNMjUxMjMwMTcyMDMwWhcNMzUxMjI4 +MTcyMDMwWjATMREwDwYDVQQDDAhzYy5sb2NhbDCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAJziRC6U+YO+PnYeu+BA8ysasyxJB204oU4UFPSju5NddYrb +LjxMx3LdEoo1Voi7SeEqmwVIF96TIB6JQkfg3/WKH5vIm1RkneIzJ8Os+gSWYA8F +AliSPC8zxX3i6DrjwZXlgXbQL2E07KLtn0Eh1G93cOI17G5jP7cLa9EZb+Ue72vs +d0rW7ie/1IXXSNmGN9rQOJ2i0poOu6XnnxCgeyStCTE5BrmEpFwHgqZx5GKGzltT +2qeCuB1KVrHQtQGGkEEGyBTGwp2+G3cLhHnkyYCQNa5hi+prxwBfz5dbKUgtGOW+ +S1mEOtYU6VdtPFKEP1rHfNR+4lGPwnG3T9ItqZkCAwEAAaNuMGwwHQYDVR0OBBYE +FICBmIRVzS0CQHS5OZmXSLQcTOz6MB8GA1UdIwQYMBaAFICBmIRVzS0CQHS5OZmX +SLQcTOz6MA8GA1UdEwEB/wQFMAMBAf8wGQYDVR0RBBIwEIIIc2MubG9jYWyHBMCo +BAEwDQYJKoZIhvcNAQELBQADggEBAIn1zeotOH72CcRUq5e+nsKLRCZSUZV1Gvip +nTADfFI8MpMGe0ikPJqetSYmP1HVIzGWQlWamqGhXckBeR9uq1e2k1Jsjf80w6o6 +ild+fr1oga7n1xwXIMumDbSFjtsWe0fO9xI5NVGP3h6ikj1SN0o6T5EtTyjZ+vGw +u73tFmD7c/YBKkvLlP1UxVbAvJFEHL+O7e3QiIzeyryWFDEWRjOHPuPLCV84J5Q6 +55mzfuUFkf7piLpLUXZ6lJ3MYa+iylll7Z9jQ8W5LWPpZhbTwyK4j7L6IiJoluzL +eV0ZuqoHda9Igd+Gigih1YOH4raMc98KVrNIUjNFoWlOx4rvWkY= +-----END CERTIFICATE----- diff --git a/main/simple_dns_server.c b/main/simple_dns_server.c new file mode 100644 index 0000000..3501c60 --- /dev/null +++ b/main/simple_dns_server.c @@ -0,0 +1,143 @@ +#include "simple_dns_server.h" +#include "lwip/sockets.h" +#include "lwip/netdb.h" +#include "esp_log.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include + +static const char *TAG = "DNS_SERVER"; +static int dns_socket = -1; +static TaskHandle_t dns_task_handle = NULL; +static char dns_ip[16] = {0}; + +// DNS header structure +typedef struct { + uint16_t id; + uint16_t flags; + uint16_t qdcount; + uint16_t ancount; + uint16_t nscount; + uint16_t arcount; +} dns_header_t; + +static void dns_server_task(void *pvParameters) { + char rx_buffer[512]; + char tx_buffer[512]; + struct sockaddr_in dest_addr; + + dest_addr.sin_addr.s_addr = htonl(INADDR_ANY); + dest_addr.sin_family = AF_INET; + dest_addr.sin_port = htons(53); + + dns_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP); + if (dns_socket < 0) { + ESP_LOGE(TAG, "Unable to create socket: errno %d", errno); + vTaskDelete(NULL); + return; + } + + int err = bind(dns_socket, (struct sockaddr *)&dest_addr, sizeof(dest_addr)); + if (err < 0) { + ESP_LOGE(TAG, "Socket bind failed: errno %d", errno); + close(dns_socket); + vTaskDelete(NULL); + return; + } + + ESP_LOGI(TAG, "DNS server started on port 53"); + + while (1) { + struct sockaddr_in source_addr; + socklen_t socklen = sizeof(source_addr); + + int len = recvfrom(dns_socket, rx_buffer, sizeof(rx_buffer) - 1, 0, + (struct sockaddr *)&source_addr, &socklen); + + if (len < 0) { + ESP_LOGE(TAG, "recvfrom failed: errno %d", errno); + break; + } + + if (len < sizeof(dns_header_t)) { + continue; + } + + // Parse DNS query + dns_header_t *header = (dns_header_t *)rx_buffer; + + // Build DNS response + memcpy(tx_buffer, rx_buffer, len); + dns_header_t *response = (dns_header_t *)tx_buffer; + + // Set response flags + response->flags = htons(0x8180); // Standard query response, no error + response->ancount = htons(1); // One answer + + // Add answer section (Type A record) + int pos = len; + + // Name pointer to question + tx_buffer[pos++] = 0xC0; + tx_buffer[pos++] = 0x0C; + + // Type A + tx_buffer[pos++] = 0x00; + tx_buffer[pos++] = 0x01; + + // Class IN + tx_buffer[pos++] = 0x00; + tx_buffer[pos++] = 0x01; + + // TTL (60 seconds) + tx_buffer[pos++] = 0x00; + tx_buffer[pos++] = 0x00; + tx_buffer[pos++] = 0x00; + tx_buffer[pos++] = 0x3C; + + // Data length (4 bytes for IPv4) + tx_buffer[pos++] = 0x00; + tx_buffer[pos++] = 0x04; + + // IP address + int a, b, c, d; + sscanf(dns_ip, "%d.%d.%d.%d", &a, &b, &c, &d); + tx_buffer[pos++] = a; + tx_buffer[pos++] = b; + tx_buffer[pos++] = c; + tx_buffer[pos++] = d; + + // Send response + sendto(dns_socket, tx_buffer, pos, 0, + (struct sockaddr *)&source_addr, sizeof(source_addr)); + } + + close(dns_socket); + dns_socket = -1; + vTaskDelete(NULL); +} + +esp_err_t simple_dns_server_start(const char *ap_ip) { + if (dns_task_handle != NULL) { + ESP_LOGW(TAG, "DNS server already running"); + return ESP_ERR_INVALID_STATE; + } + + strncpy(dns_ip, ap_ip, sizeof(dns_ip) - 1); + + xTaskCreate(dns_server_task, "dns_server", 4096, NULL, 5, &dns_task_handle); + + return ESP_OK; +} + +void simple_dns_server_stop(void) { + if (dns_task_handle != NULL) { + if (dns_socket >= 0) { + close(dns_socket); + dns_socket = -1; + } + vTaskDelete(dns_task_handle); + dns_task_handle = NULL; + ESP_LOGI(TAG, "DNS server stopped"); + } +} \ No newline at end of file diff --git a/main/simple_dns_server.h b/main/simple_dns_server.h new file mode 100644 index 0000000..1582253 --- /dev/null +++ b/main/simple_dns_server.h @@ -0,0 +1,19 @@ +#ifndef SIMPLE_DNS_SERVER_H +#define SIMPLE_DNS_SERVER_H + +#include "esp_err.h" + +/** + * @brief Start a simple DNS server that redirects all queries to the AP IP + * + * @param ap_ip The IP address to return for all DNS queries (e.g., "192.168.4.1") + * @return esp_err_t ESP_OK on success + */ +esp_err_t simple_dns_server_start(const char *ap_ip); + +/** + * @brief Stop the DNS server + */ +void simple_dns_server_stop(void); + +#endif // SIMPLE_DNS_SERVER_H \ No newline at end of file diff --git a/main/storage.c b/main/storage.c index b373bb4..81b373b 100644 --- a/main/storage.c +++ b/main/storage.c @@ -1,9 +1,12 @@ +#include #include #include "esp_partition.h" #include "esp_err.h" #include "esp_log.h" #include "esp_crc.h" #include "storage.h" +#include "freertos/FreeRTOS.h" +#include "freertos/semphr.h" #define TAG "STORAGE" @@ -51,19 +54,34 @@ const char parameter_units[NUM_PARAMS][8] = { }; #undef PARAM_DEF - // Partition pointer static const esp_partition_t *storage_partition = NULL; - -// Log head tracking +// Log head tracking with mutex protection static uint32_t log_head_index = 0; static uint32_t log_tail_index = 0; -uint32_t get_log_head() { return LOG_START_OFFSET + (log_head_index * LOG_ENTRY_SIZE); } -uint32_t get_log_tail() { return LOG_START_OFFSET + (log_tail_index * LOG_ENTRY_SIZE); } -uint32_t get_log_offset() { return LOG_START_OFFSET; } +static SemaphoreHandle_t log_mutex = NULL; static bool log_initialized = false; +uint32_t get_log_head(void) { + uint32_t head; + if (log_mutex) xSemaphoreTake(log_mutex, portMAX_DELAY); + head = LOG_START_OFFSET + (log_head_index * LOG_ENTRY_SIZE); + if (log_mutex) xSemaphoreGive(log_mutex); + return head; +} + +uint32_t get_log_tail(void) { + uint32_t tail; + if (log_mutex) xSemaphoreTake(log_mutex, portMAX_DELAY); + tail = LOG_START_OFFSET + (log_tail_index * LOG_ENTRY_SIZE); + if (log_mutex) xSemaphoreGive(log_mutex); + return tail; +} + +uint32_t get_log_offset(void) { + return LOG_START_OFFSET; +} // ============================================================================ // PARAMETER FUNCTIONS @@ -88,6 +106,43 @@ esp_err_t set_param_value_t(param_idx_t id, param_value_t val) { return ESP_OK; } +esp_err_t set_param_string(param_idx_t id, const char* str) { + if (id >= NUM_PARAMS) { + ESP_LOGE(TAG, "Invalid parameter ID: %d", id); + return ESP_ERR_INVALID_ARG; + } + + if (parameter_types[id] != PARAM_TYPE_str) { + ESP_LOGE(TAG, "Parameter %d (%s) is not a string type", id, parameter_names[id]); + return ESP_ERR_INVALID_ARG; + } + + if (str == NULL) { + parameter_table[id].str[0] = '\0'; + } else { + strncpy(parameter_table[id].str, str, 15); + parameter_table[id].str[15] = '\0'; // Ensure null termination + } + + ESP_LOGI(TAG, "String parameter %d (%s) set to '%s' (not committed)", + id, parameter_names[id], parameter_table[id].str); + return ESP_OK; +} + +char* get_param_string(param_idx_t id) { + if (id >= NUM_PARAMS) { + ESP_LOGE(TAG, "Invalid parameter ID: %d", id); + return ""; + } + + if (parameter_types[id] != PARAM_TYPE_str) { + ESP_LOGE(TAG, "Parameter %d (%s) is not a string type", id, parameter_names[id]); + return ""; + } + + return parameter_table[id].str; +} + param_type_e get_param_type(param_idx_t id) { if (id >= NUM_PARAMS) { return PARAM_TYPE_u64; // Default fallback @@ -95,6 +150,63 @@ param_type_e get_param_type(param_idx_t id) { return parameter_types[id]; } +// ============================================================================ +// JSON-FRIENDLY STRING CONVERSION +// ============================================================================ +const char* get_param_json_string(param_idx_t id, char* buffer, size_t buf_size) { + if (id >= NUM_PARAMS || buffer == NULL || buf_size == 0) { + if (buffer && buf_size > 0) buffer[0] = '\0'; + return ""; + } + + param_type_e type = parameter_types[id]; + param_value_t val = parameter_table[id]; + + switch(type) { + case PARAM_TYPE_u16: + snprintf(buffer, buf_size, "%u", val.u16); + break; + case PARAM_TYPE_i16: + snprintf(buffer, buf_size, "%d", val.i16); + break; + case PARAM_TYPE_u32: + snprintf(buffer, buf_size, "%lu", (unsigned long)val.u32); + break; + case PARAM_TYPE_i32: + snprintf(buffer, buf_size, "%ld", (long)val.i32); + break; + case PARAM_TYPE_u64: + snprintf(buffer, buf_size, "%llu", (unsigned long long)val.u64); + break; + case PARAM_TYPE_i64: + snprintf(buffer, buf_size, "%lld", (long long)val.i64); + break; + case PARAM_TYPE_f32: + if (isnan(val.f32) || isinf(val.f32)) { + snprintf(buffer, buf_size, "null"); + } else { + snprintf(buffer, buf_size, "%.6g", val.f32); + } + break; + case PARAM_TYPE_f64: + if (isnan(val.f64) || isinf(val.f64)) { + snprintf(buffer, buf_size, "null"); + } else { + snprintf(buffer, buf_size, "%.15g", val.f64); + } + break; + case PARAM_TYPE_str: + // Escape quotes and backslashes for JSON string + snprintf(buffer, buf_size, "\"%s\"", val.str); + break; + default: + snprintf(buffer, buf_size, "null"); + break; + } + + return buffer; +} + const char* get_param_name(param_idx_t id) { if (id >= NUM_PARAMS) { return "INVALID"; @@ -117,33 +229,125 @@ const char* get_param_unit(param_idx_t id) { return parameter_units[id]; } -esp_err_t commit_params() { +// ============================================================================ +// STORAGE HELPER: Pack parameter value into buffer +// ============================================================================ +static void pack_param(uint8_t *dest, param_idx_t id) { + param_type_e type = parameter_types[id]; + + switch(type) { + case PARAM_TYPE_u16: + memcpy(dest, ¶meter_table[id].u16, 2); + break; + case PARAM_TYPE_i16: + memcpy(dest, ¶meter_table[id].i16, 2); + break; + case PARAM_TYPE_u32: + memcpy(dest, ¶meter_table[id].u32, 4); + break; + case PARAM_TYPE_i32: + memcpy(dest, ¶meter_table[id].i32, 4); + break; + case PARAM_TYPE_f32: + memcpy(dest, ¶meter_table[id].f32, 4); + break; + case PARAM_TYPE_u64: + memcpy(dest, ¶meter_table[id].u64, 8); + break; + case PARAM_TYPE_i64: + memcpy(dest, ¶meter_table[id].i64, 8); + break; + case PARAM_TYPE_f64: + memcpy(dest, ¶meter_table[id].f64, 8); + break; + case PARAM_TYPE_str: + memcpy(dest, parameter_table[id].str, 16); + break; + } +} + +// ============================================================================ +// STORAGE HELPER: Unpack parameter value from buffer +// ============================================================================ +static void unpack_param(const uint8_t *src, param_idx_t id) { + param_type_e type = parameter_types[id]; + + switch(type) { + case PARAM_TYPE_u16: + memcpy(¶meter_table[id].u16, src, 2); + break; + case PARAM_TYPE_i16: + memcpy(¶meter_table[id].i16, src, 2); + break; + case PARAM_TYPE_u32: + memcpy(¶meter_table[id].u32, src, 4); + break; + case PARAM_TYPE_i32: + memcpy(¶meter_table[id].i32, src, 4); + break; + case PARAM_TYPE_f32: + memcpy(¶meter_table[id].f32, src, 4); + break; + case PARAM_TYPE_u64: + memcpy(¶meter_table[id].u64, src, 8); + break; + case PARAM_TYPE_i64: + memcpy(¶meter_table[id].i64, src, 8); + break; + case PARAM_TYPE_f64: + memcpy(¶meter_table[id].f64, src, 8); + break; + case PARAM_TYPE_str: + memcpy(parameter_table[id].str, src, 16); + parameter_table[id].str[15] = '\0'; // Ensure null termination + break; + } +} + +// ============================================================================ +// COMMIT PARAMETERS TO FLASH +// ============================================================================ +esp_err_t commit_params(void) { if (storage_partition == NULL) { ESP_LOGE(TAG, "Storage partition not initialized"); return ESP_FAIL; } - // Prepare storage buffer with parameters and CRCs - param_stored_t params_to_store[NUM_PARAMS]; + // Calculate flash offset for each parameter + uint32_t flash_offset = PARAMS_OFFSET; + // Erase the parameter sectors + esp_err_t err = esp_partition_erase_range(storage_partition, PARAMS_OFFSET, + LOG_START_OFFSET); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Failed to erase parameter sectors: %s", esp_err_to_name(err)); + return ESP_FAIL; + } + + // Write each parameter with its CRC for (int i = 0; i < NUM_PARAMS; i++) { - params_to_store[i].val = parameter_table[i]; - // Calculate CRC32 for each parameter value - params_to_store[i].crc = esp_crc32_le(0, (uint8_t*)¶meter_table[i], sizeof(param_value_t)); - } - - // Erase the sectors for parameter storage - esp_err_t err = esp_partition_erase_range(storage_partition, PARAMS_OFFSET, LOG_START_OFFSET); - if (err != ESP_OK) { - ESP_LOGE(TAG, "Failed to erase parameter sector: %s", esp_err_to_name(err)); - return ESP_FAIL; - } - - // Write parameters to flash - err = esp_partition_write(storage_partition, PARAMS_OFFSET, params_to_store, PARAMS_TOTAL_SIZE); - if (err != ESP_OK) { - ESP_LOGE(TAG, "Failed to write parameters: %s", esp_err_to_name(err)); - return ESP_FAIL; + param_stored_t stored; + memset(&stored, 0, sizeof(stored)); + + // Pack the parameter value + uint8_t size = param_type_size(parameter_types[i]); + pack_param(stored.data, i); + + // Calculate CRC over the actual data size used + uint32_t crc_input = PARAM_CRC_SALT; + //uint32_t crc = esp_crc32_le(0, (uint8_t*)&crc_input, sizeof(crc_input)); + stored.crc = esp_crc32_le(crc_input, stored.data, size); + + // Write to flash + err = esp_partition_write(storage_partition, flash_offset, + &stored, sizeof(param_stored_t)); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Failed to write parameter %d (%s): %s", + i, parameter_names[i], esp_err_to_name(err)); + return ESP_FAIL; + } + + flash_offset += sizeof(param_stored_t); } ESP_LOGI(TAG, "Parameters committed to flash successfully"); @@ -165,31 +369,44 @@ esp_err_t storage_init(void) { return ESP_ERR_NOT_FOUND; } - ESP_LOGI(TAG, "Storage partition found: size=%lu bytes", (unsigned long)storage_partition->size); + ESP_LOGI(TAG, "Storage partition found: size=%lu bytes", + (unsigned long)storage_partition->size); // Load parameters from flash - param_stored_t params_stored[NUM_PARAMS]; - esp_err_t err = esp_partition_read(storage_partition, PARAMS_OFFSET, - params_stored, PARAMS_TOTAL_SIZE); - - if (err != ESP_OK) { - ESP_LOGW(TAG, "Failed to read parameters, using defaults"); - return err; - } - - // Validate and load each parameter + uint32_t flash_offset = PARAMS_OFFSET; bool all_valid = true; + for (int i = 0; i < NUM_PARAMS; i++) { - uint32_t calculated_crc = esp_crc32_le(0, (uint8_t*)¶ms_stored[i].val, - sizeof(param_value_t)); + param_stored_t stored; - if (calculated_crc == params_stored[i].crc) { - parameter_table[i] = params_stored[i].val; + esp_err_t err = esp_partition_read(storage_partition, flash_offset, + &stored, sizeof(param_stored_t)); + + if (err != ESP_OK) { + ESP_LOGW(TAG, "Failed to read parameter %d (%s), using default", + i, parameter_names[i]); + memcpy(¶meter_table[i], ¶meter_defaults[i], sizeof(param_value_t)); // SET DEFAULT HERE + all_valid = false; + flash_offset += sizeof(param_stored_t); + continue; + } + + // Validate CRC over actual data size + uint8_t size = param_type_size(parameter_types[i]); + uint32_t crc_input = PARAM_CRC_SALT; + //uint32_t crc = esp_crc32_le(0, (uint8_t*)&crc_input, sizeof(crc_input)); + uint32_t calculated_crc = esp_crc32_le(crc_input, stored.data, size); + + if (calculated_crc == stored.crc) { + unpack_param(stored.data, i); } else { ESP_LOGW(TAG, "Parameter %d (%s) failed CRC check, using default", i, parameter_names[i]); + memcpy(¶meter_table[i], ¶meter_defaults[i], sizeof(param_value_t)); // SET DEFAULT HERE all_valid = false; } + + flash_offset += sizeof(param_stored_t); } if (all_valid) { @@ -202,7 +419,7 @@ esp_err_t storage_init(void) { } // ============================================================================ -// LOGGING FUNCTIONS +// LOGGING FUNCTIONS (unchanged from original) // ============================================================================ static esp_err_t find_log_head(void) { @@ -210,16 +427,13 @@ static esp_err_t find_log_head(void) { return ESP_ERR_INVALID_STATE; } - // Calculate total log area size uint32_t log_area_size = storage_partition->size - LOG_START_OFFSET; uint32_t max_entries = log_area_size / LOG_ENTRY_SIZE; - // Read through entries to find first uninitialized (all 0xFF) uint8_t entry[LOG_ENTRY_SIZE]; uint8_t empty_entry[LOG_ENTRY_SIZE]; memset(empty_entry, 0xFF, LOG_ENTRY_SIZE); - // Binary search would be faster, but linear is safer for circular buffer for (uint32_t i = 0; i < max_entries; i++) { uint32_t offset = LOG_START_OFFSET + (i * LOG_ENTRY_SIZE); @@ -229,7 +443,6 @@ static esp_err_t find_log_head(void) { return err; } - // Check if this entry is uninitialized if (memcmp(entry, empty_entry, LOG_ENTRY_SIZE) == 0) { log_head_index = i; ESP_LOGI(TAG, "Log head found at index %lu", (unsigned long)log_head_index); @@ -237,11 +450,9 @@ static esp_err_t find_log_head(void) { } } - // If we get here, all entries are full - wrap to beginning log_head_index = 0; ESP_LOGI(TAG, "Log is full, wrapping to beginning"); - // Erase the first log sector to start fresh esp_err_t err = esp_partition_erase_range(storage_partition, LOG_START_OFFSET, FLASH_SECTOR_SIZE); if (err != ESP_OK) { @@ -258,8 +469,16 @@ esp_err_t log_init(void) { return ESP_ERR_INVALID_STATE; } + log_mutex = xSemaphoreCreateMutex(); + if (log_mutex == NULL) { + ESP_LOGE(TAG, "Failed to create log mutex"); + return ESP_ERR_NO_MEM; + } + esp_err_t err = find_log_head(); if (err != ESP_OK) { + vSemaphoreDelete(log_mutex); + log_mutex = NULL; return err; } @@ -273,111 +492,121 @@ esp_err_t write_log(char* entry) { return ESP_FAIL; } + if (log_mutex) xSemaphoreTake(log_mutex, portMAX_DELAY); + uint32_t log_area_end = storage_partition->size; uint32_t max_entries = (log_area_end - LOG_START_OFFSET) / LOG_ENTRY_SIZE; - //uint32_t max_sectors = max_entries / FLASH_SECTOR_SIZE; - // Calculate current offset uint32_t current_offset = LOG_START_OFFSET + (log_head_index * LOG_ENTRY_SIZE); - - // Check if we need to erase the next sector - uint32_t current_sector = current_offset / FLASH_SECTOR_SIZE; uint32_t next_offset = current_offset + LOG_ENTRY_SIZE; - if (next_offset >= log_area_end) - next_offset = LOG_START_OFFSET; + if (next_offset >= log_area_end) { + next_offset = LOG_START_OFFSET; + } + + uint32_t current_sector = current_offset / FLASH_SECTOR_SIZE; uint32_t next_sector = next_offset / FLASH_SECTOR_SIZE; - // If we're crossing into a new sector, check if it needs erasing if (next_sector != current_sector) { - // Check if next sector is uninitialized uint8_t check_byte; esp_err_t err = esp_partition_read(storage_partition, next_sector * FLASH_SECTOR_SIZE, &check_byte, 1); if (err == ESP_OK && check_byte != 0xFF) { - // Sector needs erasing ESP_LOGI(TAG, "Erasing sector %lu for log", (unsigned long)next_sector); err = esp_partition_erase_range(storage_partition, next_sector * FLASH_SECTOR_SIZE, FLASH_SECTOR_SIZE); - log_tail_index = (next_sector)*FLASH_SECTOR_SIZE/LOG_ENTRY_SIZE; - if (log_tail_index >= max_entries) - log_tail_index = 0; - - - ESP_LOGI(TAG, "Tail/Head are now %ld/%ld", (long)log_tail_index, (long)log_head_index); - if (err != ESP_OK) { ESP_LOGE(TAG, "Failed to erase sector: %s", esp_err_to_name(err)); + if (log_mutex) xSemaphoreGive(log_mutex); return ESP_FAIL; } - } else if (err == ESP_OK) { - ESP_LOGI(TAG, "Next sector %ld clear, no erasing needed", (unsigned long)next_sector); - } else { - ESP_LOGE(TAG, "Error checking byte (sector %ld)", (unsigned long)next_sector); - } + + uint32_t tail_offset = next_sector * FLASH_SECTOR_SIZE; + if (tail_offset < LOG_START_OFFSET) { + tail_offset = LOG_START_OFFSET; + } + log_tail_index = (tail_offset - LOG_START_OFFSET) / LOG_ENTRY_SIZE; + + if (log_tail_index >= max_entries) { + log_tail_index = 0; + } + + ESP_LOGI(TAG, "Tail/Head are now %ld/%ld", (long)log_tail_index, (long)log_head_index); + } } - // Write the log entry esp_err_t err = esp_partition_write(storage_partition, current_offset, entry, LOG_ENTRY_SIZE); if (err != ESP_OK) { ESP_LOGE(TAG, "Failed to write log entry: %s", esp_err_to_name(err)); + if (log_mutex) xSemaphoreGive(log_mutex); return ESP_FAIL; } - //ESP_LOGI(TAG, "Log @ sector %lu / index %lu / offset %lu", (unsigned long) current_sector, (unsigned long) log_head_index, (unsigned long)current_offset); - - log_head_index++; if (log_head_index >= max_entries) { log_head_index = 0; ESP_LOGI(TAG, "Log wrapped to beginning"); } + if (log_mutex) xSemaphoreGive(log_mutex); return ESP_OK; } -esp_err_t write_dummy_log_1() { - log_head_index = 0; - log_tail_index = 0; +esp_err_t write_dummy_log_1(void) { + if (log_mutex) xSemaphoreTake(log_mutex, portMAX_DELAY); + log_head_index = 0; + log_tail_index = 0; + if (log_mutex) xSemaphoreGive(log_mutex); + uint32_t log_area_end = storage_partition->size; uint32_t max_entries = (log_area_end - LOG_START_OFFSET) / LOG_ENTRY_SIZE; - for (uint32_t i=0; i>24,i>>16,i>>8,i>>0}; - write_log(entry); - } - return ESP_OK; + for (uint32_t i=0; i>24,i>>16,i>>8,i>>0}; + write_log(entry); + } + return ESP_OK; } -esp_err_t write_dummy_log_2() { - log_head_index = 56; - log_tail_index = 105; +esp_err_t write_dummy_log_2(void) { + if (log_mutex) xSemaphoreTake(log_mutex, portMAX_DELAY); + log_head_index = 56; + log_tail_index = 105; + if (log_mutex) xSemaphoreGive(log_mutex); + uint32_t log_area_end = storage_partition->size; uint32_t max_entries = (log_area_end - LOG_START_OFFSET) / LOG_ENTRY_SIZE; - for (uint32_t i=0; i>24,i>>16,i>>8,i>>0}; - write_log(entry); - } - return ESP_OK; + for (uint32_t i=0; i>24,i>>16,i>>8,i>>0}; + write_log(entry); + } + return ESP_OK; } -esp_err_t write_dummy_log_3() { - log_head_index = 105; - log_tail_index = 34; +esp_err_t write_dummy_log_3(void) { + if (log_mutex) xSemaphoreTake(log_mutex, portMAX_DELAY); + log_head_index = 105; + log_tail_index = 34; + if (log_mutex) xSemaphoreGive(log_mutex); + uint32_t log_area_end = storage_partition->size; uint32_t max_entries = (log_area_end - LOG_START_OFFSET) / LOG_ENTRY_SIZE; - for (uint32_t i=0; i>24,i>>16,i>>8,i>>0}; - write_log(entry); - } - return ESP_OK; + for (uint32_t i=0; i>24,i>>16,i>>8,i>>0}; + write_log(entry); + } + return ESP_OK; } void storage_deinit(void) { storage_partition = NULL; log_initialized = false; + if (log_mutex) { + vSemaphoreDelete(log_mutex); + log_mutex = NULL; + } } \ No newline at end of file diff --git a/main/storage.h b/main/storage.h index 6abb79e..c8d4071 100644 --- a/main/storage.h +++ b/main/storage.h @@ -1,5 +1,5 @@ /* - * storage.h + * storage.h - Simple variable-size parameter storage with per-param CRC * * Created on: Nov 5, 2025 * Author: Thad @@ -17,9 +17,10 @@ #include #include "i2c.h" +#define PARAM_CRC_SALT 0xDEADBEEF // Salt to prevent all-zero CRC collision + +// Union for parameter values - now sized appropriately typedef union { - uint8_t u8; - int8_t i8; uint16_t u16; int16_t i16; uint32_t u32; @@ -28,25 +29,43 @@ typedef union { int64_t i64; float f32; double f64; + char str[16]; // 15 chars + null terminator } param_value_t; -typedef struct { - param_value_t val; - uint32_t crc; +// Enum for parameter types +typedef enum { + PARAM_TYPE_u16 = 0, + PARAM_TYPE_i16 = 1, + PARAM_TYPE_u32 = 2, + PARAM_TYPE_i32 = 3, + PARAM_TYPE_u64 = 4, + PARAM_TYPE_i64 = 5, + PARAM_TYPE_f32 = 6, + PARAM_TYPE_f64 = 7, + PARAM_TYPE_str = 8 +} param_type_e; + +// Storage format: each param stored as [data][crc32] +typedef struct __attribute__((packed)) { + uint8_t data[16]; // Max size needed (for strings) + uint32_t crc; // CRC of actual data bytes used } param_stored_t; -typedef enum { - PARAM_TYPE_u8, - PARAM_TYPE_i8, - PARAM_TYPE_u16, - PARAM_TYPE_i16, - PARAM_TYPE_u32, - PARAM_TYPE_i32, - PARAM_TYPE_u64, - PARAM_TYPE_i64, - PARAM_TYPE_f32, - PARAM_TYPE_f64 -} param_type_e; +// Get storage size for a given type (data only, not including CRC) +static inline uint8_t param_type_size(param_type_e type) { + switch(type) { + case PARAM_TYPE_u16: + case PARAM_TYPE_i16: return 2; + case PARAM_TYPE_u32: + case PARAM_TYPE_i32: + case PARAM_TYPE_f32: return 4; + case PARAM_TYPE_u64: + case PARAM_TYPE_i64: + case PARAM_TYPE_f64: return 8; + case PARAM_TYPE_str: return 16; + default: return 8; // Fallback + } +} // ============================================================================ // PARAMETER DEFINITION MACRO @@ -56,9 +75,9 @@ typedef enum { // Examples: // PARAM_DEF(NUM_MOVES, u32, 0, "") // PARAM_DEF(EFUSE_1_AS, u16, 2400, "mA") -// PARAM_DEF(JACK_DIST, u8, 5, "mm") // PARAM_DEF(KEYCODE_0, i64, -1, "") // PARAM_DEF(TEMPERATURE, f32, 25.5, "C") +// PARAM_DEF(DEVICE_NAME, str, "ESP32", "") // ============================================================================ // REMEMBER: ORDER IS IMPERATIVE! PARAMETERS ARE ENTERED IN THE TABLE BY INDEX! // ============================================================================ @@ -68,39 +87,40 @@ typedef enum { PARAM_DEF(NUM_MOVES, u32, 0, "") \ PARAM_DEF(MOVE_START, u32, 0, "s") \ PARAM_DEF(MOVE_END, u32, 0, "s") \ - PARAM_DEF(DRIVE_DIST, u16, 10, "ft") /*4*/\ - PARAM_DEF(JACK_DIST, u8, 5, "in") \ + PARAM_DEF(DRIVE_DIST, f32, 10, "ft") \ + PARAM_DEF(JACK_DIST, f32, 5, "in") \ PARAM_DEF(DRIVE_KE, f32, 4000, "n/ft") \ PARAM_DEF(DRIVE_KT, f32, 600, "ms/ft") \ - PARAM_DEF(JACK_KT, f32, 600, "ms/in") /*8*/\ - PARAM_DEF(KEYCODE_0, i64, 0x19000000005D0C61, "") \ - PARAM_DEF(KEYCODE_1, i64, 0x19000000005D0C62, "") \ - PARAM_DEF(KEYCODE_2, i64, 0x19000000005D0C64, "") \ - PARAM_DEF(KEYCODE_3, i64, 0x19000000005D0C68, "") /*12*/\ - PARAM_DEF(KEYCODE_4, i64, -1, "") \ - PARAM_DEF(KEYCODE_5, i64, -1, "") \ - PARAM_DEF(KEYCODE_6, i64, -1, "") \ - PARAM_DEF(KEYCODE_7, i64, -1, "") /*16*/\ + PARAM_DEF(JACK_KT, f32, 600, "ms/in") \ + PARAM_DEF(KEYCODE_0, i32, -1, "") \ + PARAM_DEF(KEYCODE_1, i32, -1, "") \ + PARAM_DEF(KEYCODE_2, i32, -1, "") \ + PARAM_DEF(KEYCODE_3, i32, -1, "") \ + PARAM_DEF(KEYCODE_4, i32, -1, "") \ + PARAM_DEF(KEYCODE_5, i32, -1, "") \ + PARAM_DEF(KEYCODE_6, i32, -1, "") \ + PARAM_DEF(KEYCODE_7, i32, -1, "") \ PARAM_DEF(ADC_ALPHA_BATTERY, f32, 0.02, "-") \ PARAM_DEF(ADC_ALPHA_ISENS, f32, 0.02, "-") \ PARAM_DEF(ADC_ALPHA_IAZ, f32, 0.005, "-") \ - PARAM_DEF(ADC_DB_IAZ, f32, 5.0, "A") /*20*/\ + PARAM_DEF(ADC_DB_IAZ, f32, 5.0, "A") \ PARAM_DEF(EFUSE_INOM_1, f32, 40.0, "A") \ PARAM_DEF(EFUSE_INOM_2, f32, 6.0, "A") \ PARAM_DEF(EFUSE_INOM_3, f32, 2.0, "A") \ - PARAM_DEF(EFUSE_HEAT_THRESH, f32, 60.0, "i/i^2-s") /*24*/\ + PARAM_DEF(EFUSE_HEAT_THRESH, f32, 60.0, "i/i^2-s") \ PARAM_DEF(EFUSE_KINST, f32, 4.0, "i/i") \ PARAM_DEF(EFUSE_TAUCOOL, f32, 0.2, "i") \ PARAM_DEF(EFUSE_TCOOL, i64, 5000000, "us") \ - PARAM_DEF(LOW_PROTECTION_V, f32, 10.0, "V") /*28*/\ + PARAM_DEF(LOW_PROTECTION_V, f32, 10.0, "V") \ PARAM_DEF(LOW_PROTECTION_S, i64, 10, "s") \ PARAM_DEF(CHG_LOW_V, f32, 5.0, "V") \ - PARAM_DEF(CHG_LOW_S, i64, 5.0, "s") \ - PARAM_DEF(CHG_BULK_S, i64, 20, "s") /*32*/\ + PARAM_DEF(CHG_LOW_S, i64, 5, "s") \ + PARAM_DEF(CHG_BULK_S, i64, 20, "s") \ PARAM_DEF(RF_PULSE_LENGTH, u64, 350000, "us") \ PARAM_DEF(V_SENS_OFFSET, f32, 0.4, "V") \ - - + PARAM_DEF(WIFI_CHANNEL, i16, 6, "") \ + PARAM_DEF(WIFI_SSID, str, "sc.local", "") \ + PARAM_DEF(WIFI_PASS, str, "password", "") \ // Generate enum for parameter indices @@ -111,9 +131,10 @@ typedef enum { } param_idx_t; #undef PARAM_DEF -#define PARAMS_SIZE sizeof(param_stored_t) +#define FLASH_SECTOR_SIZE 4096 #define PARAMS_OFFSET 0 -#define PARAMS_TOTAL_SIZE (NUM_PARAMS * PARAMS_SIZE) +#define PARAMETER_NUM_SECTORS 4 +#define LOG_START_OFFSET (FLASH_SECTOR_SIZE * PARAMETER_NUM_SECTORS) // External declarations extern param_value_t parameter_table[NUM_PARAMS]; @@ -122,36 +143,38 @@ extern const param_type_e parameter_types[NUM_PARAMS]; extern const char* parameter_names[NUM_PARAMS]; extern const char parameter_units[NUM_PARAMS][8]; -esp_err_t storage_init(); -esp_err_t log_init(); +// Core functions +esp_err_t storage_init(void); +esp_err_t log_init(void); +void storage_deinit(void); +// Parameter access functions param_value_t get_param_value_t(param_idx_t id); esp_err_t set_param_value_t(param_idx_t id, param_value_t val); param_type_e get_param_type(param_idx_t id); const char* get_param_name(param_idx_t id); param_value_t get_param_default(param_idx_t id); const char* get_param_unit(param_idx_t id); +const char* get_param_json_string(param_idx_t id, char* buffer, size_t buf_size); -esp_err_t commit_params(); - -uint32_t get_log_head(); -uint32_t get_log_tail(); -uint32_t get_log_offset(); - -esp_err_t write_dummy_log_1(); -esp_err_t write_dummy_log_2(); -esp_err_t write_dummy_log_3(); +// Helper functions for string parameters +esp_err_t set_param_string(param_idx_t id, const char* str); +char* get_param_string(param_idx_t id); +// Storage operations +esp_err_t commit_params(void); +// Log functions #define LOG_ENTRY_SIZE 32 -#define FLASH_SECTOR_SIZE 4096 - -// Calculate offset for log area (after parameters sector) -#define PARARMETER_NUM_SECTORS 4 -#define LOG_START_OFFSET FLASH_SECTOR_SIZE*PARARMETER_NUM_SECTORS +uint32_t get_log_head(void); +uint32_t get_log_tail(void); +uint32_t get_log_offset(void); esp_err_t write_log(char* entry); -void storage_deinit(); +// Test functions +esp_err_t write_dummy_log_1(void); +esp_err_t write_dummy_log_2(void); +esp_err_t write_dummy_log_3(void); #endif /* MAIN_STORAGE_H_ */ \ No newline at end of file diff --git a/main/uart_comms.c b/main/uart_comms.c index f748135..1c81aa0 100644 --- a/main/uart_comms.c +++ b/main/uart_comms.c @@ -51,16 +51,9 @@ static bool parse_uint64(const char *str, uint64_t *result) { static void print_param_value(param_idx_t id, param_value_t val) { param_type_e type = get_param_type(id); + char sbuf[9] = {0}; + switch (type) { - case PARAM_TYPE_u8: - printf("%u (0x%02X)\n", val.u8, val.u8); - break; - - case PARAM_TYPE_i8: - printf("%d (0x%02X)\n", - val.i8, (uint8_t)val.i8); - break; - case PARAM_TYPE_u16: printf("%u (0x%04X)\n", val.u16, val.u16); @@ -102,6 +95,12 @@ static void print_param_value(param_idx_t id, param_value_t val) { val.f64, (unsigned long long)val.u64); break; + case PARAM_TYPE_str: + memcpy(val.str, sbuf, 8); + sbuf[8] = '\0'; + printf("\"%s\"", sbuf); + break; + default: printf("UNKNOWN TYPE\n"); break; @@ -114,7 +113,7 @@ static esp_err_t parse_param_value(const char *orig_str, param_type_e type, para while (isspace((unsigned char)*str)) str++; // Check for negative sign on unsigned integer types - bool is_unsigned_int = (type == PARAM_TYPE_u8 || type == PARAM_TYPE_u16 || type == PARAM_TYPE_u32 || type == PARAM_TYPE_u64); + bool is_unsigned_int = (type == PARAM_TYPE_u16 || type == PARAM_TYPE_u32 || type == PARAM_TYPE_u64); if (is_unsigned_int && *str == '-') { return ESP_FAIL; } @@ -123,14 +122,12 @@ static esp_err_t parse_param_value(const char *orig_str, param_type_e type, para errno = 0; switch (type) { - case PARAM_TYPE_u8: case PARAM_TYPE_u16: case PARAM_TYPE_u32: case PARAM_TYPE_u64: val->u64 = strtoull(str, &endptr, 0); break; - case PARAM_TYPE_i8: case PARAM_TYPE_i16: case PARAM_TYPE_i32: case PARAM_TYPE_i64: diff --git a/main/webpage.h b/main/webpage.h index 148e970..78932bf 100644 --- a/main/webpage.h +++ b/main/webpage.h @@ -1,3 +1,3 @@ -const char html_content[] = {0x1f,0x8b,0x08,0x00,0x4d,0x48,0x53,0x69,0x02,0xff,0xad,0x1a,0x69,0x77,0xdb,0x36,0xf2,0xbb,0x7f,0x05,0xec,0xb4,0x2e,0x99,0x52,0xd4,0x61,0x37,0xcd,0x4a,0xa6,0xb2,0xae,0x8f,0x26,0x79,0xbe,0x9e,0x8f,0x76,0x77,0xfd,0xf4,0x44,0x88,0x84,0x24,0xd6,0x14,0xc1,0x25,0x20,0xcb,0x5a,0x45,0xff,0x7d,0x67,0x00,0x5e,0x92,0x68,0xc7,0x9b,0x6c,0xf3,0x42,0x91,0xc0,0x5c,0x98,0x7b,0x90,0x1e,0x6c,0xfb,0xdc,0x93,0xf3,0x98,0x91,0xb1,0x9c,0x84,0xdd,0x03,0x19,0xc8,0x90,0x75,0x8f,0x78,0x24,0x13,0x1e,0x92,0x2b,0x1a,0xb1,0xf0,0xa0,0xae,0x17,0x0f,0x84,0x9c,0xc3,0xcf,0xdb,0x85,0xc7,0x43,0x9e,0xb4,0xdf,0x30,0xc6,0x3a,0x03,0xea,0x3d,0x8c,0x12,0x3e,0x8d,0xfc,0x5a,0xba,0xda,0x6c,0x36,0x3b,0x43,0x40,0xaf,0x0d,0xe9,0x24,0x08,0xe7,0x6d,0x41,0x23,0x51,0x13,0x2c,0x09,0x86,0xcb,0x20,0x8a,0xa7,0xd2,0x1a,0x4c,0xa5,0xe4,0xd1,0x42,0xb2,0x27,0x59,0xa3,0x61,0x30,0x8a,0xda,0x49,0x30,0x1a,0xcb,0xce,0x80,0x3f,0xd5,0x44,0xf0,0x9f,0x20,0x1a,0xb5,0x07,0x3c,0xf1,0x59,0x52,0x83,0x95,0x0a,0x06,0x7b,0x7b,0x7b,0x1d,0x0d,0xd0,0x6e,0xc6,0x4f,0x44,0xf0,0x30,0xf0,0xc9,0x9b,0x77,0xef,0xde,0x75,0x66,0x81,0x2f,0xc7,0xed,0x66,0xa3,0xf1,0xe3,0x8a,0x04,0x13,0x1e,0x71,0x11,0x53,0x8f,0x2d,0x37,0x59,0x7b,0x2c,0x92,0x2c,0x59,0xda,0xde,0x98,0x46,0x23,0xe6,0x2f,0x8a,0x43,0x6c,0x07,0x93,0x98,0x27,0x92,0x46,0xb2,0x4a,0x06,0x7f,0xaf,0xd8,0x5f,0xbe,0xf1,0xf8,0x64,0x12,0xc8,0xfe,0x40,0x46,0x25,0x02,0x1d,0x6f,0x9a,0x08,0x78,0x8f,0x79,0x80,0x3c,0xaa,0xa9,0x64,0x27,0x89,0x78,0xc4,0xca,0xf2,0x4f,0x68,0x32,0x0a,0xa2,0x9a,0xe4,0x31,0x7c,0xc7,0x4f,0x9d,0x98,0xfa,0x3e,0x6a,0x46,0x7d,0xa8,0xc3,0xcd,0x18,0x6a,0xad,0xfd,0x6b,0xa3,0x51,0xe6,0x7f,0xef,0x07,0x82,0x0e,0x42,0xe6,0xf7,0x32,0x49,0xde,0xbf,0x7f,0x9f,0x49,0x12,0x71,0x3c,0x76,0xc8,0x67,0xcc,0xaf,0x90,0x66,0x7f,0x7f,0x7f,0x29,0x11,0x77,0x91,0xaa,0x1f,0xd6,0x43,0x1a,0x0b,0xd6,0xce,0x5e,0x4a,0x02,0x2e,0xa5,0xbf,0xc8,0xad,0x04,0x4a,0x9d,0x94,0x6d,0xd1,0x6a,0xb5,0x72,0x81,0xdf,0xc7,0x4f,0x4b,0x99,0xb4,0xc7,0xfc,0x91,0x25,0x8b,0x0a,0x6f,0xa1,0xf8,0x67,0x29,0xa6,0x13,0x38,0xf1,0xbc,0x6c,0x99,0x90,0x0d,0x65,0x27,0x85,0xf2,0x3c,0xaf,0x42,0xe0,0x5f,0x5b,0x7b,0x39,0x1b,0x7b,0x2f,0x61,0x93,0x0d,0xc5,0x1c,0xd4,0xb5,0xcb,0x1e,0xd4,0xc7,0x8c,0xfa,0xdd,0x83,0x01,0xf7,0xe7,0xf0,0x54,0x5e,0x40,0x32,0x4d,0x91,0xc0,0x77,0x0a,0x05,0x12,0x1e,0x79,0x61,0xe0,0x3d,0x64,0x4b,0x31,0x4d,0xe8,0x44,0x18,0x66,0xf7,0x86,0x3e,0x32,0x72,0xa4,0xdc,0x44,0x1c,0xd4,0x35,0x0d,0x08,0x17,0x24,0x01,0x3f,0x09,0xfc,0xf5,0xbb,0x37,0xde,0x98,0xf9,0xd3,0x90,0x91,0x1b,0x49,0x13,0x09,0x71,0xe3,0xab,0xe5,0x03,0xe5,0xf8,0xc8,0x67,0x02,0x6a,0xe8,0x0b,0xdc,0x44,0x3e,0x8a,0x98,0xa3,0x7f,0x32,0x54,0x43,0x8e,0x03,0x61,0x12,0x8c,0x48,0x47,0x06,0x13,0x94,0x1d,0x29,0xd4,0x15,0x87,0x35,0x2e,0x27,0x91,0xff,0x1c,0x0f,0x16,0xf9,0xdf,0xc1,0xe1,0x0d,0x39,0x07,0x22,0xa2,0x7e,0x4c,0xe7,0x15,0x0c,0xa2,0xe9,0xa4,0x8f,0x4c,0x04,0x99,0x04,0x91,0xd3,0x78,0x0d,0x1f,0x40,0x19,0xb0,0xa4,0x82,0x13,0xf2,0x21,0xc7,0x01,0xa8,0x24,0xf2,0x58,0x05,0x2f,0x3f,0x09,0xe0,0x34,0x60,0x2a,0xf9,0x8d,0xcc,0xe0,0xef,0x50,0x6e,0xf2,0xfd,0x0c,0xde,0x44,0x3e,0x2a,0x4f,0xa9,0xe0,0xfa,0x17,0xec,0x7e,0x27,0xd3,0x20,0xda,0x64,0x7a,0x0b,0xda,0xae,0xe0,0x16,0x44,0x7d,0xb4,0x43,0xc1,0x05,0x42,0xe1,0x41,0x7b,0x9a,0x9f,0xb2,0x10,0x92,0xc5,0x4e,0x53,0x73,0xf2,0xa9,0x64,0x08,0x5f,0x0b,0xb9,0x47,0xc3,0x82,0x63,0xe6,0xd7,0x68,0x21,0x3e,0x5b,0xf1,0x65,0xc1,0x24,0xf2,0xbe,0xe5,0x17,0x7c,0x06,0xae,0xbc,0x1b,0xca,0x0e,0xb9,0xb8,0xfc,0xb3,0x70,0xe3,0x0d,0x51,0x7f,0xa3,0x12,0x72,0x56,0x95,0xf5,0x1f,0x79,0x28,0xe9,0x88,0x91,0x04,0x22,0x8a,0x47,0xe1,0xbc,0x10,0xe0,0x8f,0x4d,0x32,0x1b,0xc2,0x65,0x12,0xed,0x78,0x13,0xdf,0xf8,0x49,0x45,0xc2,0x4f,0xe6,0x4e,0xf7,0xe6,0xf6,0xf0,0xfa,0x96,0x9c,0x5f,0xfe,0x71,0xf2,0x82,0x4c,0x5f,0x21,0x06,0x99,0x81,0x23,0xad,0xbb,0x8b,0xe3,0xcb,0xef,0x24,0x25,0x20,0xef,0x02,0x29,0xa2,0xb2,0x87,0xb3,0x99,0x79,0xde,0x37,0x1a,0x20,0xf2,0xe5,0xd5,0xb3,0x6c,0xea,0x69,0x5e,0x18,0xc0,0xbb,0xcf,0x24,0x0d,0x42,0x01,0xe5,0x53,0x27,0xb9,0xee,0xf1,0xe1,0xc5,0xef,0x27,0xd7,0xe4,0x5f,0x97,0x17,0x80,0x9b,0x2d,0x92,0xb5,0x54,0x72,0x95,0xf0,0x11,0x64,0x1e,0x72,0x7d,0x4a,0xae,0xd9,0x84,0x4b,0xf6,0xac,0xc8,0xb1,0x86,0xbc,0x3e,0x35,0x1a,0x66,0x2a,0xb1,0xce,0xd3,0xfb,0x8d,0x1f,0xbb,0xa7,0x33,0x3f,0x97,0x8f,0x3c,0x8f,0xd9,0xdc,0xc4,0xbc,0x66,0x8f,0xaf,0xc1,0x6c,0x6d,0x62,0xde,0xc5,0xaf,0x41,0xdc,0xdb,0x44,0x3c,0xe6,0xb3,0xe8,0x35,0xa8,0xb5,0xa6,0xd9,0x3d,0xc2,0x84,0x11,0x92,0x33,0x46,0x93,0x08,0x0a,0xc0,0x0b,0xb6,0x3e,0x82,0x7a,0x32,0x48,0xa8,0x0c,0x78,0x54,0x15,0x2b,0x10,0x43,0x7d,0x15,0xef,0x10,0x30,0x3a,0x2d,0xac,0x20,0xac,0x4b,0x93,0x62,0xe8,0xbc,0x84,0x28,0xc7,0xf8,0x56,0x89,0xb3,0x29,0xca,0x69,0x90,0x4c,0x66,0x34,0xd9,0x48,0x02,0xd4,0xf3,0x58,0x2c,0x1d,0x7b,0x10,0x28,0x06,0xc3,0x14,0xac,0x3f,0x0c,0x20,0xcb,0xab,0xa0,0xc7,0xb7,0x15,0x21,0xa6,0x71,0xc8,0xa9,0xbf,0x12,0xe5,0x7a,0x29,0xe3,0x01,0x71,0x7e,0xa7,0x16,0x48,0xc1,0xf5,0x59,0xc1,0xce,0xf8,0x08,0xc0,0x42,0x56,0xa5,0xa0,0x90,0x8f,0x56,0xd8,0xf8,0x60,0x25,0xa4,0x0b,0x38,0x88,0x02,0x7c,0x8e,0xd3,0x15,0x02,0x4b,0x2f,0x44,0x43,0xea,0xe2,0x48,0x33,0xf5,0xf5,0x2c,0x4c,0xea,0x45,0x8c,0x78,0x49,0x10,0xcb,0x6e,0xc8,0x24,0x51,0x95,0xb7,0xff,0x48,0xc3,0x29,0x13,0xce,0x7d,0xcf,0xd2,0xdf,0x11,0x9d,0x94,0x3f,0xa7,0x51,0x20,0xf1,0xb3,0x33,0x9c,0x46,0x1e,0x6a,0x9f,0x60,0x00,0x3f,0x99,0x8b,0x60,0x68,0x3c,0x39,0x8e,0xe3,0xaa,0x14,0xe3,0xee,0xee,0x6e,0x7b,0x3c,0x42,0xbd,0x1a,0xee,0x9f,0x41,0x18,0x92,0x01,0x83,0xf6,0x8a,0x40,0x15,0x03,0xdf,0x21,0x35,0x12,0x87,0x8c,0x0a,0x46,0x52,0x18,0xdb,0x35,0xcd,0x84,0xc9,0x69,0x12,0x75,0x50,0x90,0xa7,0x71,0xe2,0x44,0x6c,0x46,0xfe,0x71,0x7e,0xf6,0x51,0xca,0xf8,0x9a,0xfd,0x1b,0x24,0x92,0x1d,0x58,0xb6,0x79,0xcc,0x22,0xc3,0xbd,0xba,0xbc,0xb9,0x75,0x2d,0xd7,0xae,0x03,0x6f,0xd7,0xda,0x6e,0x98,0x16,0xee,0x41,0xd2,0x4d,0x41,0x3f,0x42,0xaa,0x64,0x89,0xe1,0x62,0x57,0x0d,0xfd,0x66,0xed,0x16,0x2c,0x0a,0xf0,0x34,0x8e,0x41,0xa1,0xca,0x67,0xea,0x7f,0x09,0x1e,0xb9,0x19,0x5e,0xe4,0x1b,0x9f,0x6f,0x2e,0x2f,0x6c,0x21,0x13,0x10,0x2f,0x18,0xce,0x8d,0x05,0x50,0x6e,0x3f,0x2d,0x4d,0x0d,0xc1,0x95,0xb6,0x9d,0xec,0xc8,0x86,0x09,0xbd,0x5e,0x04,0xbd,0x17,0xb3,0xc1,0x56,0x06,0x40,0x98,0xcb,0x65,0xae,0x8f,0x11,0x43,0x75,0xe8,0xe3,0x10,0xe8,0xf5,0xa7,0x13,0x10,0xc1,0x1e,0x31,0x79,0x12,0x32,0x7c,0xfd,0x6d,0xfe,0x09,0x15,0xb6,0xdc,0xaa,0xd7,0xc9,0x47,0xa8,0x87,0x21,0xd6,0x44,0x92,0xf6,0xc3,0x44,0xf9,0xa7,0x20,0x14,0xda,0x09,0x16,0x29,0xeb,0xc9,0x31,0x23,0x02,0x7b,0x21,0x6d,0xe7,0xad,0x9c,0x51,0xb9,0x6a,0xb1,0xd0,0x5c,0xb0,0xd0,0xf6,0x42,0x2a,0xc4,0x19,0xd4,0x51,0x1b,0xda,0x34,0xc3,0x4d,0x89,0xc2,0x39,0x41,0x28,0xb7,0xe8,0xb9,0x5c,0xd3,0xce,0x9a,0x31,0x67,0xbb,0x59,0x88,0x2e,0xf9,0x69,0xf0,0x04,0xd4,0xf4,0xdc,0x10,0x99,0x0b,0xb4,0x06,0x14,0x5a,0x07,0x6c,0x2f,0xd8,0x29,0x28,0x41,0xea,0x3d,0xb3,0x93,0x9e,0x2f,0x10,0x17,0xf4,0xc2,0x00,0x10,0xf3,0x43,0x34,0x0d,0xc3,0xf6,0x85,0xaa,0xca,0xb8,0x60,0x67,0xc4,0x22,0x53,0x9f,0xb5,0x56,0xab,0x91,0xa6,0x4d,0x7e,0x3f,0xb9,0x25,0xc7,0x87,0xb7,0x87,0xf8,0x5d,0x9c,0x65,0xc8,0xa4,0x37,0x86,0x26,0x4e,0x4e,0xa1,0xf5,0x5b,0xbc,0xca,0x09,0x80,0x90,0xf2,0x01,0xa1,0xb0,0x0a,0x37,0xd8,0x34,0x16,0xba,0x26,0xda,0x59,0x01,0x82,0x8f,0xb6,0x1a,0x0d,0x53,0x42,0xf3,0xbb,0x66,0x44,0x3b,0x61,0x22,0x86,0x25,0x76,0x0b,0x4d,0xb1,0xa9,0x3c,0x11,0x4a,0x3f,0x75,0x94,0x6b,0x28,0x0d,0x54,0x40,0xe1,0xc9,0xee,0x62,0x6c,0x11,0x88,0xea,0x29,0x86,0x01,0x0b,0xc1,0x8a,0x43,0x42,0x1f,0x21,0xc0,0x50,0xc5,0x5b,0xc0,0x1e,0xe9,0xd8,0xb8,0xaf,0xcf,0x86,0xe0,0x8e,0x51,0x7f,0x4b,0xfe,0xde,0xef,0x5f,0xdd,0x5d,0x9f,0xf4,0xfb,0xe4,0x6d,0x9d,0xe0,0x69,0x8f,0x61,0xa7,0x80,0x7e,0xdb,0x64,0x7b,0xa6,0x09,0x9a,0xfc,0x74,0x73,0x79,0xa3,0x7c,0xd3,0x30,0x6d,0x01,0x3e,0xcc,0x8c,0x86,0xd5,0xfc,0x9b,0xd9,0x41,0xb3,0xa6,0xdd,0x0c,0xd8,0x54,0x85,0xae,0x6a,0x57,0x96,0xb8,0x91,0x36,0x0e,0xf9,0x46,0x66,0x10,0x45,0x7e,0xa0,0xfb,0x0d,0xab,0x65,0x5a,0x2b,0x71,0xaf,0x36,0xf5,0xfb,0x97,0x2f,0x6b,0x49,0x40,0xed,0xa9,0xd7,0xd2,0x96,0x4e,0x08,0x6a,0x4b,0xbd,0xaa,0x2d,0xf5,0x99,0x48,0xaf,0x0f,0x31,0xf9,0xe5,0x8b,0xb1,0x2a,0xe6,0x9a,0x93,0xb2,0x24,0xe1,0x09,0xb8,0x68,0x9e,0x2f,0x8e,0xa0,0xcf,0x7a,0x20,0x30,0x3b,0x11,0xc0,0xb6,0xc9,0xcd,0x3c,0xf2,0xc8,0x2c,0x90,0x63,0x82,0xad,0x19,0xf1,0xd9,0x23,0x9c,0xff,0x27,0x41,0x3c,0x04,0xfb,0xe0,0x9a,0xbb,0xbb,0xc6,0x6a,0xbb,0x65,0xa5,0x8e,0x8e,0xec,0x0c,0x13,0xbc,0x0f,0x42,0xde,0x1b,0x1b,0xac,0x88,0x5a,0xc5,0xd2,0x70,0x4f,0xf0,0x07,0xd3,0x9e,0xc0,0xa4,0x84,0x66,0x76,0x2d,0xa6,0x9d,0xf5,0x30,0x9c,0xd1,0xb9,0x80,0x9e,0x2b,0x82,0x44,0x42,0x74,0x1a,0x65,0x8f,0x2c,0x42,0xcb,0x26,0xda,0x15,0xc9,0x10,0x33,0x28,0x01,0x0a,0x78,0x5a,0x88,0x04,0xc2,0x26,0xb1,0x9c,0x6f,0x69,0x9c,0x5b,0x44,0x31,0xcc,0x65,0xea,0x92,0x8a,0x63,0xe1,0x93,0x9b,0xb2,0x5c,0x30,0x39,0xe3,0xc9,0x03,0xd1,0xda,0x00,0x31,0xac,0x0a,0x3a,0x2a,0x53,0x99,0x45,0xbc,0x8a,0xbe,0xe4,0xfd,0xf1,0x78,0x32,0x31,0x44,0x96,0x71,0xdc,0x1f,0x16,0xa9,0xa7,0x9c,0x53,0x39,0xb6,0x87,0x21,0x07,0xea,0xa2,0xbe,0xf7,0x0e,0x7c,0xde,0x04,0x2f,0xf6,0xd5,0xa4,0x64,0xb4,0x2c,0xb7,0xe1,0x9a,0xcb,0x76,0x25,0xf4,0x8f,0x08,0x5d,0x7f,0x57,0x85,0xe0,0x16,0xcc,0x57,0xe4,0x53,0x6e,0xad,0xd4,0xe4,0xa0,0xb1,0xd5,0x9b,0xab,0xa3,0xe3,0x08,0x52,0x7d,0x42,0xd8,0x13,0x18,0x1c,0xd5,0xac,0xbc,0x86,0x81,0xef,0x91,0x84,0xcf,0x04,0x31,0xd4,0x73,0x00,0xa7,0x67,0xa8,0x5d,0x20,0xf9,0x44,0x1a,0x2a,0xfd,0x61,0xde,0x03,0x4f,0x91,0x08,0x67,0x6e,0x0d,0x41,0xb0,0x8e,0x22,0x6b,0x23,0x86,0x1d,0xb2,0x68,0x24,0xc7,0xdd,0x46,0xc7,0xd4,0x8b,0x3e,0x03,0x09,0xd8,0x35,0xd8,0xbf,0x61,0x76,0x4a,0x4e,0x6b,0x03,0xe2,0x09,0x05,0xf3,0x1b,0xf8,0x69,0x05,0xa6,0xd3,0x55,0xb2,0x02,0x11,0x5d,0x14,0xed,0x00,0x62,0x39,0x91,0x88,0xb9,0x41,0x1e,0xd2,0x1c,0x9f,0x01,0x00,0x98,0xef,0xe3,0xed,0xf9,0x99,0xe3,0x6e,0x91,0x8a,0xff,0xb0,0x7c,0xff,0xb0,0x08,0x96,0xaa,0x00,0xbf,0x00,0x51,0x92,0xea,0x3e,0xe8,0x6d,0x3b,0xd0,0xd9,0xc3,0xf0,0xde,0xd8,0xdd,0xdd,0xd8,0xc0,0x54,0xfa,0x61,0x75,0xb5,0xed,0xe2,0xa2,0xfb,0x15,0x26,0x69,0x7b,0xa3,0x3a,0x98,0x1d,0x3d,0x21,0xed,0x60,0xf9,0xdf,0x81,0xe8,0x43,0x11,0x77,0x88,0x4e,0x05,0x3b,0x99,0x34,0x3a,0xd2,0xab,0xc4,0x29,0xef,0x94,0xe4,0xc9,0x97,0x33,0x81,0x76,0xa0,0x4f,0x51,0x5c,0x9d,0x9d,0x8d,0x31,0x6a,0xa7,0xfb,0x3a,0x9d,0xa8,0xc4,0x01,0x34,0xbf,0x7c,0x71,0x9f,0x3b,0xa1,0xbb,0xd4,0x45,0x2c,0x9f,0x85,0xf3,0xb4,0xb6,0x22,0x57,0xb3,0xa7,0xa0,0x8a,0xb1,0x3f,0x07,0x2b,0x62,0x65,0x05,0xa1,0xd5,0x33,0x0b,0x0c,0xf0,0xe8,0xaf,0xc1,0xef,0xa5,0xf0,0xc5,0x9c,0x5c,0x2d,0xc8,0xbe,0x16,0x24,0x1f,0x6c,0xab,0xa1,0x7e,0xe9,0x15,0xf1,0xb4,0x36,0xea,0x32,0x55,0xb7,0x56,0x6a,0xbc,0x69,0x81,0xb7,0xfa,0xd0,0x63,0x15,0x4a,0x80,0xe4,0x97,0x26,0xd7,0x66,0xce,0x81,0xe9,0x5f,0xab,0x8c,0x5b,0x00,0x99,0x39,0x95,0xb2,0x92,0x30,0x26,0xee,0xc7,0x7c,0x9a,0x08,0x0b,0x26,0xf0,0xa9,0x64,0xa2,0x97,0xd1,0xb1,0x05,0x74,0x4d,0xd2,0x70,0xdb,0xc0,0x60,0x42,0x63,0x43,0x97,0xf8,0xbc,0xf6,0xb4,0x72,0xbe,0x0a,0xfd,0x2d,0xe6,0x8e,0x9f,0x53,0x1a,0x6f,0xdf,0x35,0xaa,0xa4,0x00,0x14,0x73,0x09,0x87,0x2b,0xcb,0xa1,0x54,0xff,0xed,0x52,0xec,0xfd,0xef,0x52,0xec,0xa1,0x14,0xa9,0x08,0x25,0x6b,0x16,0x1a,0xdd,0x7f,0x8d,0x46,0xf7,0xcb,0x1a,0x2d,0xac,0x5d,0x50,0xf9,0xe5,0x35,0x54,0x7e,0x41,0x2a,0xa5,0xbc,0xbe,0x52,0xcf,0x16,0x3a,0xa7,0xe6,0x05,0xd4,0xda,0x70,0x0a,0x4d,0xff,0xf9,0x86,0x42,0xf5,0x10,0x67,0x78,0x7b,0xc1,0xd2,0x74,0xef,0x8a,0xc7,0xda,0xcd,0x89,0x5b,0xe2,0xb9,0x52,0x34,0x5f,0xe8,0xc0,0xac,0x7b,0x6c,0x30,0xae,0xc0,0x6b,0x2c,0x84,0xc5,0x97,0x9e,0x53,0xd1,0x87,0x64,0x06,0xbb,0x05,0x81,0xef,0xe7,0x50,0x02,0xac,0x09,0x74,0xe3,0x63,0x68,0x0d,0xe6,0x3d,0x27,0x23,0x91,0x01,0xd5,0x56,0xad,0x6a,0x29,0x27,0x48,0x7d,0xc0,0x12,0x0c,0x6a,0xa5,0xef,0x34,0x7a,0x4e,0xc6,0xf0,0x19,0x67,0xb0,0x58,0xcc,0xbd,0xb1,0x53,0x2a,0x65,0x78,0x7a,0xfb,0xee,0xf6,0xc8,0x28,0x04,0xa8,0x35,0x51,0x04,0x6b,0x93,0x81,0x59,0xc7,0x6e,0xab,0x6a,0xca,0x00,0x7b,0x7e,0xf7,0x90,0xb1,0xd9,0x95,0xae,0xb7,0xa4,0xbb,0xbb,0xcf,0xb5,0x49,0x09,0xc3,0x10,0x29,0xb7,0xf3,0xf9,0x58,0x01,0x92,0x24,0xf3,0x1b,0xa8,0x7d,0x9e,0xe4,0xc9,0x61,0x18,0x22,0x01,0xc8,0xc5,0x76,0x0e,0x9a,0x56,0x32,0x60,0xd1,0xf8,0xf0,0xc2,0x10,0xd0,0x68,0xbf,0x38,0x21,0x14,0xdd,0x87,0x52,0x31,0x78,0x53,0xd6,0x8e,0x16,0xbd,0x7d,0xcb,0x26,0xa8,0xb1,0x8a,0xe6,0x7e,0xed,0x66,0x77,0xf1,0x92,0x1c,0xaa,0xed,0x4e,0xa5,0xff,0xa4,0x66,0x21,0xe7,0xf5,0x87,0xed,0x40,0x52,0x11,0xb1,0xb3,0x58,0x5a,0x2b,0x14,0xf2,0x1e,0x40,0xd7,0xa9,0x2e,0x26,0x56,0x8d,0x89,0x51,0xeb,0x14,0x3a,0x5f,0x89,0x81,0x0e,0x0b,0x61,0x42,0x2d,0x81,0xda,0x2a,0x57,0x8a,0x3f,0xa1,0x15,0x55,0x76,0x82,0x98,0x5d,0xe0,0xe1,0xaf,0xf2,0x8e,0x06,0x98,0xfa,0x21,0xa8,0x65,0x0b,0x0f,0xa1,0x2e,0x1a,0x33,0x4c,0xed,0xaf,0x80,0x82,0x15,0x0a,0xe2,0x23,0xdd,0xd2,0x91,0x82,0xb1,0x39,0x63,0xc9,0x11,0x4c,0xc4,0x86,0xe9,0xa8,0xfc,0x0e,0x95,0x55,0x0f,0x54,0xeb,0x93,0x97,0x46,0x31,0x3b,0x22,0xbe,0x0f,0xfc,0x9e,0x03,0x5f,0x4b,0xa8,0x8c,0x97,0x83,0xbf,0x40,0x29,0xf6,0x03,0x9b,0x0b,0x50,0x40,0x66,0x74,0xa8,0xdc,0x8d,0x3c,0x94,0x5b,0xcf,0x4c,0x53,0xad,0x0d,0x6f,0x8f,0x73,0x6f,0x6f,0x7d,0xab,0xbb,0xb7,0xaa,0xfd,0xbd,0xb5,0xe2,0xf0,0x1f,0xbe,0x62,0xa4,0x54,0x79,0xdb,0x25,0x0b,0xed,0xee,0xa6,0x16,0x7f,0x3e,0x36,0x96,0xe6,0xd7,0x5d,0xb9,0x55,0x39,0xf3,0x83,0xe2,0x20,0x1f,0x96,0x07,0xd1,0x22,0x3b,0xae,0x5f,0xf5,0x28,0xad,0xe2,0x1d,0x91,0x12,0x5e,0xe5,0xbf,0x95,0x4b,0x24,0xed,0x8b,0xdb,0x39,0x84,0x8d,0x6f,0x79,0x5b,0xb9,0x80,0x44,0x0c,0x3d,0xb5,0x7b,0xc1,0x15,0x0d,0xc8,0xf7,0xe8,0xd3,0xca,0x83,0x75,0x17,0xbf,0xcc,0xc8,0x3b,0x6b,0x14,0xee,0x1b,0x3d,0xeb,0xf5,0xd7,0x23,0x5c,0xd2,0x6f,0xcc,0x5c,0x1c,0xc4,0x91,0x35,0xd0,0x0d,0xa3,0x93,0x57,0x67,0xb0,0x0f,0xe9,0xb1,0xd2,0x6b,0x30,0x31,0xf5,0x3c,0x26,0xc4,0x70,0x1a,0xda,0xe4,0x58,0x4d,0x6d,0x64,0x42,0xe7,0x30,0x37,0x0c,0x38,0x97,0xb6,0x6b,0xb6,0x57,0xc1,0x71,0x9c,0x62,0x7e,0x9b,0xb8,0x3f,0x17,0x74,0x9f,0x9b,0x9f,0x0a,0x0d,0x96,0xc7,0x26,0xe2,0x4f,0xd1,0x96,0xa9,0xb1,0xdc,0xf2,0xd0,0x84,0xca,0x2b,0x99,0xb3,0xb8,0xda,0x0c,0x5e,0x79,0xdb,0x90,0xeb,0x34,0x4e,0x86,0xff,0xa7,0x2b,0xa7,0xa0,0x9c,0x46,0xad,0xe2,0xd0,0x4b,0x2a,0x70,0xe4,0xcd,0x85,0xdd,0xb8,0xff,0x5b,0xe0,0xe5,0x85,0x1a,0x62,0xd2,0xab,0x08,0x87,0xce,0x68,0x20,0xf5,0x25,0x8a,0x01,0x32,0x86,0x7c,0x94,0x3a,0x60,0x06,0x61,0xf3,0x07,0x53,0x8e,0x61,0x9a,0x21,0x27,0xab,0xf3,0x66,0x06,0x40,0x66,0x54,0xa8,0x99,0x9b,0x3f,0xb8,0xfa,0xee,0x63,0x10,0xf2,0x41,0x4a,0x38,0xa7,0x82,0x6b,0x30,0x60,0x47,0x30,0x3c,0x3d,0xd7,0x6c,0x58,0x10,0xc7,0x13,0xbc,0x5c,0xf0,0xf1,0xcb,0x29,0xe6,0x51,0x40,0xc2,0x5b,0xb0,0xac,0x21,0x59,0x9f,0x2c,0x7f,0x58,0xdc,0xbb,0x9f,0x0f,0x61,0x02,0x77,0x4f,0x4f,0x7e,0x83,0xe7,0xf9,0xe1,0x35,0x3c,0x0f,0xaf,0xae,0xd5,0xfb,0x3f,0xe1,0xf9,0xf9,0xee,0x42,0x3d,0xcf,0x70,0xfd,0xee,0x77,0x78,0xde,0x9c,0x5c,0xc1,0xf3,0xf2,0x08,0x2d,0x73,0x71,0xf9,0x07,0x3c,0x8f,0x4f,0x8e,0xdc,0xde,0x7d,0xca,0xea,0x1c,0xeb,0xbd,0x61,0xf6,0x80,0x76,0xba,0x72,0x0a,0x29,0xf5,0x9f,0xd0,0x0a,0x40,0x68,0xd7,0xd6,0x05,0xfb,0x88,0x8d,0x63,0xb5,0x64,0xab,0x80,0xe7,0xba,0xad,0xac,0x02,0x75,0xad,0x69,0x12,0x3a,0x77,0xd7,0x67,0xb6,0x07,0x91,0x23,0x99,0xce,0xcb,0xf0,0x6d,0xa0,0xe6,0x4c,0x8b,0x16,0xc5,0x4c,0x03,0xa4,0x77,0x82,0x86,0x4b,0x41,0xeb,0xd4,0x1e,0x27,0x6c,0xe8,0x00,0x09,0x8b,0xda,0x99,0xd5,0xf1,0x46,0x95,0x27,0x74,0xc4,0x40,0xe0,0x15,0xd5,0x2e,0xf1,0xf6,0xda,0x2d,0x5a,0x01,0xfc,0xb7,0x56,0x1b,0xfc,0x0d,0x5c,0xeb,0x68,0x1c,0x84,0xbe,0x41,0x81,0x9f,0xad,0xae,0x90,0x0d,0x73,0x0d,0x4c,0x67,0xcd,0x1c,0x0c,0x05,0x4e,0xd8,0x23,0x7f,0x28,0x09,0x0c,0x52,0xe4,0x37,0x27,0xe8,0x32,0x1b,0x37,0x16,0xf9,0x25,0x74,0x1a,0xb8,0xae,0xa5,0xe1,0x96,0xaa,0x23,0xf8,0x04,0x23,0x5d,0x40,0x43,0x72,0x06,0x10,0x5b,0x33,0x98,0xeb,0x41,0x77,0x59,0x06,0x29,0x52,0x6c,0xe7,0xa0,0x9e,0x5e,0x40,0x1f,0xd4,0xf5,0xbf,0x15,0xd7,0xd5,0xff,0x15,0xf1,0x5f,0x68,0x8b,0x9c,0x3e,0x25,0x21,0x00,0x00}; +const char html_content[] = {0x1f,0x8b,0x08,0x00,0xfa,0x72,0x54,0x69,0x02,0xff,0xc5,0x3b,0x6b,0x77,0xdb,0xb6,0x92,0xdf,0xfd,0x2b,0x10,0x27,0xd7,0x25,0x13,0x8a,0x92,0x6c,0x27,0x6d,0x24,0xd3,0xbe,0x8e,0xed,0x34,0xed,0x8d,0x1f,0xc7,0x8f,0xf6,0x74,0x5d,0x1f,0x13,0x22,0x21,0x89,0x35,0x45,0x68,0x09,0xc8,0xb2,0x56,0xd1,0x7f,0xdf,0x19,0x00,0x7c,0x49,0xb4,0x9d,0x9b,0xde,0xcd,0x26,0x27,0x12,0x09,0x0e,0x66,0x06,0xf3,0x9e,0xa1,0xb2,0xf3,0x22,0xe4,0x81,0x9c,0x8d,0x19,0x19,0xca,0x51,0xbc,0xbb,0x23,0x23,0x19,0xb3,0xdd,0x03,0x9e,0xc8,0x94,0xc7,0xe4,0x8c,0x26,0x2c,0xde,0x69,0xea,0xc5,0x9d,0x11,0x93,0x94,0x04,0xf0,0x88,0x25,0xd2,0x5b,0x9f,0x46,0xa1,0x1c,0x7a,0x21,0xbb,0x8f,0x02,0xd6,0x50,0x37,0x4e,0x94,0x44,0x32,0xa2,0x71,0x43,0x04,0x34,0x66,0x5e,0xdb,0x6d,0xad,0x93,0x84,0x8e,0x98,0x77,0x1f,0xb1,0xe9,0x98,0xa7,0x72,0x77,0x47,0xc8,0x19,0x60,0x7a,0x39,0x4d,0xe9,0x78,0xcc,0xd2,0xb9,0x64,0x0f,0xb2,0x41,0xe3,0x68,0x90,0x74,0x02,0x40,0xca,0xd2,0x6e,0x8f,0x3f,0x34,0x44,0xf4,0x3f,0x51,0x32,0xe8,0xf4,0x78,0x1a,0xb2,0xb4,0x01,0x2b,0x8b,0x97,0x86,0xea,0x7c,0x44,0x1f,0x34,0xad,0xce,0xdb,0x56,0x6b,0xfc,0xd0,0x1d,0xd1,0x74,0x10,0x25,0x1d,0x3a,0x91,0xbc,0x3b,0xa6,0x61,0x88,0xfb,0x5a,0xa4,0x0d,0x8f,0x16,0x3d,0x1e,0xce,0x6a,0x08,0x98,0x1d,0xad,0x02,0x7c,0xf1,0x7a,0x1e,0xf0,0x98,0xa7,0x9d,0x97,0x9b,0x7d,0xfc,0xdb,0xed,0xd1,0xe0,0x6e,0x90,0xf2,0x49,0x12,0x36,0xcc,0x83,0x7e,0xbf,0xdf,0xed,0x03,0x0b,0x8d,0x3e,0x1d,0x45,0xf1,0xac,0x73,0xc2,0x25,0x27,0x17,0x34,0x11,0xce,0x6f,0x2c,0x0d,0x69,0x42,0x1d,0x01,0x37,0x0d,0xc1,0xd2,0xc8,0x00,0xc2,0x19,0x58,0xa7,0xed,0x6e,0xa6,0x6c,0xb4,0x88,0x92,0xf1,0x44,0x3a,0xbd,0x89,0x94,0x3c,0x29,0x73,0x94,0x46,0x83,0xa1,0xac,0x3f,0x71,0x0d,0x0f,0xac,0xcf,0x42,0xf6,0xbe,0xab,0x61,0x3a,0xed,0xf1,0x03,0x11,0x3c,0x8e,0x42,0xf2,0xb2,0x47,0xdf,0xbf,0x7b,0xdb,0x33,0x0f,0x1a,0x29,0x0d,0xa3,0x89,0xe8,0xbc,0x05,0xe1,0x68,0x41,0xb5,0x5b,0xad,0x7f,0x68,0x16,0xae,0x51,0xcf,0x1e,0x32,0x70,0xe3,0x94,0x16,0x92,0xc9,0xa8,0xc7,0xd2,0x9b,0x79,0xf9,0x80,0x23,0x9e,0x70,0x31,0xa6,0x01,0x5b,0xac,0xb2,0xad,0x05,0xb9,0x70,0x83,0x21,0x4d,0x06,0x2c,0x74,0x40,0x39,0xa3,0x51,0x24,0x6f,0x7b,0x32,0x99,0x17,0xf2,0x7a,0x11,0x8d,0x50,0xe5,0x34,0x91,0x35,0x67,0xd9,0xa4,0xdb,0xef,0xb7,0xc2,0x02,0x64,0x51,0xc1,0x31,0x49,0x05,0x00,0x8d,0x79,0x64,0x2c,0x42,0x1d,0x38,0xe1,0x09,0x2b,0x9d,0xc8,0xe8,0xb1,0x21,0xf9,0xb8,0x83,0xea,0xce,0xd5,0xa9,0x6e,0xd4,0x51,0xa6,0x0c,0xe5,0xdb,0xf9,0xb1,0xd5,0x2a,0xa3,0xbf,0x0e,0x23,0x41,0x7b,0x31,0x0b,0x6f,0x32,0x66,0x7f,0xfa,0xe9,0xa7,0xae,0xa1,0x99,0x70,0x3c,0x64,0xcc,0xa7,0x2c,0xac,0xe1,0x7a,0x7b,0x7b,0xbb,0xc4,0xb2,0x44,0x2c,0x73,0x23,0x75,0x80,0x88,0xe9,0x58,0xb0,0x4e,0x76,0xd1,0x2d,0x09,0x2c,0x66,0x7d,0x59,0x56,0x86,0x0c,0xe7,0xb9,0xa6,0x41,0xb8,0xa3,0xb2,0x32,0x8d,0x96,0xb3,0xd3,0xfc,0x04,0x86,0x2c,0x26,0x23,0x38,0x6c,0xc5,0x96,0x15,0xc6,0x92,0x6d,0xae,0xf2,0xfa,0xe3,0xe6,0x56,0x8d,0x45,0x64,0x68,0xdd,0x2d,0xb0,0xcb,0x15,0x29,0xb9,0xc1,0x28,0xe3,0x4c,0x8b,0xbb,0x6c,0xc9,0x6f,0xd1,0x92,0x5f,0x8e,0xc4,0xa0,0xc6,0x14,0x86,0xed,0x79,0x01,0xba,0xa9,0x41,0xff,0x39,0x62,0x61,0x44,0x89,0x08,0x52,0xc6,0x12,0x42,0x93,0x90,0x58,0x4a,0x04,0x3b,0xde,0xd6,0x5b,0x50,0x91,0x3d,0xaf,0xf1,0x69,0xa5,0xd8,0xc2,0x8d,0x81,0x63,0x2d,0x65,0x22,0x53,0xa2,0x84,0x56,0xe7,0x29,0xa5,0xad,0xa0,0xda,0x71,0x4c,0x67,0x9d,0x5e,0xcc,0x83,0xbb,0x7c,0xeb,0xdc,0x98,0x4a,0x26,0x6c,0x34,0x90,0x2a,0xe4,0x62,0xa7,0xa9,0x03,0xd3,0x4e,0x73,0xc8,0x68,0xb8,0xbb,0x83,0xb1,0x63,0x77,0x27,0x8c,0xee,0x49,0x14,0x7a,0x26,0x58,0xe5,0xf7,0x86,0xef,0xdd,0x9d,0x61,0x7b,0xf7,0x20,0x9e,0x08,0x90,0xc0,0x01,0x98,0x17,0x1c,0x11,0xb6,0xb7,0x21,0x84,0x22,0x5d,0xf8,0x82,0x1d,0x12,0x71,0x29,0x07,0x22,0x3c,0x09,0xe2,0x28,0xb8,0xf3,0xd6,0x05,0x4b,0x42,0x03,0x6f,0xfd,0x20,0x24,0x4d,0xe5,0x0f,0xf6,0x3a,0x09,0x62,0x2a,0x84,0x07,0x0a,0xd8,0xbd,0xb8,0xdc,0x3f,0xbf,0xdc,0x69,0xea,0x6d,0xc0,0x11,0xe2,0xf8,0x0a,0x3c,0x7c,0x5c,0x41,0x43,0xd4,0x81,0xbc,0xe7,0x6c,0x04,0xa8,0x9d,0x9e,0xfd,0xbb,0xc4,0x00,0x05,0xaf,0xf2,0x7c,0x75,0x72,0x78,0xba,0x84,0xa5,0x89,0xe7,0x6f,0x66,0xb2,0x28,0x8b,0x04,0x52,0x48,0x0c,0xb1,0x25,0xf1,0xb6,0x76,0x77,0x54,0x18,0x42,0xa1,0x82,0x61,0x91,0x14,0x64,0xcf,0x93,0x78,0x56,0xc6,0xf0,0xc4,0x96,0x28,0xb9,0x95,0xd1,0x88,0x21,0x93,0x2a,0x12,0x79,0xa0,0xe7,0xbb,0x03,0x1d,0x94,0x2c,0x39,0x8c,0x84,0x0d,0x42,0x60,0x63,0xaf,0x4d,0x54,0x98,0x0b,0xa9,0x64,0x08,0xdf,0x00,0x95,0xd3,0x78,0x97,0x64,0x67,0x04,0x4c,0x09,0x9f,0x62,0x68,0xc8,0x8f,0x2b,0x98,0xbc,0x04,0xc8,0x4b,0x7e,0xc2,0xa7,0x96,0xbd,0x7b,0x31,0x4b,0x02,0x82,0x0b,0x75,0x47,0x34,0x6a,0xbe,0x08,0x86,0x2c,0x9c,0x80,0xbd,0x5d,0xa0,0x46,0x0b,0x41,0x16,0x07,0xe4,0xf7,0xec,0x56,0xa9,0xbb,0x60,0x58,0x7f,0x65,0x5b,0x0d,0xcf,0x3a,0x48,0x03,0xb5,0xa7,0xa8,0x1c,0xa1,0xb1,0xd5,0xd3,0x00,0x4d,0xfd,0x0d,0x0a,0x2f,0xc9,0x31,0x20,0x11,0xcd,0x43,0x3a,0xab,0x21,0x00,0xa9,0xe2,0x16,0x89,0x08,0x32,0x8a,0x12,0xaf,0xf5,0x35,0x74,0x74,0x76,0xa9,0xa1,0x74,0xce,0x46,0x34,0x4a,0x5c,0x72,0x18,0x81,0x54,0x92,0x80,0x11,0xab,0x2f,0xed,0x1a,0x9a,0xa9,0x82,0x03,0xa7,0xbf,0x05,0xa7,0x95,0x4f,0x69,0xfb,0x69,0x7a,0x78,0xae,0x67,0x89,0x85,0x69,0x04,0x22,0x54,0x84,0xfe,0xfe,0x09,0x7f,0x05,0x8f,0x23,0x9f,0x54,0x7c,0x25,0x56,0x94,0xd4,0xd1,0xfb,0x0b,0x40,0xfe,0x53,0xe4,0x3e,0x50,0x09,0xa1,0x68,0x46,0xac,0xdf,0xea,0x28,0xdd,0xf3,0x58,0xd2,0x01,0xab,0x75,0xb2,0xcc,0x4d,0x8d,0x47,0x64,0x19,0x52,0x07,0xbb,0x2c,0x71,0xe6,0xde,0xa1,0x97,0xce,0x68,0x4a,0x47,0x02,0xbd,0x83,0x82,0x5c,0xb5,0x22,0x44,0xe1,0x20,0xbd,0x54,0xff,0x0b,0xa1,0x66,0x8c,0x62,0x01,0x95,0x9f,0xce,0x62,0xbb,0x87,0xfb,0x27,0x3f,0x1f,0x9d,0x93,0xff,0x3a,0x3d,0x39,0x82,0xa8,0x6b,0x16,0xc9,0x52,0xd0,0x3c,0x4b,0xf9,0x00,0xd0,0x93,0xf3,0x8f,0x04,0xcc,0x84,0x4b,0xf6,0x68,0x64,0x1a,0x6b,0xc8,0xf3,0x8f,0x17,0xec,0xbf,0x27,0x0c,0x34,0x0b,0x1c,0x65,0xbb,0xf7,0xe3,0x98,0x7c,0x50,0xe0,0xe2,0x09,0xcf,0x3d,0x80,0x54,0xd6,0x4b,0xa9,0x8c,0x78,0xf2,0x78,0xfc,0x0b,0x0c,0x10,0xb3,0x7e,0x40,0x95,0x41,0xf4,0xd3,0xda,0xad,0x6c,0x36,0x24,0xc8,0x53,0xbb,0x95,0x81,0xe1,0xf6,0x43,0xbc,0xa8,0xdd,0xbf,0xca,0xe2,0xc7,0x28,0x1d,0x4d,0x69,0xca,0x96,0xd5,0x4a,0x83,0x80,0x8d,0xa5,0xe7,0xf6,0x22,0x15,0xc6,0xfa,0x06,0xec,0xb6,0x1f,0x61,0xe2,0x43,0x63,0xc1,0xab,0x4a,0xa8,0x9b,0x8c,0x63,0x4e,0xc3,0x8a,0x3e,0xf5,0x52,0x46,0x03,0xe4,0x77,0xa5,0x16,0x48,0x41,0xf5,0x51,0xc6,0x3e,0xf3,0x01,0x80,0xc5,0xab,0xea,0x01,0x4a,0x31,0x1f,0x54,0xc8,0x84,0x7c,0x9a,0x20,0x5e,0xd8,0x83,0x5b,0x80,0xce,0xa1,0x59,0x21,0xb0,0xf4,0x44,0xf6,0x30,0xc6,0x81,0x38,0x8d,0x95,0x14,0x0f,0x9e,0x4b,0x55,0x29,0xeb,0x71,0x2e,0xbf,0x29,0x33,0x9e,0x1f,0x7d,0x38,0x3d,0x5d,0x4e,0xc4,0xcd,0xdc,0x9e,0x9b,0x50,0x0d,0x64,0x9f,0x50,0xe4,0x44,0x63,0xb9,0x1b,0x33,0x49,0xc6,0xe8,0x16,0xbf,0xd1,0x78,0xc2,0x84,0x77,0x7d,0xe3,0xa8,0xdb,0x13,0xe8,0x81,0x8a,0xbb,0x2b,0x68,0x92,0xf0,0x0e,0xea,0xb7,0x04,0xfc,0x1e,0x7c,0x1d,0x0e,0xb6,0x0b,0x5d,0xd8,0x64,0x04,0x55,0x85,0x3b,0x60,0xf2,0x28,0x66,0x78,0xf9,0x61,0xf6,0x4b,0x68,0x45,0xa1,0xdd,0xa5,0x02,0x13,0x50,0x7f,0x92,0x04,0x68,0x27,0xa4,0x7c,0x40,0x38,0x0f,0x62,0xb7,0xe7,0xe6,0xc2,0xf3,0x3c,0x5f,0x25,0x19,0x7f,0x63,0xe3,0x05,0x10,0x40,0x93,0xb0,0xfc,0xdf,0x23,0xf0,0x84,0x1e,0x83,0x22,0x88,0x40,0xf4,0x86,0x50,0x4a,0x1a,0x64,0x1c,0x33,0x2a,0x18,0x31,0x30,0xae,0x6f,0x7f,0xf9,0x52,0xc2,0xa1,0xe5,0x56,0x41,0x72,0xa8,0x3a,0x3d,0x32,0x45,0x5c,0xfa,0x31,0x60,0x09,0x00,0x4b,0x8a,0x08,0x03,0x2c,0xa4,0x54,0x99,0x17,0x9a,0x10,0xeb,0x92,0xfd,0x94,0x91,0x19,0x9f,0x10,0x31,0x49,0xd9,0x1e,0x12,0xa0,0x53,0x1a,0x49,0xd2,0x67,0x32,0x18,0x5a,0xbe,0xdb,0x04,0x7a,0xbe,0x33,0x87,0xae,0x72,0xc8,0xc3,0x8e,0x7f,0x76,0x7a,0x71,0xe9,0x3b,0x58,0x7f,0xb1,0x54,0x74,0xe6,0xeb,0x07,0xba,0xcc,0x6a,0x5c,0x82,0x1d,0xaf,0x77,0x7c,0xa8,0xc1,0x40,0xbf,0xca,0x53,0x9a,0x7f,0x09,0x9e,0xf8,0x0b,0x07,0xab,0xb4,0xce,0xaf,0x17,0xa7,0x27,0xae,0x90,0xc8,0x44,0xd4,0x9f,0x59,0x28,0x88,0x8e,0x39,0xc8,0xc2,0x86,0xbf,0x4b,0xc2,0x2b,0x5c,0x91,0x3e,0x40,0x48,0x9d,0x7f,0x2f,0x96,0x7c,0x20,0x7c,0xfb,0x6a,0x8e,0x44,0x17,0xba,0x0c,0xf0,0x91,0xbd,0x2e,0xda,0x0c,0x1d,0x49,0x8c,0x63,0xa3,0xb1,0xb4,0xfc,0xb3,0x94,0x09,0x41,0x72,0x9b,0x46,0x7d,0xb1,0xd4,0x25,0x95,0x65,0x3a,0x80,0x84,0x48,0xa0,0x03,0xc5,0xaa,0x8f,0x44,0xd2,0x25,0x97,0x43,0x96,0x38,0xca,0xe3,0x09,0x3c,0xa1,0x81,0x9c,0xd0,0x18,0x2a,0x5f,0x88,0xcc,0x31,0xc6,0xf1,0x4c,0x25,0x64,0xc8,0x52,0x05,0x11,0x41,0x9a,0x61,0xa2,0xe3,0xdb,0xdd,0xa8,0x6f,0xbd,0x88,0xc4,0x09,0x3d,0xb1,0xc0,0x38,0x05,0xfb,0x08,0xfe,0x28,0x2d,0x60,0xc8,0xb6,0xed,0x39,0xf2,0x06,0x74,0xc7,0x60,0xa7,0xcc,0xfb,0xae,0x82,0x02,0x27,0xd0,0xe2,0x01,0xf6,0x32,0x0e,0x5c,0x7e,0xa7,0x59,0x82,0x42,0x8e,0x1a,0x76,0xf2,0x67,0x88,0xd5,0x02,0x4f,0x01,0xf1,0xa2,0xf9,0xaa,0x28,0xeb,0xef,0x59,0xe5,0x1a,0x61,0xc0,0x2c,0x1f,0x4a,0xc6,0x77,0xbe,0x6d,0xbb,0xf7,0xe8,0xa0,0x58,0x11,0x52,0x97,0x35,0xe1,0xb4,0x4e,0x0d,0xe0,0x8f,0x4b,0x80,0x12,0x01,0x5f,0x43,0x4b,0x6f,0x77,0x6a,0xa0,0x7f,0xaa,0x83,0x5e,0x2c,0x16,0x6b,0xcd,0x26,0xf9,0x04,0x15,0x40,0xac,0xaa,0x00,0xd3,0x32,0x13,0x15,0xbe,0x85,0x72,0x17,0x96,0xe8,0x36,0x65,0xc8,0x88,0xc0,0x4c,0xaa,0x75,0xbc,0x96,0x1b,0x6c,0x99,0x16,0x8b,0xed,0x79,0xca,0xe4,0x24,0x4d,0x08,0x8b,0x5d,0x15,0xd1,0x3e,0x83,0x6a,0x5d,0xe8,0x98,0x2c,0xdf,0xe0,0xf6,0x6d,0x07,0x59,0x2a,0xf2,0xb6,0x6f,0xbb,0x59,0x42,0xf7,0x5e,0xb4,0x1d,0x16,0x2f,0x72,0xdc,0x92,0x7f,0x8c,0x1e,0x00,0xaf,0x1e,0x50,0x24,0x5a,0xbc,0x50,0x5f,0x78,0x25,0x5b,0x50,0xcf,0xec,0xae,0x21,0xab,0x4d,0x05,0x40,0xec,0xbd,0x64,0x12,0xc7,0x9d,0x13,0x55,0x8c,0xe0,0x82,0x9b,0x21,0x4b,0x6c,0x5b,0x9d,0xba,0xd1,0x68,0x90,0xb6,0x4b,0x7e,0x3e,0xba,0x24,0x87,0xfb,0x97,0xfb,0x78,0xbf,0xb6,0xe4,0x8c,0xca,0x9a,0xa0,0x60,0x96,0x13,0x28,0x24,0xe6,0x12,0x7a,0xdc,0xa7,0x4c,0x4e,0x28,0x40,0x63,0xb3,0x65,0xab,0xd0,0xbc,0x75,0x9f,0xb1,0x0d,0xe4,0xe9,0x6a,0x8c,0x5d,0x00,0x51,0x6d,0x43,0x3f,0x62,0x31,0x68,0xa2,0x4f,0xe8,0x3d,0x44,0x74,0x94,0xcf,0x1a,0x20,0xc6,0xa0,0xcc,0x63,0xe6,0x42,0xf6,0xb2,0x10,0x99,0xed,0x68,0x75,0x46,0x18,0x64,0x0d,0x05,0xe6,0x59,0xcd,0xd7,0xe4,0x9f,0xb7,0xb7,0x67,0x57,0xe7,0x47,0xb7,0xb7,0xe4,0x75,0x93,0x24,0x6c,0x4a,0x0e,0x31,0xaa,0xe4,0xd0,0xaf,0xdb,0x6c,0x0b,0x4c,0x42,0xf2,0x5f,0x2e,0x4e,0x2f,0x94,0x89,0x5b,0xb6,0x2b,0xc0,0x0d,0x98,0xd5,0x72,0xda,0xef,0xed,0xae,0x31,0x1c,0x84,0xf5,0x4b,0xa6,0xc3,0x16,0xf8,0xc0,0x54,0x6b,0xf9,0x83,0x4c,0xb8,0x0a,0x7d,0x4f,0x17,0x7a,0xce,0xa6,0x56,0x75,0xb5,0x40,0xae,0xdf,0x52,0x85,0xc9,0x76,0x42,0xd3,0xe5,0x57,0xac,0x16,0x16,0x9c,0x72,0x06,0x53,0x8b,0xea,0xb9,0xf8,0xf2,0xa5,0x9a,0xce,0xd4,0x23,0x9c,0xee,0x95,0x9e,0xe8,0xd4,0xa6,0x9e,0x4c,0xf0,0x52,0x3d,0x79,0xc2,0x1a,0x5b,0x5a,0xb8,0xa9,0x0c,0x6e,0xa1,0xe5,0xfa,0xf2,0xc5,0xaa,0xca,0x64,0xc9,0xc0,0x59,0x9a,0xf2,0x14,0xcc,0x3b,0xcf,0x48,0x07,0x2a,0xe7,0x24,0x90,0x88,0x60,0xb7,0x4b,0x54,0x9b,0x36,0x8d,0xe4,0x90,0x60,0xb5,0x4c,0xf4,0x64,0xf2,0x07,0xa1,0x53,0x13,0xe4,0x9f,0x8d,0x0d,0xab,0xda,0xd8,0x39,0x9a,0x2d,0x5c,0xb1,0x20,0xde,0x2d,0x20,0x42,0x81,0xa5,0x61,0x32,0x35,0x46,0xa0,0x28,0x5a,0xfe,0x11,0x7e,0x61,0x66,0x17,0x98,0xe9,0x30,0x68,0xf9,0x0e,0xd3,0x46,0xbe,0x1f,0x4f,0xe9,0x4c,0x80,0xad,0x25,0x10,0xf9,0x88,0xae,0x53,0xd8,0x3d,0x4b,0xd0,0xae,0x52,0xac,0x48,0x21,0xc3,0xf7,0xb1,0x60,0x20,0x80,0x01,0x0f,0x0b,0x1e,0x44,0x18,0x44,0xfa,0xd9,0x9a,0xde,0x73,0x89,0x5b,0x2c,0x7b,0x51,0xca,0xee,0x40,0x3d,0x14,0x97,0xfc,0xd3,0xa7,0xe3,0x63,0xcb,0xdc,0x65,0x6e,0xef,0xbf,0x9a,0x1b,0x5b,0x3a,0xa6,0x72,0xe8,0xf6,0x63,0x0e,0xfc,0x19,0x98,0xe6,0xd6,0xbb,0x56,0x0b,0x2c,0x6e,0x4c,0x43,0xd5,0x83,0x5a,0x9b,0x8e,0xdf,0xf2,0xed,0x45,0xe7,0x89,0x3d,0xff,0xc0,0x3d,0xcd,0x77,0x75,0xdb,0xfc,0x82,0xa5,0x0a,0xa7,0xca,0x09,0xd4,0x41,0x3d,0xd4,0x96,0xba,0xf2,0xb5,0x77,0x1d,0x60,0x31,0x40,0x18,0xc4,0x60,0x89,0x82,0x52,0x26,0xc1,0xc0,0x52,0x49,0xca,0xa7,0x62,0xad,0x0f,0x64,0xbb,0x0a,0xdc,0xc5,0x7b,0x37,0x66,0xc9,0x40,0x0e,0x77,0x5b,0x5d,0x5b,0x2f,0x86,0x0c,0x30,0xb3,0x73,0x50,0x4c,0x4b,0xa3,0xfb,0xcc,0x21,0xbb,0xc9,0x21,0x14,0x66,0x83,0xa1,0x8a,0x8f,0x27,0xfb,0xc7,0x47,0x17,0x84,0xa6,0x29,0x9d,0x61,0xf6,0x63,0x09,0x16,0x16,0x28,0x6e,0x68,0x7a,0x4c,0x9f,0x23,0x88,0x18,0x42,0x55,0xb9,0x56,0x18,0xaa,0x0b,0x74,0x8f,0x28,0xe8,0xd5,0x42,0x63,0x75,0x22,0xdb,0xdb,0xd5,0x51,0x86,0x4f,0x75,0x39,0xe9,0x46,0x10,0x24,0x52,0x89,0x84,0x57,0xb8,0xb3,0x9d,0xb1,0x1a,0x60,0x17,0xe8,0xae,0xa3,0x9b,0x17,0x1e,0x34,0x53,0x51,0x48,0x5a,0x1b,0x1b,0xcb,0xeb,0x18,0x13,0xf7,0x2a,0x8b,0x1d,0x1f,0xd7,0x7c,0x67,0x0c,0x5e,0xe4,0x95,0x5c,0xab,0x06,0x4f,0xf9,0x41,0x81,0x28,0x5f,0x35,0x98,0xba,0xc0,0x1e,0xb0,0x9c,0xb0,0xf4,0xd3,0xe5,0xf1,0x67,0xcf,0x5f,0x23,0x35,0x7f,0xb0,0x30,0x7e,0x35,0x8f,0x16,0xaa,0x68,0x7d,0x02,0x42,0x9d,0xee,0x19,0x28,0xd3,0x6b,0xa8,0x76,0x62,0xfd,0xd5,0x1c,0xbf,0x79,0x9f,0xa8,0xf3,0x78,0xbe,0x6e,0x46,0xfd,0xbd,0xec,0xa2,0xe3,0xe3,0x74,0xd0,0x5f,0xac,0x63,0xb5,0xbe,0x0e,0xae,0x8c,0x5c,0xac,0x13,0x1d,0x62,0x60,0x37,0x6e,0x83,0x7b,0x9e,0x28,0xa4,0xde,0xfa,0x4a,0x13,0xbf,0xbe,0xfb,0x2c,0xcf,0x79,0xa4,0x01,0xa1,0x7c,0xf9,0xe2,0xfb,0x8f,0xf0,0x0f,0x05,0x44,0x17,0x6d,0x0e,0x95,0xad,0x8f,0x00,0x6c,0xd7,0x94,0xd9,0xe2,0xc3,0xec,0x92,0x0e,0x50,0x5f,0x18,0x7b,0x00,0x0e,0x32,0xb9,0xfa,0xc6,0xa8,0x73,0x04,0xbe,0x2c,0x31,0x04,0x31,0x10,0x38,0xc4,0x31,0x6c,0x31,0xc0,0xf9,0xc1,0x86,0x98,0x0b,0xde,0x02,0x58,0x5c,0x01,0x76,0x1b,0x48,0x0b,0xab,0x15,0x74,0x88,0x7c,0x44,0x92,0x47,0xd6,0xb2,0x1a,0xdb,0x3a,0x1e,0x16,0xc3,0xa0,0x1c,0xaa,0xea,0xf7,0xe5,0x3d,0x9b,0x37,0x76,0xb1,0x09,0x5c,0xf1,0x2b,0xb6,0x6c,0x99,0x2d,0xc5,0x38,0xa3,0x96,0x9b,0x6d,0xcd,0x4d,0x3e,0x84,0xa8,0x05,0x7a,0x7b,0x53,0x44,0x82,0xa5,0xa9,0x04,0x84,0x4a,0x48,0x99,0x95,0x0a,0xc5,0x76,0xc0,0xa1,0x42,0x4f,0x9b,0x86,0x11,0x04,0x04,0x5e,0x13,0xd8,0xdb,0x39,0x05,0xa6,0xbf,0xeb,0x0a,0x2f,0x00,0xb2,0x0b,0x34,0x65,0x51,0xa1,0xe3,0x5e,0x0f,0xf9,0x24,0x15,0xce,0x28,0x4a,0x26,0x92,0x89,0x9b,0x0c,0x91,0x2b,0xa0,0xc4,0x84,0xfa,0x19,0x6a,0x5a,0x77,0x44,0xc7,0x96,0x2e,0x4c,0xf2,0x2c,0xbb,0x99,0x13,0x56,0xdb,0x5f,0x63,0xdc,0x7b,0x63,0x70,0xbc,0x7e,0xd7,0xaa,0x63,0x03,0xb6,0xd8,0x0b,0x38,0x5e,0x85,0x11,0x25,0xfe,0x6f,0x67,0x63,0xeb,0xdf,0x67,0x63,0x0b,0xd9,0xc8,0x78,0x28,0xe9,0xb3,0x10,0xea,0xf6,0xd7,0x08,0x75,0xbb,0x22,0xd4,0x42,0xe3,0x05,0x9a,0xb7,0x5f,0x83,0xe6,0x2d,0xa2,0x29,0x27,0xab,0x72,0x3e,0x55,0x71,0x55,0xa7,0x85,0x3c,0x89,0x77,0x57,0xac,0x43,0xd3,0x78,0xbc,0x82,0x52,0x45,0xd3,0x67,0x9c,0xd1,0x32,0x93,0xb7,0x7c,0x71,0xdf,0xb8,0x38,0xf2,0x57,0x7b,0xb9,0x52,0xfa,0x9e,0x63,0xc6,0x38,0xc3,0xb2,0x55,0xa5,0x0a,0x78,0x04,0xc5,0x1f,0x7a,0xf7,0x1a,0x2a,0x0b,0xeb,0x2a,0x78,0x28,0x1d,0x64,0x0a,0x2f,0x6e,0xbc,0x9a,0xf2,0x2b,0x53,0xde,0x25,0x14,0x19,0xd7,0x33,0xc8,0x65,0xce,0x08,0xfa,0x98,0x21,0x14,0x29,0xb3,0x1b,0x2f,0x43,0x91,0x01,0x35,0xaa,0x1a,0x76,0x94,0x41,0x18,0x7b,0x70,0xb4,0x67,0x7a,0xad,0x1b,0x2f,0x23,0xf8,0x88,0x61,0x38,0x6c,0xcc,0x83,0xa1,0x57,0xca,0xcc,0x28,0x03,0xf7,0xea,0xf2,0xc0,0x2a,0x18,0x68,0xb4,0x91,0x05,0x67,0x95,0x80,0xdd,0xc4,0x22,0xb3,0x6b,0xad,0x14,0xca,0x7f,0xbf,0x35,0x53,0x7c,0x81,0x22,0xb2,0xd2,0x75,0x01,0x6a,0xe1,0x77,0x1b,0x1b,0x8f,0x55,0x68,0x50,0x60,0x82,0x7f,0x94,0xbb,0x90,0x3c,0xd4,0x42,0x15,0x94,0xce,0x2e,0x54,0x94,0xe4,0xe9,0x7e,0x1c,0x9b,0x30,0xeb,0xe6,0xa0,0x26,0xd9,0x82,0x61,0xb6,0xf6,0x9e,0xaa,0x16,0x3b,0x4f,0x35,0x36,0x79,0xcf,0xb1,0x09,0xdd,0x32,0x9c,0xf9,0xd1,0xa6,0xa3,0x3a,0xbe,0x9c,0x3f,0x45,0x50,0xb5,0x14,0x86,0xcd,0x5f,0x54,0xcb,0xe6,0x7d,0xfd,0xa9,0x1c,0x31,0xf6,0xe6,0x8b,0xd5,0x14,0x54,0xc1,0x67,0x43,0x80,0xd1,0xfb,0xb4,0x63,0xe6,0xa2,0xd5,0x2a,0x2d,0x5b,0x78,0x97,0xc5,0x60,0xdc,0x4b,0xf0,0xcb,0xb5,0xbf,0x72,0xc1,0x87,0x72,0xff,0xf6,0x78,0x87,0xb0,0x6a,0x38,0xff,0x77,0x4d,0xfd,0x12,0x07,0x0e,0x34,0xc7,0x9d,0x87,0x45,0xc5,0xaa,0x56,0x98,0x7c,0xc2,0xb8,0x16,0xcb,0xb2,0x70,0x55,0x86,0x10,0xbf,0x43,0xf5,0xaf,0xec,0x13,0xc2,0x54,0x16,0x11,0x4c,0x0d,0x0a,0x5b,0xc3,0x18,0xb0,0xaf,0x29,0x65,0xe0,0xdb,0xa3,0x6c,0xa7,0x76,0x4c,0xd8,0x02,0xd9,0xb9,0x2b,0xc6,0xd7,0x51,0x78,0x63,0x9e,0xea,0x30,0xa8,0xaf,0x55,0xfd,0x53,0x54,0x3c,0xd8,0x4c,0xac,0x80,0xaa,0xc0,0x35,0x65,0xe9,0x01,0x15,0xa0,0x30,0x0d,0x0d,0x25,0x9b,0x6e,0x95,0x97,0x7b,0x6a,0xa3,0x04,0x7b,0x71,0xda,0xfb,0x0b,0x8c,0xc8,0xbd,0x63,0x33,0x01,0x38,0x33,0x6f,0x80,0x22,0x10,0x0a,0x43,0x6b,0xc5,0xb7,0xc7,0xff,0x71,0x0d,0x01,0x4d,0xad,0x87,0xbd,0x8a,0x69,0xe6,0x85,0xb3,0x2e,0xd5,0x76,0xe7,0x99,0xc4,0x5e,0x94,0xec,0x74,0x63,0xc3,0x58,0xfd,0x13,0xba,0xb2,0x9f,0xf4,0x5b,0xdb,0x29,0x9d,0x30,0x9b,0x05,0x2c,0x47,0xfa,0xe5,0x11,0xb5,0x32,0x73,0x9c,0x6d,0x2b,0x56,0x55,0x2c,0xaf,0x0c,0xbf,0xcd,0x90,0x20,0x87,0x70,0xf1,0x2a,0x2f,0xea,0xe7,0x90,0x5a,0xa0,0xd1,0xf1,0x4f,0xb8,0xc2,0x41,0x74,0x05,0x87,0xbc,0x9a,0x31,0xc7,0x22,0x43,0xef,0x2d,0x61,0xb8,0x6e,0xdd,0x74,0x9f,0x1b,0x53,0x70,0x49,0xbf,0x4d,0x45,0x1c,0x78,0x90,0x0d,0xd0,0x0b,0xa3,0xa3,0x4c,0x55,0x48,0x75,0x81,0x6c,0xe5,0xd3,0x8e,0x3d,0xc3,0xbc,0x19,0xd2,0x8b,0x49,0x10,0x30,0x21,0xfa,0x93,0xd8,0x25,0x66,0x42,0x3b,0x82,0xf6,0x48,0x0f,0x68,0x5d,0xdf,0xee,0x54,0xc1,0xb1,0x17,0x65,0x61,0x87,0xf8,0x6f,0x72,0x94,0x7a,0xac,0x62,0xba,0xdf,0x5c,0x34,0x4c,0x4e,0x79,0x7a,0x47,0x54,0x07,0x4c,0xc2,0x89,0x9a,0xf1,0x6a,0x2d,0x80,0x46,0x8b,0x02,0x20,0x7f,0xfd,0x62,0x45,0xf6,0xfc,0x7b,0xc4,0x91,0x3e,0xd8,0x3f,0x9a,0x56,0xc2,0xe2,0x4e,0x54,0x37,0xe0,0xad,0x79,0x21,0xa4,0xd4,0xa5,0xe7,0x6a,0x66,0x14,0xef,0x7f,0xe4,0x29,0x18,0x0b,0x70,0xe9,0x9f,0x63,0xff,0x28,0x18,0x5c,0x5d,0x01,0x6a,0x1f,0xdf,0x49,0xf8,0x37,0x0e,0x76,0xb2,0x09,0x0b,0x0f,0x78,0x88,0xe0,0xe8,0xbf,0x4e,0xf5,0xe3,0x46,0x19,0x58,0x3e,0x8a,0xb8,0xc4,0x89,0x83,0x1a,0x8d,0x1b,0xfa,0x84,0xc2,0xf5,0x36,0xbe,0xc0,0x4a,0xd5,0x0b,0x2c,0x43,0x5f,0xe0,0xf4,0x55,0x18,0xce,0xdc,0xb5,0x35,0x3d,0xd7,0x3d,0xfd,0x17,0xf6,0xb3,0x6a,0x40,0xef,0x60,0xf9,0x92,0x90,0x3e,0xc7,0x5f,0xa1,0xa8,0x52,0x46,0x4f,0x86,0x05,0xe8,0x32,0x1b,0x74,0x61,0x60,0x3b,0xd4,0x1e,0x84,0x04,0x02,0xfd,0x63,0x2d,0x91,0xa9,0xc9,0x70,0x30,0xc2,0x60,0xf7,0xfd,0x02,0x7c,0xff,0xd6,0x38,0xb5,0x1e,0xdc,0xe6,0x69,0xcf,0x6b,0x75,0xa3,0x9d,0xed,0x6e,0xf4,0xe6,0x8d,0x6a,0x16,0xca,0x06,0x63,0x3c,0x1f,0x2b,0xbf,0x33,0x38,0x64,0x04,0x41,0x13,0xc4,0xc1,0xe3,0x7b,0xe8,0xaf,0x4c,0x65,0xc9,0x27,0x32,0x5b,0x73,0xda,0x38,0xde,0x70,0x0a,0x99,0xeb,0x57,0x7b,0x04,0x3a,0xcc,0x37,0xed,0x45,0x73,0xbb,0x03,0x57,0x25,0x25,0x43,0x73,0xb8,0xf8,0x33,0xf9,0x33,0xd1,0x12,0x46,0x41,0xae,0x3c,0x2e,0x8d,0xd9,0x67,0x50,0x5b,0x65,0x9a,0x4a,0xf8,0xd4,0x68,0x61,0x6c,0xb4,0xe3,0x16,0x88,0x0e,0x70,0x8e,0x1e,0xab,0xe1,0xfb,0x5d,0x34,0xd6,0x93,0x26,0x8d,0x06,0x15,0x34,0x2f,0x8e,0xd7,0x80,0xc8,0x56,0xb6,0x22,0x20,0xe8,0x35,0xda,0xf8,0xd2,0x47,0x42,0x09,0xc7,0x54,0xb9,0xf2,0xbb,0x52,0x0e,0x38,0x58,0x00,0x10,0xda,0x04,0x88,0xd9,0x43,0xac,0x31,0x98,0x80,0x7a,0x48,0x49,0x2f,0x92,0xb6,0xca,0x5b,0xe6,0x21,0xce,0x71,0x55,0xc2,0x43,0xcc,0xde,0x12,0x95,0x5c,0xf4,0x38,0x25,0x04,0xcb,0x01,0x05,0x98,0xab,0x9d,0xb7,0xf9,0x25,0x6a,0xe3,0x1b,0xa4,0xaf,0xc7,0x3c,0x43,0x16,0xdc,0xe1,0x80,0x4b,0x71,0x3d,0xa5,0x22,0xe7,0xb9,0x37,0x23,0xc8,0x35,0x1a,0x21,0xd8,0xa5,0x0e,0x2c,0xe4,0x3e,0xa2,0x04,0x0d,0x6f,0x2d,0x0b,0x9c,0xc5,0x8c,0xd6,0xfa,0x9e,0xe6,0x69,0xc6,0xc7,0xba,0xe8,0x28,0xcd,0x84,0xf3,0xe3,0x28,0x5d,0x8a,0x31,0x0b,0xa2,0x7e,0x14,0x80,0x9f,0x86,0xec,0x21,0x1f,0xd8,0xf7,0x41,0x42,0x64,0x3a,0xa4,0x92,0x4c,0x19,0x51,0xa2,0x87,0x45,0x9c,0x35,0xe2,0xcc,0x58,0x0d,0x31,0x03,0x23,0x7e,0xc8,0x8e,0x8d,0xf6,0xc6,0xc6,0xf2,0x1a,0xc6,0x8c,0xd5,0xd5,0x5c,0x89,0x18,0xa3,0xaa,0xb6,0x52,0x01,0x75,0x72,0xc5,0xb7,0xba,0x3d,0xc8,0x0f,0x77,0x8b,0x67,0x86,0x95,0x01,0x1e,0xaa,0xa2,0x87,0x8e,0x9a,0x59,0x62,0x43,0xfb,0xc2,0x20,0xb3,0xf5,0xb8,0xdb,0x04,0x30,0xad,0x6e,0x82,0x0a,0xc1,0x7d,0x68,0x78,0x8f,0x39,0x8c,0x72,0x87,0x73,0x06,0xfa,0x2c,0xdb,0xff,0x1e,0xda,0x7f,0xd4,0x68,0x14,0x26,0xae,0x8a,0x34,0x14,0xf1,0xc5,0x92,0xab,0xac,0xad,0x3a,0xc6,0xa2,0x34,0x9e,0xd7,0xa5,0xb2,0x9a,0xcf,0x0b,0xc5,0x48,0x3e,0x49,0x14,0xe4,0x7d,0xa3,0xbd,0x49,0xac,0xb3,0xfd,0xf3,0xfd,0xe3,0xdb,0x7f,0x1d,0xfd,0x71,0x70,0x7a,0x78,0x74,0xdb,0xca,0xa7,0x84,0xd5,0xf5,0x2d,0x7b,0xad,0x36,0x0c,0xe5,0xe5,0x78,0xd6,0x04,0xbe,0x9a,0xbf,0x7f,0x13,0x2d,0xb0,0x68,0xc0,0x55,0xa8,0xba,0x4a,0x05,0xda,0xb2,0x7b,0x55,0xba,0x62,0xfd,0x72,0x44,0x8f,0x82,0x0f,0x54,0x81,0x43,0xfe,0x9a,0x08,0xa9,0xc2,0x0d,0x48,0x1e,0x4a,0x3a,0xa5,0x41,0xa2,0x87,0x33,0x9a,0x7b,0xed,0xc9,0x4b,0xcd,0x41,0x89,0x3d,0x28,0x2b,0x81,0x9b,0x9b,0x15,0xb7,0x06,0x6d,0x7d,0xcf,0x62,0x50,0xd7,0xcf,0x57,0xc9,0x30,0x7f,0x79,0x85,0x87,0x32,0x27,0x32,0x2f,0xb0,0xbe,0x51,0xbc,0xcf,0x97,0x8c,0x4b,0x61,0x46,0x09,0xd6,0x04,0x6b,0x01,0x6d,0x70,0x8c,0x2f,0xf1,0xa1,0xca,0xd1,0xef,0xce,0xc2,0xb5,0x6f,0x6a,0x35,0xcd,0xe4,0xe3,0xb1,0xde,0x4f,0x33,0x71,0xce,0x1a,0xe6,0x05,0x5d,0x39,0xd1,0xd2,0x3e,0x76,0x14,0xff,0x5f,0x79,0x56,0x33,0xa4,0xd3,0xac,0xf2,0xae,0x21,0x54,0x0a,0xe6,0x97,0x34,0xda,0xb6,0xf4,0xb5,0xe7,0xe7,0x3f,0x9f,0x21,0x67,0x05,0xaf,0x68,0xa8,0x63,0x1c,0xb5,0xbf,0x58,0x5b,0xf3,0x6b,0x2d,0x70,0xd9,0x3b,0x31,0xa2,0xed,0x19,0xa4,0x6f,0x3c,0x7f,0x25,0x2c,0x74,0xc8,0x09,0x97,0xb9,0x38,0x58,0xf8,0x67,0xe2,0x77,0x9e,0x04,0x7f,0xb5,0x1c,0xed,0x20,0x53,0xfb,0x5d,0x5d,0x7a,0x9a,0x8d,0x5f,0xd5,0x16,0xac,0xfc,0xa4,0xe4,0xd9,0x77,0x88,0x31,0x1f,0xd4,0xbc,0x40,0xc4,0xf0,0x31,0x25,0x47,0x3a,0x80,0x66,0xa5,0x6f,0x06,0xa0,0x32,0x1c,0xbe,0x64,0xe2,0x77,0xbe,0x7e,0x5f,0xdf,0x8b,0x79,0x6f,0xf9,0x25,0x23,0xae,0x59,0xb6,0x03,0xb5,0x83,0xf7,0xd8,0x64,0xcb,0x01,0x59,0x8f,0x30,0xff,0x86,0x78,0xe7,0x15,0xef,0x72,0x60,0x13,0xce,0xa3,0xb3,0xe9,0xd7,0xf2,0x9b,0x98,0x57,0xf3,0x6b,0xff,0xd7,0xfd,0x13,0x28,0x4e,0x3f,0x1e,0x7d,0x80,0xcf,0xe3,0xfd,0x73,0xf8,0xdc,0x3f,0x3b,0x57,0xd7,0x7f,0xc0,0xe7,0xaf,0x57,0x27,0xea,0xf3,0x33,0xae,0x5f,0xfd,0x0c,0x9f,0x17,0x47,0x67,0xf0,0x79,0x7a,0x00,0x76,0xe7,0x9f,0x9c,0xfe,0x86,0x85,0xed,0xd1,0x81,0x7f,0x73,0x6d,0x48,0x1d,0xe3,0x58,0xc9,0xb2,0x6f,0x00,0xb7,0x59,0xf9,0x08,0xf9,0xe9,0x0f,0x50,0x0a,0x08,0xb9,0xb1,0xcc,0xd8,0x27,0x9c,0x55,0xd6,0x73,0x56,0x05,0x3c,0xd6,0x93,0xcc,0x3a,0x50,0xdf,0x99,0xa4,0xb1,0x77,0x75,0xfe,0xd9,0x0d,0x20,0x7f,0x49,0xa6,0x9b,0x5e,0xb8,0xb7,0x50,0x72,0xa0,0xed,0x62,0xb2,0xa2,0x01,0xcc,0x74,0xde,0xf2,0x29,0x48,0x9d,0xba,0xc3,0x94,0xf5,0x3d,0x40,0xe1,0x50,0x37,0xd3,0x3a,0xfe,0xd2,0x85,0xa7,0x74,0xc0,0x80,0xe1,0x8a,0x68,0x17,0xf8,0x83,0x28,0xbf,0x18,0x40,0xa1,0x37,0xb9,0xf8,0x1b,0xde,0x24,0x3c,0x18,0x46,0x71,0x68,0x51,0xa0,0xe7,0xaa,0x59,0xbe,0x65,0x2f,0x81,0xe9,0x58,0x94,0x83,0x21,0xc3,0x29,0xbb,0xe7,0x77,0x25,0x86,0x81,0x8b,0xfc,0x5d,0x21,0x9a,0xcc,0x4a,0x0a,0xce,0x7f,0xd7,0x64,0xba,0x2d,0xc8,0xbc,0x0a,0x4e,0xff,0x1a,0xe0,0x17,0xfd,0x9f,0x24,0xc8,0x67,0x80,0x58,0x9b,0x42,0x99,0x01,0xb2,0xe3,0xfa,0x40,0x25,0x63,0xef,0xee,0x34,0xcd,0xaf,0x8a,0x76,0x9a,0xfa,0xd7,0xc8,0x4d,0xf5,0x1f,0x34,0xfe,0x17,0xf9,0xba,0x34,0x68,0xb0,0x31,0x00,0x00}; -const unsigned int html_content_len = 3065; +const unsigned int html_content_len = 4418; diff --git a/main/webpage_minified.html b/main/webpage_minified.html index 7241e11..9e5a613 100644 --- a/main/webpage_minified.html +++ b/main/webpage_minified.html @@ -1,22 +1,52 @@ -Control Panel
Schedule Start
Schedule End
# Moves/Day
Move Distanceft
Jack Heightin
Time
BatteryV

DANGER ZONE
Program RF Remote
Calibration
Firmware
Log File
\ No newline at end of file diff --git a/main/webserver.c b/main/webserver.c index 8fbf4ab..b9c9868 100644 --- a/main/webserver.c +++ b/main/webserver.c @@ -15,6 +15,7 @@ #include "power_mgmt.h" #include "rf_433.h" #include "rtc.h" +#include "simple_dns_server.h" #include "string.h" #include "freertos/FreeRTOS.h" #include "freertos/task.h" @@ -24,6 +25,7 @@ #include "esp_log.h" #include "nvs_flash.h" #include "esp_http_server.h" +//#include "esp_https_server.h" #include "esp_netif.h" #include #include @@ -31,7 +33,8 @@ #include #include "stdio.h" #include "storage.h" -//#include "mdns.h" +#include "mdns.h" + #include "webpage.h" #include "esp_partition.h" @@ -44,10 +47,17 @@ static const char *TAG = "WEBSERVER"; +// HTTPS +/* +extern const uint8_t servercert_pem_start[] asm("_binary_servercert_pem_start"); +extern const uint8_t servercert_pem_end[] asm("_binary_servercert_pem_end"); +extern const uint8_t prvtkey_pem_start[] asm("_binary_prvtkey_pem_start"); +extern const uint8_t prvtkey_pem_end[] asm("_binary_prvtkey_pem_end"); +*/ static httpd_handle_t httpServerInstance = NULL; -char httpBuffer[1024]; +char httpBuffer[4096]; /* Handler to serve the HTML page */ static esp_err_t root_get_handler(httpd_req_t *req) { @@ -55,131 +65,174 @@ static esp_err_t root_get_handler(httpd_req_t *req) { // Send the HTML response httpd_resp_set_type(req, "text/html"); // Original MIME type - httpd_resp_set_hdr(req, "Content-Encoding", "gzip"); // Tell browser it's gzipped - return httpd_resp_send(req, (const char *)html_content, html_content_len); + httpd_resp_set_hdr(req, "Content-Encoding", "gzip"); // Tell browser it's gzipped + return httpd_resp_send(req, (const char *)html_content, html_content_len); } +// Cache the storage partition pointer to avoid repeated lookups +static const esp_partition_t *cached_storage_partition = NULL; + static esp_err_t log_handler(httpd_req_t *req) { ESP_LOGI(TAG, "log_handler"); - - int32_t tail = -1; + int32_t tail = -1; if (req -> method == HTTP_GET) { - // give the whole log - } - if (req -> method == HTTP_POST) { - int ret = httpd_req_recv(req, httpBuffer, sizeof(httpBuffer)); - if (ret <= 0) { - if (ret == HTTPD_SOCK_ERR_TIMEOUT) { - httpd_resp_send_408(req); - } - return ESP_FAIL; - } - httpBuffer[ret] = '\0'; // Null-terminate the string - - ESP_LOGI(TAG, "ST POST %.*s", ret, httpBuffer); - - if(sscanf(httpBuffer, "%ld", (long*)&tail) != 1) { - // if malformed, just send the whole log. - //httpd_resp_send_err(req, 400, "INVALID TAIL POINTER"); - } - } + // give the whole log + } + if (req -> method == HTTP_POST) { + int ret = httpd_req_recv(req, httpBuffer, sizeof(httpBuffer)); + if (ret <= 0) { + if (ret == HTTPD_SOCK_ERR_TIMEOUT) { + httpd_resp_send_408(req); + } + return ESP_FAIL; + } + httpBuffer[ret] = '\0'; // Null-terminate the string + + //ESP_LOGI(TAG, "LOG POST %.*s", ret, httpBuffer); + + if(sscanf(httpBuffer, "%ld", (long*)&tail) != 1) { + // if malformed, just send the whole log. + tail = -1; + } + } - const esp_partition_t *storage_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, "storage"); + // Use cached partition pointer instead of looking it up each time + const esp_partition_t *storage_partition = cached_storage_partition; if (storage_partition == NULL) { - ESP_LOGE(TAG, "Storage partition not found"); - return httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Storage partition not found"); + // Fall back to lookup if cache is empty (shouldn't happen in normal operation) + storage_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, + ESP_PARTITION_SUBTYPE_ANY, + "storage"); + if (storage_partition == NULL) { + ESP_LOGE(TAG, "Storage partition not found"); + return httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, + "Storage partition not found"); + } + cached_storage_partition = storage_partition; } - // Figure out the bounds of data - if (tail < 0) - tail = get_log_tail(); + // Get head and tail atomically and store in local variables + // This releases the mutex before we do any partition operations int32_t head = get_log_head(); - int32_t total_size = head - tail + 8; // 8 bytes for the head/tail pointers - int32_t offset = tail; - int32_t sent = 0; + int32_t log_start = get_log_offset(); - if (tail >= head) { - total_size = storage_partition->size - tail + head - get_log_offset() + 8; + if (tail < 0) { + tail = get_log_tail(); + } else { + // Validate tail is within log area bounds + if (tail < log_start || tail >= (int32_t)storage_partition->size) { + ESP_LOGW(TAG, "Invalid tail pointer %ld, using current tail", (long)tail); + tail = get_log_tail(); + } + // Also validate tail is aligned to LOG_ENTRY_SIZE + if ((tail - log_start) % LOG_ENTRY_SIZE != 0) { + ESP_LOGW(TAG, "Tail pointer %ld not aligned to entry size, using current tail", + (long)tail); + tail = get_log_tail(); + } + } + + // Calculate total size to send + int32_t total_size; + if (tail == head) { + // Empty log - just send pointers + total_size = 8; + } else if (tail < head) { + // Normal case: tail before head + total_size = head - tail + 8; // +8 for head/tail pointers + } else { + // Wrapped case: tail after head + total_size = (storage_partition->size - tail) + (head - log_start) + 8; } - ESP_LOGI(TAG, "start/end: %ld/%ld -> %ld", (long)tail, (long)head, (long)total_size); + //ESP_LOGI(TAG, "Log bounds: tail=%ld, head=%ld, total_size=%ld", + // (long)tail, (long)head, (long)total_size); - // Send header + // Send HTTP headers char len_str[16]; sprintf(len_str, "%u", (unsigned)total_size); httpd_resp_set_type(req, "application/octet-stream"); httpd_resp_set_hdr(req, "Content-Disposition", "attachment; filename=\"sc_storage.bin\""); httpd_resp_set_hdr(req, "Content-Length", len_str); - - int32_t htail = htobe32(tail); - int32_t hhead = htobe32(head); - // Send head/tail pointers + // Send head/tail pointers in big-endian format + int32_t htail = htobe32(tail); + int32_t hhead = htobe32(head); memcpy(&httpBuffer[0], &(htail), 4); memcpy(&httpBuffer[4], &(hhead), 4); if (httpd_resp_send_chunk(req, (const char *)httpBuffer, 8) != ESP_OK) { - ESP_LOGE(TAG, "Failed to send chunk"); + ESP_LOGE(TAG, "Failed to send head/tail chunk"); return ESP_FAIL; } - sent += 8; + int32_t sent = 8; + int32_t offset = tail; + + // Only send data if there's something to send if (tail != head) { - // Send data between tail and end (if wrapped) - if (tail >= head) { - ESP_LOGI(TAG, "STARTING wrapped section (tail=%ld, head=%ld)", (long)tail, (long)head); - while (offset < storage_partition->size) { - // FIXED: Don't limit by head in this section - read to end of partition - size_t to_read = MIN(sizeof(httpBuffer), storage_partition->size - offset); - esp_err_t err = esp_partition_read(storage_partition, offset, httpBuffer, to_read); - if (err != ESP_OK) { - ESP_LOGE(TAG, "Failed to read partition: %s", esp_err_to_name(err)); - return httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read storage"); - } - ESP_LOGI(TAG, "Sending wrapped chunk: offset=%ld size=%d", (long)offset, to_read); - if (httpd_resp_send_chunk(req, (const char *)httpBuffer, to_read) != ESP_OK) { - ESP_LOGE(TAG, "Failed to send chunk"); - return ESP_FAIL; - } - sent += to_read; - offset += to_read; - } - // Loop back to the beginning - offset = get_log_offset(); - ESP_LOGI(TAG, "Wrapped to beginning, offset now=%ld", (long)offset); - } - - // Send data between start (or tail) and head - ESP_LOGI(TAG, "FINISHING final section (offset=%ld, head=%ld)", (long)offset, (long)head); - while (offset < head) { - size_t to_read = MIN(sizeof(httpBuffer), head - offset); - esp_err_t err = esp_partition_read(storage_partition, offset, httpBuffer, to_read); - if (err != ESP_OK) { - ESP_LOGE(TAG, "Failed to read partition: %s", esp_err_to_name(err)); - return httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read storage"); - } - ESP_LOGI(TAG, "Sending final chunk: offset=%ld size=%d", (long)offset, to_read); - if (httpd_resp_send_chunk(req, (const char *)httpBuffer, to_read) != ESP_OK) { - ESP_LOGE(TAG, "Failed to send chunk"); - return ESP_FAIL; - } - sent += to_read; - offset += to_read; - } - - ESP_LOGI(TAG, "Transfer complete: sent %ld bytes (expected %ld)", (long)sent, (long)total_size); - - + // Handle wrapped case: send from tail to end of partition first + if (tail > head) { + //ESP_LOGI(TAG, "Wrapped log: sending tail=%ld to partition_end=%lu", + // (long)tail, (unsigned long)storage_partition->size); + + while (offset < (int32_t)storage_partition->size) { + size_t to_read = MIN(sizeof(httpBuffer), storage_partition->size - offset); + esp_err_t err = esp_partition_read(storage_partition, offset, httpBuffer, to_read); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Failed to read partition at offset %ld: %s", + (long)offset, esp_err_to_name(err)); + return httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, + "Failed to read storage"); + } + + if (httpd_resp_send_chunk(req, (const char *)httpBuffer, to_read) != ESP_OK) { + ESP_LOGE(TAG, "Failed to send chunk at offset %ld", (long)offset); + return ESP_FAIL; + } + + sent += to_read; + offset += to_read; + } + + // Wrap to beginning of log area + offset = log_start; + //ESP_LOGI(TAG, "Wrapped to log start, offset=%ld", (long)offset); + } + + // Send from current offset to head + //ESP_LOGI(TAG, "Sending final section: offset=%ld to head=%ld", (long)offset, (long)head); + + while (offset < head) { + size_t to_read = MIN(sizeof(httpBuffer), head - offset); + esp_err_t err = esp_partition_read(storage_partition, offset, httpBuffer, to_read); + if (err != ESP_OK) { + ESP_LOGE(TAG, "Failed to read partition at offset %ld: %s", + (long)offset, esp_err_to_name(err)); + return httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, + "Failed to read storage"); + } + + if (httpd_resp_send_chunk(req, (const char *)httpBuffer, to_read) != ESP_OK) { + ESP_LOGE(TAG, "Failed to send chunk at offset %ld", (long)offset); + return ESP_FAIL; + } + + sent += to_read; + offset += to_read; + } } + //ESP_LOGI(TAG, "Transfer complete: sent %ld bytes (expected %ld)", (long)sent, (long)total_size); + // End chunked transfer if (httpd_resp_send_chunk(req, NULL, 0) != ESP_OK) { ESP_LOGE(TAG, "Failed to send final empty chunk"); return ESP_FAIL; } - ESP_LOGI(TAG, "Final empty chunk sent successfully"); + //ESP_LOGI(TAG, "Final empty chunk sent successfully"); return ESP_OK; } @@ -188,7 +241,7 @@ static esp_err_t st_post_handler(httpd_req_t *req) { ESP_LOGI(TAG, "st_post_handler"); // Send the HTML response - int ret = httpd_req_recv(req, httpBuffer, sizeof(httpBuffer)); + int ret = httpd_req_recv(req, httpBuffer, sizeof(httpBuffer)); if (ret <= 0) { if (ret == HTTPD_SOCK_ERR_TIMEOUT) { httpd_resp_send_408(req); @@ -196,18 +249,17 @@ static esp_err_t st_post_handler(httpd_req_t *req) { return ESP_FAIL; } httpBuffer[ret] = '\0'; // Null-terminate the string - - ESP_LOGI(TAG, "ST POST %.*s", ret, httpBuffer); - int64_t tv = -1; - - /*if(sscanf(httpBuffer, "%d-%d-%dT%d:%d", &tv) == 1) { - system_rtc_set_raw_time(tv); - }*/ - if(sscanf(httpBuffer, "%lld", &tv) == 1) { - system_rtc_set_raw_time(tv); - } - - + + ESP_LOGI(TAG, "ST POST %.*s", ret, httpBuffer); + int64_t tv = -1; + + /*if(sscanf(httpBuffer, "%d-%d-%dT%d:%d", &tv) == 1) { + system_rtc_set_raw_time(tv); + }*/ + if(sscanf(httpBuffer, "%lld", &tv) == 1) { + system_rtc_set_raw_time(tv); + } + return httpd_resp_send(req, "200 OK", HTTPD_RESP_USE_STRLEN); } @@ -274,53 +326,50 @@ static esp_err_t sp_post_handler(httpd_req_t *req) { } // Get the value - if (!cJSON_IsNumber(item)) { - ESP_LOGW(TAG, "Parameter %s has non-numeric value", key); - params_failed++; - continue; - } + if (cJSON_IsNumber(item)) { - double param_val = item->valuedouble; - - ESP_LOGI(TAG, "Updating Param '%s' (ID: %d) to Value: %.2f", key, param_id, param_val); - - // Set the parameter based on its type - switch(get_param_type(param_id)) { - case PARAM_TYPE_u8: - set_param_value_t(param_id, (param_value_t){.u8 = round(param_val)}); - break; - case PARAM_TYPE_i8: - set_param_value_t(param_id, (param_value_t){.i8 = round(param_val)}); - break; - case PARAM_TYPE_u16: - set_param_value_t(param_id, (param_value_t){.u16 = round(param_val)}); - break; - case PARAM_TYPE_i16: - set_param_value_t(param_id, (param_value_t){.i16 = round(param_val)}); - break; - case PARAM_TYPE_u32: - set_param_value_t(param_id, (param_value_t){.u32 = round(param_val)}); - break; - case PARAM_TYPE_i32: - set_param_value_t(param_id, (param_value_t){.i32 = round(param_val)}); - break; - case PARAM_TYPE_u64: - set_param_value_t(param_id, (param_value_t){.u64 = round(param_val)}); - break; - case PARAM_TYPE_i64: - set_param_value_t(param_id, (param_value_t){.i64 = round(param_val)}); - break; - case PARAM_TYPE_f32: - set_param_value_t(param_id, (param_value_t){.f32 = param_val}); - break; - case PARAM_TYPE_f64: - set_param_value_t(param_id, (param_value_t){.f64 = param_val}); - break; - default: - ESP_LOGW(TAG, "Unknown parameter type for ID %d", param_id); - params_failed++; - continue; - } + double param_val = item->valuedouble; + + ESP_LOGI(TAG, "Updating Param '%s' (ID: %d) to Value: %.2f", key, param_id, param_val); + + // Set the parameter based on its type + switch(get_param_type(param_id)) { + case PARAM_TYPE_u16: + set_param_value_t(param_id, (param_value_t){.u16 = round(param_val)}); + break; + case PARAM_TYPE_i16: + set_param_value_t(param_id, (param_value_t){.i16 = round(param_val)}); + break; + case PARAM_TYPE_u32: + set_param_value_t(param_id, (param_value_t){.u32 = round(param_val)}); + break; + case PARAM_TYPE_i32: + set_param_value_t(param_id, (param_value_t){.i32 = round(param_val)}); + break; + case PARAM_TYPE_u64: + set_param_value_t(param_id, (param_value_t){.u64 = round(param_val)}); + break; + case PARAM_TYPE_i64: + set_param_value_t(param_id, (param_value_t){.i64 = round(param_val)}); + break; + case PARAM_TYPE_f32: + set_param_value_t(param_id, (param_value_t){.f32 = param_val}); + break; + case PARAM_TYPE_f64: + set_param_value_t(param_id, (param_value_t){.f64 = param_val}); + break; + default: + ESP_LOGW(TAG, "Unknown parameter type for ID %d", param_id); + params_failed++; + continue; + } + } else if (cJSON_IsString(item)) { + set_param_string(param_id, item->valuestring); + } else { + ESP_LOGW(TAG, "Parameter bad type: %s", key); + params_failed++; + continue; + } params_updated++; } @@ -334,11 +383,10 @@ static esp_err_t sp_post_handler(httpd_req_t *req) { } - static esp_err_t cmd_post_handler(httpd_req_t *req) { ESP_LOGI(TAG, "cmd_post_handler"); // Send the HTML response - int ret = httpd_req_recv(req, httpBuffer, sizeof(httpBuffer)); + int ret = httpd_req_recv(req, httpBuffer, sizeof(httpBuffer)); if (ret <= 0) { if (ret == HTTPD_SOCK_ERR_TIMEOUT) { httpd_resp_send_408(req); @@ -346,8 +394,8 @@ static esp_err_t cmd_post_handler(httpd_req_t *req) { return ESP_FAIL; } httpBuffer[ret] = '\0'; // Null-terminate the string - - cJSON *root = cJSON_Parse(httpBuffer); + + cJSON *root = cJSON_Parse(httpBuffer); if (root == NULL) { ESP_LOGE(TAG, "Failed to parse JSON: %s", httpBuffer); httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid JSON"); @@ -356,30 +404,98 @@ static esp_err_t cmd_post_handler(httpd_req_t *req) { cJSON *cmd = cJSON_GetObjectItem(root, "cmd"); - if (!cJSON_IsString(cmd) || cmd->valuestring == NULL) - return httpd_resp_send(req, "400 Bad Request", HTTPD_RESP_USE_STRLEN); - - if (strcmp(cmd->valuestring, "stop") == 0) { - fsm_request(FSM_CMD_STOP); - ESP_LOGI(TAG, "FSM_CMD_STOP"); - } else if (strcmp(cmd->valuestring, "undo") == 0) { - fsm_request(FSM_CMD_UNDO); - ESP_LOGI(TAG, "FSM_CMD_UNDO"); - } else if (strcmp(cmd->valuestring, "start") == 0) { - fsm_request(FSM_CMD_START); - ESP_LOGI(TAG, "FSM_CMD_START"); - } else if (strcmp(cmd->valuestring, "rfp") == 0) { - cJSON *i = cJSON_GetObjectItem(root, "channel"); - if (cJSON_IsNumber(i) && i->valueint >= 0 && i->valueint < 8) { - rf_433_learn_keycode(i->valueint); - } else { - rf_433_cancel_learn_keycode(); - } - } else { - ESP_LOGE(TAG, "Command not valid: %s", httpBuffer); - return httpd_resp_send(req, "400 Bad Request", HTTPD_RESP_USE_STRLEN); - } - + if (!cJSON_IsString(cmd) || cmd->valuestring == NULL) + return httpd_resp_send(req, "400 Bad Request", HTTPD_RESP_USE_STRLEN); + + if (strcmp(cmd->valuestring, "stop") == 0) { + fsm_request(FSM_CMD_STOP); + ESP_LOGI(TAG, "FSM_CMD_STOP"); + } else if (strcmp(cmd->valuestring, "undo") == 0) { + fsm_request(FSM_CMD_UNDO); + ESP_LOGI(TAG, "FSM_CMD_UNDO"); + } else if (strcmp(cmd->valuestring, "reboot") == 0) { + // Send response FIRST + httpd_resp_send(req, "Rebooting...", HTTPD_RESP_USE_STRLEN); + + set_param_value_t(PARAM_BOOT_TIME, (param_value_t){.i64 = system_rtc_get_raw_time()}); + + // THEN delay and reboot + vTaskDelay(pdMS_TO_TICKS(2000)); // Give time for TCP to close properly + esp_restart(); + } else if (strcmp(cmd->valuestring, "start") == 0) { + fsm_request(FSM_CMD_START); + ESP_LOGI(TAG, "FSM_CMD_START"); + } else if (strcmp(cmd->valuestring, "cal_jack_start") == 0) { + fsm_request(FSM_CMD_CALIBRATE_JACK_PREP); + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_JACK_PREP"); + } else if (strcmp(cmd->valuestring, "cal_jack_finish") == 0) { + cJSON *i = cJSON_GetObjectItem(root, "amt"); + if (cJSON_IsNumber(i) && i->valuedouble >= 0 && i->valuedouble < 8) { + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_JACK_FINISH"); + fsm_set_cal_val(i->valuedouble); + fsm_request(FSM_CMD_CALIBRATE_JACK_FINISH); + } + } else if (strcmp(cmd->valuestring, "cal_drive_start") == 0) { + fsm_request(FSM_CMD_CALIBRATE_DRIVE_PREP); + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_DRIVE_PREP"); + } else if (strcmp(cmd->valuestring, "cal_drive_finish") == 0) { + cJSON *i = cJSON_GetObjectItem(root, "amt"); + if (cJSON_IsNumber(i) && i->valuedouble >= 0 && i->valuedouble < 8) { + ESP_LOGI(TAG, "FSM_CMD_CALIBRATE_DRIVE_FINISH"); + fsm_set_cal_val(i->valuedouble); + fsm_request(FSM_CMD_CALIBRATE_DRIVE_FINISH); + } + } else if (strcmp(cmd->valuestring, "cal_get") == 0) { + ESP_LOGI(TAG, "CAL_GET"); + sprintf(httpBuffer, "{\"e\":%lld,\"t\":%lld}", fsm_get_cal_e(), fsm_get_cal_t()); + + httpd_resp_set_type(req, "application/json"); + return httpd_resp_send(req, httpBuffer, HTTPD_RESP_USE_STRLEN); + } + + else if (strcmp(cmd->valuestring, "remaining_dist") == 0) { + cJSON *i = cJSON_GetObjectItem(root, "amt"); + if (cJSON_IsNumber(i)) { + ESP_LOGI(TAG, "remaining_dist"); + fsm_set_remaining_distance(i->valuedouble); + } + } + + else if (strcmp(cmd->valuestring, "rfp") == 0) { + cJSON *i = cJSON_GetObjectItem(root, "channel"); + if (cJSON_IsNumber(i) && i->valueint >= 0 && i->valueint < 8) { + rf_433_learn_keycode(i->valueint); + } else { + rf_433_cancel_learn_keycode(); + } + } else if (strcmp(cmd->valuestring, "rf_status") == 0) { + // Return current RF button codes (just the 32-bit values) + int head = 0; + head += sprintf(httpBuffer, "{\"codes\":["); + + for (uint8_t i = 0; i < NUM_RF_BUTTONS; i++) { + if (i > 0) head += sprintf(httpBuffer+head, ","); + + int64_t code = get_param_value_t(PARAM_KEYCODE_0 + i).i64; + // Return just the code as uint32 + head += sprintf(httpBuffer+head, "%lu", (unsigned long)(uint32_t)code); + } + + head += sprintf(httpBuffer+head, "]}"); + + httpd_resp_set_type(req, "application/json"); + return httpd_resp_send(req, httpBuffer, head); + } else if (strcmp(cmd->valuestring, "rf_disable") == 0) { + rf_433_disable_controls(); + ESP_LOGI(TAG, "RF controls disabled"); + } else if (strcmp(cmd->valuestring, "rf_enable") == 0) { + rf_433_enable_controls(); + ESP_LOGI(TAG, "RF controls enabled"); + } else { + ESP_LOGE(TAG, "Command not valid: %s", httpBuffer); + return httpd_resp_send(req, "400 Bad Request", HTTPD_RESP_USE_STRLEN); + } + httpd_resp_set_type(req, "text/html"); return httpd_resp_send(req, "200 OK", HTTPD_RESP_USE_STRLEN); @@ -394,11 +510,50 @@ static esp_err_t status_get_handler(httpd_req_t *req) { httpd_resp_set_type(req, "application/json"); // Start building the JSON string with time - head += sprintf(httpBuffer+head, "{\"time\":%lld,\"battery\":%f,\"rtc_set\":%s,\"values\":[", - system_rtc_get_raw_time(), - get_battery_V(), - rtc_is_set()?"true":"false" - ); + head += sprintf(httpBuffer+head, "{\"time\":%lld,\"rtc_set\":%s,", + system_rtc_get_raw_time(), + rtc_is_set()?"true":"false"); + + float vbat = get_battery_V(); + if (fpclassify(vbat) == FP_NORMAL) { + head += sprintf(httpBuffer+head, "\"battery\":%f,", + vbat); + } else { + head += sprintf(httpBuffer+head, "\"battery\":null,"); + } + + float d = fsm_get_remaining_distance(); + if (fpclassify(d) == FP_NORMAL) { + head += sprintf(httpBuffer+head, "\"remaining_dist\":%f,\"msg\":\"",d); + } else { + head += sprintf(httpBuffer+head, "\"remaining_dist\":null,\"msg\":\""); + } + + + + switch(fsm_get_state()) { + case STATE_IDLE: + head += sprintf(httpBuffer+head, "IDLE"); + break; + case STATE_UNDO_JACK: + case STATE_UNDO_JACK_START: + head += sprintf(httpBuffer+head, "CANCELLING MOVE"); + break; + default: + head += sprintf(httpBuffer+head, "MOVING..."); + break; + } + + if (efuse_is_tripped(BRIDGE_AUX)) head += sprintf(httpBuffer+head, " | AUX EFUSE TRIP"); + if (efuse_is_tripped(BRIDGE_JACK)) head += sprintf(httpBuffer+head, " | JACK EFUSE TRIP"); + if (efuse_is_tripped(BRIDGE_DRIVE)) head += sprintf(httpBuffer+head, " | DRIVE EFUSE TRIP"); + + if (!rtc_is_set()) { + head += sprintf(httpBuffer+head, " | RTC NOT SET"); + } + + + head += sprintf(httpBuffer+head, "\",\"values\":["); for (param_idx_t i = 0; i < NUM_PARAMS; i++) { if (i > 0) { @@ -410,16 +565,27 @@ static esp_err_t status_get_handler(httpd_req_t *req) { // Append the parameter value based on its type switch (get_param_type(i)) { - case PARAM_TYPE_u8: head+=sprintf(httpBuffer+head, "%u", param.u8); break; - case PARAM_TYPE_i8: head+=sprintf(httpBuffer+head, "%d", param.i8); break; case PARAM_TYPE_u16: head+=sprintf(httpBuffer+head, "%u", param.u16); break; case PARAM_TYPE_i16: head+=sprintf(httpBuffer+head, "%d", param.i16); break; case PARAM_TYPE_u32: head+=sprintf(httpBuffer+head, "%lu", (unsigned long)param.u32); break; case PARAM_TYPE_i32: head+=sprintf(httpBuffer+head, "%ld", (long)param.i32); break; case PARAM_TYPE_u64: head+=sprintf(httpBuffer+head, "%llu", param.u64); break; case PARAM_TYPE_i64: head+=sprintf(httpBuffer+head, "%lld", param.i64); break; - case PARAM_TYPE_f32: head+=sprintf(httpBuffer+head, "%.8f", param.f32); break; - case PARAM_TYPE_f64: head+=sprintf(httpBuffer+head, "%.8f", param.f64); break; + case PARAM_TYPE_f32: + if (fpclassify(param.f32) == FP_NORMAL) + head+=sprintf(httpBuffer+head, "%.8f", param.f32); + else + head+=sprintf(httpBuffer+head, "null"); + break; + case PARAM_TYPE_f64: + if (fpclassify(param.f32) == FP_NORMAL) + head+=sprintf(httpBuffer+head, "%.8f", param.f64); + else + head+=sprintf(httpBuffer+head, "null"); + break; + case PARAM_TYPE_str: + head+=sprintf(httpBuffer+head, "\"%s\"", param.str); + break; } } @@ -553,14 +719,11 @@ httpd_uri_t uris[] = {{ static void startHttpServer(void) { httpd_config_t config = HTTPD_DEFAULT_CONFIG(); config.server_port = SERVER_PORT; - - ESP_LOGI(TAG, "Starting server on port: '%d'", config.server_port); + if (httpd_start(&httpServerInstance, &config) == ESP_OK) { - for (uint8_t i=0; i<(sizeof(uris)/sizeof(httpd_uri_t)); i++) { - httpd_register_uri_handler(httpServerInstance, &uris[i]); - - } - } + for (uint8_t i=0; i<(sizeof(uris)/sizeof(httpd_uri_t)); i++) + httpd_register_uri_handler(httpServerInstance, &uris[i]); + } } /* Event handler for WiFi events */ @@ -579,18 +742,15 @@ void launchSoftAp() { ESP_ERROR_CHECK(nvs_flash_init()); ESP_ERROR_CHECK(esp_netif_init()); ESP_ERROR_CHECK(esp_event_loop_create_default()); - - // Create default WiFi AP and get the netif handle - esp_netif_t *ap_netif = esp_netif_create_default_wifi_ap(); - assert(ap_netif); // Optional: check for NULL - // Set your custom hostname here (max 32 chars, no spaces/special chars recommended) + esp_netif_t *ap_netif = esp_netif_create_default_wifi_ap(); + assert(ap_netif); + ESP_ERROR_CHECK(esp_netif_set_hostname(ap_netif, HOSTNAME)); wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); ESP_ERROR_CHECK(esp_wifi_init(&cfg)); - // Register the event handler ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, @@ -599,29 +759,51 @@ void launchSoftAp() { wifi_config_t wifi_config = { .ap = { - .channel = 8, + .channel = 6, .ssid = SOFT_AP_SSID, - .ssid_len = strlen(SOFT_AP_SSID), .password = SOFT_AP_PASSWORD, .max_connection = 4, .authmode = WIFI_AUTH_WPA2_PSK }, }; + + // Get the strings from your parameter system + char* ssid_str = get_param_string(PARAM_WIFI_SSID); + char* password_str = get_param_string(PARAM_WIFI_PASS); + + // Allocate and set the SSID and password + memcpy(wifi_config.ap.ssid, ssid_str, 16); + memcpy(wifi_config.ap.password, password_str, 16); + + // password minimum length of 8 + if (strlen(password_str) < 8) { + wifi_config.ap.password[0] = '\0'; + wifi_config.ap.authmode = WIFI_AUTH_OPEN; + } + + // Set the length of SSID + wifi_config.ap.ssid_len = strlen(ssid_str); + ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP)); ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_config)); ESP_ERROR_CHECK(esp_wifi_start()); - - //dns_server_config_t dns_config = DNS_SERVER_CONFIG_SINGLE(HOSTNAME, "192.168.4.1"); - //ESP_ERROR_CHECK(dns_server_start(&dns_config)); - - //ESP_ERROR_CHECK(mdns_init()); - //ESP_ERROR_CHECK(mdns_hostname_set(HOSTNAME)); // Matches the netif hostname - //ESP_ERROR_CHECK(mdns_instance_name_set("My ESP32 Device")); // Optional friendly name - // After mdns_init() and hostname set - //ESP_ERROR_CHECK(mdns_service_add(NULL, "_http", "_tcp", 80, NULL, 0)); - ESP_LOGI(TAG, "SoftAP set up. SSID:%s password:%s", SOFT_AP_SSID, SOFT_AP_PASSWORD); + // Start DNS server with your specific hostname + // Option 1: Only respond to your hostname + ESP_ERROR_CHECK(simple_dns_server_start("192.168.4.1")); + + // Option 2: Respond to ALL domains (captive portal style) + // ESP_ERROR_CHECK(simple_dns_server_start(HOSTNAME, "192.168.4.1", true)); + + // Start mDNS for .local domain + ESP_ERROR_CHECK(mdns_init()); + ESP_ERROR_CHECK(mdns_hostname_set(HOSTNAME)); + ESP_ERROR_CHECK(mdns_instance_name_set("ClusterCommand")); + ESP_ERROR_CHECK(mdns_service_add(NULL, "_http", "_tcp", 80, NULL, 0)); + + ESP_LOGI(TAG, "SoftAP ready. Access at: http://%s or http://%s.local or http://192.168.4.1", + HOSTNAME, HOSTNAME); } esp_err_t webserver_init(void) { diff --git a/managed_components/esp-idf-lib__esp_idf_lib_helpers/.component_hash b/managed_components/esp-idf-lib__esp_idf_lib_helpers/.component_hash index 762296e..ea9e900 100644 --- a/managed_components/esp-idf-lib__esp_idf_lib_helpers/.component_hash +++ b/managed_components/esp-idf-lib__esp_idf_lib_helpers/.component_hash @@ -1 +1 @@ -a8049b1e609679fb54b2d57b0399dd29c4d1fda09a797edac9926f7810aa5703 \ No newline at end of file +689853bb8993434f9556af0f2816e808bf77b5d22100144b21f3519993daf237 \ No newline at end of file diff --git a/managed_components/esp-idf-lib__esp_idf_lib_helpers/.eil.yml b/managed_components/esp-idf-lib__esp_idf_lib_helpers/.eil.yml index e5b255c..dfa547a 100644 --- a/managed_components/esp-idf-lib__esp_idf_lib_helpers/.eil.yml +++ b/managed_components/esp-idf-lib__esp_idf_lib_helpers/.eil.yml @@ -1,7 +1,7 @@ --- name: esp_idf_lib_helpers description: Common support library for esp-idf-lib -version: 1.3.10 +version: 1.4.0 groups: - common code_owners: diff --git a/managed_components/esp-idf-lib__esp_idf_lib_helpers/.gitignore b/managed_components/esp-idf-lib__esp_idf_lib_helpers/.gitignore index 9cccbfb..b017df1 100644 --- a/managed_components/esp-idf-lib__esp_idf_lib_helpers/.gitignore +++ b/managed_components/esp-idf-lib__esp_idf_lib_helpers/.gitignore @@ -2,6 +2,11 @@ examples/**/sdkconfig examples/**/sdkconfig.old examples/**/build/ examples/**/dependencies.lock +examples/**/managed_components/ docs/_*/ -docs/doxygen.log +docs/**/*.log *.swp +*.bak +*.orig +build/ +.vscode/ diff --git a/managed_components/esp-idf-lib__esp_idf_lib_helpers/esp_idf_lib_helpers.h b/managed_components/esp-idf-lib__esp_idf_lib_helpers/esp_idf_lib_helpers.h index c1c9c4a..232ab22 100644 --- a/managed_components/esp-idf-lib__esp_idf_lib_helpers/esp_idf_lib_helpers.h +++ b/managed_components/esp-idf-lib__esp_idf_lib_helpers/esp_idf_lib_helpers.h @@ -74,7 +74,7 @@ * The default SPI_HOST for spi_host_device_t */ #if CONFIG_IDF_TARGET_ESP32 -#define HELPER_SPI_HOST_DEFAULT HSPI_HOST +#define HELPER_SPI_HOST_DEFAULT SPI1_HOST #elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 #define HELPER_SPI_HOST_DEFAULT SPI2_HOST #elif CONFIG_IDF_TARGET_ESP32C2 || CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C5 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32C61 diff --git a/managed_components/esp-idf-lib__esp_idf_lib_helpers/idf_component.yml b/managed_components/esp-idf-lib__esp_idf_lib_helpers/idf_component.yml index eee3220..1d088f2 100644 --- a/managed_components/esp-idf-lib__esp_idf_lib_helpers/idf_component.yml +++ b/managed_components/esp-idf-lib__esp_idf_lib_helpers/idf_component.yml @@ -12,7 +12,7 @@ maintainers: - Ruslan V. Uss (@UncleRus) repository: git://github.com/esp-idf-lib/esp_idf_lib_helpers.git repository_info: - commit_sha: 57bbd8f3cda9c5ad390fc3ea5585e0ad80672584 + commit_sha: 918d82cafb1f00fd86f1ad8571271cb3e910588b path: . targets: - esp32 @@ -26,4 +26,4 @@ targets: - esp32s2 - esp32s3 url: https://github.com/esp-idf-lib/core -version: 1.3.10 +version: 1.4.0 diff --git a/managed_components/esp-idf-lib__i2cdev/.component_hash b/managed_components/esp-idf-lib__i2cdev/.component_hash index ca7b1a1..d773742 100644 --- a/managed_components/esp-idf-lib__i2cdev/.component_hash +++ b/managed_components/esp-idf-lib__i2cdev/.component_hash @@ -1 +1 @@ -11c08f9e1a7d346b5dd763196dc2567cf2209ae49042402c2c2d296624601c14 \ No newline at end of file +4f3838b2e68ab2b77fd43737139fa97dd0243b46af7b4a04588c67ff6b275ba1 \ No newline at end of file diff --git a/managed_components/esp-idf-lib__i2cdev/.eil.yml b/managed_components/esp-idf-lib__i2cdev/.eil.yml index 7cfd1fb..0046b26 100644 --- a/managed_components/esp-idf-lib__i2cdev/.eil.yml +++ b/managed_components/esp-idf-lib__i2cdev/.eil.yml @@ -1,10 +1,12 @@ name: i2cdev description: ESP-IDF I2C master thread-safe utilities -version: 2.0.8 +version: 2.1.0 groups: - common code_owners: - UncleRus + - quinkq + - trombik depends: - driver - freertos @@ -25,4 +27,6 @@ targets: license: MIT copyrights: - name: UncleRus - year: 2018 \ No newline at end of file + year: 2018 + - name: quinkq + year: 2025 diff --git a/managed_components/esp-idf-lib__i2cdev/.gitignore b/managed_components/esp-idf-lib__i2cdev/.gitignore index 9cccbfb..b017df1 100644 --- a/managed_components/esp-idf-lib__i2cdev/.gitignore +++ b/managed_components/esp-idf-lib__i2cdev/.gitignore @@ -2,6 +2,11 @@ examples/**/sdkconfig examples/**/sdkconfig.old examples/**/build/ examples/**/dependencies.lock +examples/**/managed_components/ docs/_*/ -docs/doxygen.log +docs/**/*.log *.swp +*.bak +*.orig +build/ +.vscode/ diff --git a/managed_components/esp-idf-lib__i2cdev/CMakeLists.txt b/managed_components/esp-idf-lib__i2cdev/CMakeLists.txt index f98fc70..a7ee126 100644 --- a/managed_components/esp-idf-lib__i2cdev/CMakeLists.txt +++ b/managed_components/esp-idf-lib__i2cdev/CMakeLists.txt @@ -1,5 +1,10 @@ # ESP-IDF CMake component for i2cdev library -set(req driver freertos esp_idf_lib_helpers) +if(${IDF_VERSION_MAJOR} STREQUAL 5 AND ${IDF_VERSION_MINOR} LESS 3) + # Use driver component as esp_driver_gpio is not available before 5.3 + set(req driver freertos log esp_timer) +else() + set(req esp_driver_gpio esp_driver_i2c freertos esp_idf_lib_helpers) +endif() # ESP-IDF version detection for automatic driver selection # Check for manual override via Kconfig @@ -14,7 +19,7 @@ elseif(IDF_VERSION_MAJOR LESS 5) set(USE_LEGACY_DRIVER TRUE) message(STATUS "i2cdev: ESP-IDF v${IDF_VERSION_MAJOR}.x detected, using legacy driver") elseif(IDF_VERSION_MAJOR EQUAL 5 AND IDF_VERSION_MINOR LESS 3) - set(USE_LEGACY_DRIVER TRUE) + set(USE_LEGACY_DRIVER TRUE) message(STATUS "i2cdev: ESP-IDF v${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR} detected, using legacy driver") else() set(USE_LEGACY_DRIVER FALSE) diff --git a/managed_components/esp-idf-lib__i2cdev/i2cdev.c b/managed_components/esp-idf-lib__i2cdev/i2cdev.c index 2a72277..b690b17 100644 --- a/managed_components/esp-idf-lib__i2cdev/i2cdev.c +++ b/managed_components/esp-idf-lib__i2cdev/i2cdev.c @@ -107,7 +107,7 @@ static void deregister_device(i2c_dev_t *dev) } } -esp_err_t i2c_init(void) +esp_err_t i2cdev_init(void) { ESP_LOGV(TAG, "Initializing I2C subsystem..."); memset(active_devices, 0, sizeof(active_devices)); diff --git a/managed_components/esp-idf-lib__i2cdev/i2cdev.h b/managed_components/esp-idf-lib__i2cdev/i2cdev.h index 71ebb5e..4dab9ba 100644 --- a/managed_components/esp-idf-lib__i2cdev/i2cdev.h +++ b/managed_components/esp-idf-lib__i2cdev/i2cdev.h @@ -46,12 +46,18 @@ #ifndef __I2CDEV_H__ #define __I2CDEV_H__ -#include -#include #include #include #include #include +#include + +#include +#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0) +#include +#else +#include +#endif // Define missing types for older ESP-IDF versions #if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 2, 0) @@ -193,7 +199,7 @@ typedef struct * * @return ESP_OK on success */ -esp_err_t i2c_init(void); +esp_err_t i2cdev_init(void); /** * @brief Release I2C subsystem (deletes all devices, buses, and mutexes) diff --git a/managed_components/esp-idf-lib__i2cdev/i2cdev_legacy.c b/managed_components/esp-idf-lib__i2cdev/i2cdev_legacy.c index 3a5c679..9cbcb97 100644 --- a/managed_components/esp-idf-lib__i2cdev/i2cdev_legacy.c +++ b/managed_components/esp-idf-lib__i2cdev/i2cdev_legacy.c @@ -499,7 +499,7 @@ static esp_err_t i2c_setup_port(i2c_dev_t *dev) vTaskDelay(1); // Target-specific driver installation/configuration sequence -#if HELPER_TARGET_IS_ESP32 || HELPER_TARGET_IS_ESP32S2 || HELPER_TARGET_IS_ESP32S3 || HELPER_TARGET_IS_ESP32C3 || HELPER_TARGET_IS_ESP32C6 +#if HELPER_TARGET_IS_ESP32 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 1, 0) ESP_LOGD(TAG, "Using IDF >= 5.1.0 driver install order for ESP32 family"); err = i2c_driver_install(dev->port, legacy_cfg.mode, 0, 0, 0); @@ -559,7 +559,7 @@ static esp_err_t i2c_setup_port(i2c_dev_t *dev) } // Part 2: Timeout Configuration (ESP32 family specific hardware timeout) -#if HELPER_TARGET_IS_ESP32 || HELPER_TARGET_IS_ESP32S2 || HELPER_TARGET_IS_ESP32S3 || HELPER_TARGET_IS_ESP32C3 || HELPER_TARGET_IS_ESP32C6 +#if HELPER_TARGET_IS_ESP32 int current_timeout_hw; err = i2c_get_timeout(dev->port, ¤t_timeout_hw); if (err != ESP_OK) diff --git a/managed_components/esp-idf-lib__i2cdev/idf_component.yml b/managed_components/esp-idf-lib__i2cdev/idf_component.yml index 6c7263c..5814cb0 100644 --- a/managed_components/esp-idf-lib__i2cdev/idf_component.yml +++ b/managed_components/esp-idf-lib__i2cdev/idf_component.yml @@ -13,7 +13,7 @@ maintainers: - Ruslan V. Uss (@UncleRus) repository: git://github.com/esp-idf-lib/i2cdev.git repository_info: - commit_sha: abf0ebc8f0f826373e9a9ee07cf96727a49ed87b + commit_sha: b4f09df5a02e576af61846954557bf7a61d35274 path: . targets: - esp32 @@ -27,4 +27,4 @@ targets: - esp32s2 - esp32s3 url: https://github.com/esp-idf-lib/core -version: 2.0.8 +version: 2.1.0 diff --git a/managed_components/espressif__mdns/.component_hash b/managed_components/espressif__mdns/.component_hash new file mode 100644 index 0000000..3bf22d0 --- /dev/null +++ b/managed_components/espressif__mdns/.component_hash @@ -0,0 +1 @@ +29e47564b1a7ee778135e17fbbf2a2773f71c97ebabfe626c8eda7c958a7ad16 \ No newline at end of file diff --git a/managed_components/espressif__mdns/.cz.yaml b/managed_components/espressif__mdns/.cz.yaml new file mode 100644 index 0000000..277c642 --- /dev/null +++ b/managed_components/espressif__mdns/.cz.yaml @@ -0,0 +1,8 @@ +--- +commitizen: + bump_message: 'bump(mdns): $current_version -> $new_version' + pre_bump_hooks: python ../../ci/changelog.py mdns + tag_format: mdns-v$version + version: 1.9.1 + version_files: + - idf_component.yml diff --git a/managed_components/espressif__mdns/CHANGELOG.md b/managed_components/espressif__mdns/CHANGELOG.md new file mode 100644 index 0000000..7387aea --- /dev/null +++ b/managed_components/espressif__mdns/CHANGELOG.md @@ -0,0 +1,607 @@ +# Changelog + +## [1.9.1](https://github.com/espressif/esp-protocols/commits/mdns-v1.9.1) + +### Bug Fixes + +- Fix to use tagged AFL image + minor format fix ([2b2f009a](https://github.com/espressif/esp-protocols/commit/2b2f009a)) +- Fix unused variable `dcst` warning for wifi-remote chips ([081eef88](https://github.com/espressif/esp-protocols/commit/081eef88)) + +## [1.9.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.9.0) + +### Features + +- support null value for boolean txt records ([fa96de3b](https://github.com/espressif/esp-protocols/commit/fa96de3b)) + +### Bug Fixes + +- Add test case for bool/NULL txt handling ([5068f221](https://github.com/espressif/esp-protocols/commit/5068f221)) +- Temporary fix for build issues on IDF master ([0197c994](https://github.com/espressif/esp-protocols/commit/0197c994)) +- Add tests for delegated answers ([487a746d](https://github.com/espressif/esp-protocols/commit/487a746d)) +- Add fuzzing into mdns CI ([af6bb1b5](https://github.com/espressif/esp-protocols/commit/af6bb1b5)) +- Host test to use hw_support include dir ([8bba3a97](https://github.com/espressif/esp-protocols/commit/8bba3a97)) +- Fixes case where we create our own malloc/free allocators, therefore we need to call mdns_mem_free and not free ([63bf7091](https://github.com/espressif/esp-protocols/commit/63bf7091)) +- put srv/txt records in additional section for ptr queries ([b7b8c5db](https://github.com/espressif/esp-protocols/commit/b7b8c5db)) + +### Updated + +- ci(common): Update test component dir for IDFv6.0 ([18418c83](https://github.com/espressif/esp-protocols/commit/18418c83)) + +## [1.8.2](https://github.com/espressif/esp-protocols/commits/mdns-v1.8.2) + +### Bug Fixes + +- Fix parsing incorrect txt records ([8fd2c99f](https://github.com/espressif/esp-protocols/commit/8fd2c99f)) + +## [1.8.1](https://github.com/espressif/esp-protocols/commits/mdns-v1.8.1) + +### Bug Fixes + +- Fix potential task delete race ([8ca45f34](https://github.com/espressif/esp-protocols/commit/8ca45f34)) + +## [1.8.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.8.0) + +### Features + +- Add version keys ([e01e67e7](https://github.com/espressif/esp-protocols/commit/e01e67e7)) + +### Bug Fixes + +- Reformat mdns sources per indent-cont=120 ([c7663cde](https://github.com/espressif/esp-protocols/commit/c7663cde)) + +## [1.7.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.7.0) + +### Features + +- Support user defined allocators ([88162d1f](https://github.com/espressif/esp-protocols/commit/88162d1f)) +- Allow allocate memory with configured caps ([7d29b476](https://github.com/espressif/esp-protocols/commit/7d29b476)) + +### Bug Fixes + +- Adjust some formatting per indent-cont=120 ([5b2077e3](https://github.com/espressif/esp-protocols/commit/5b2077e3)) + +## [1.6.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.6.0) + +### Features + +- support allocating mDNS task from SPIRAM ([8fcad10c](https://github.com/espressif/esp-protocols/commit/8fcad10c)) + +### Bug Fixes + +- Use correct task delete function ([eb4ab524](https://github.com/espressif/esp-protocols/commit/eb4ab524)) + +### Updated + +- ci(mdns): Fix mdns host test layers with static task creation ([0690eba3](https://github.com/espressif/esp-protocols/commit/0690eba3)) + +## [1.5.3](https://github.com/espressif/esp-protocols/commits/mdns-v1.5.3) + +### Bug Fixes + +- Fix responder to ignore only invalid queries ([cd07228f](https://github.com/espressif/esp-protocols/commit/cd07228f), [#754](https://github.com/espressif/esp-protocols/issues/754)) + +## [1.5.2](https://github.com/espressif/esp-protocols/commits/mdns-v1.5.2) + +### Bug Fixes + +- Fix potential NULL deref when sending sub-buy ([e7273c46](https://github.com/espressif/esp-protocols/commit/e7273c46)) +- Fix _mdns_append_fqdn excessive stack usage ([bd23c233](https://github.com/espressif/esp-protocols/commit/bd23c233)) + +## [1.5.1](https://github.com/espressif/esp-protocols/commits/mdns-v1.5.1) + +### Bug Fixes + +- Fix incorrect memory free for mdns browse ([4451a8c5](https://github.com/espressif/esp-protocols/commit/4451a8c5)) + +## [1.5.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.5.0) + +### Features + +- supported removal of subtype when updating service ([4ad88e29](https://github.com/espressif/esp-protocols/commit/4ad88e29)) + +### Bug Fixes + +- Fix zero-sized VLA clang-tidy warnings ([196198ec](https://github.com/espressif/esp-protocols/commit/196198ec)) +- Remove dead store to arg variable shared ([e838bf03](https://github.com/espressif/esp-protocols/commit/e838bf03)) +- Fix name mangling not to use strcpy() ([99b54ac3](https://github.com/espressif/esp-protocols/commit/99b54ac3)) +- Fix potential null derefernce in _mdns_execute_action() ([f5be2f41](https://github.com/espressif/esp-protocols/commit/f5be2f41)) +- Fix AFL test mock per espressif/esp-idf@a5bc08fb55c ([3d8835cf](https://github.com/espressif/esp-protocols/commit/3d8835cf)) +- Fixed potential out-of-bound interface error ([24f55ce9](https://github.com/espressif/esp-protocols/commit/24f55ce9)) +- Fixed incorrect error conversion ([8f8516cc](https://github.com/espressif/esp-protocols/commit/8f8516cc)) +- Fixed potential overflow when allocating txt data ([75a8e864](https://github.com/espressif/esp-protocols/commit/75a8e864)) +- Move MDNS_NAME_BUF_LEN to public headers ([907087c0](https://github.com/espressif/esp-protocols/commit/907087c0), [#724](https://github.com/espressif/esp-protocols/issues/724)) +- Cleanup includes in mdns.c ([68a9e148](https://github.com/espressif/esp-protocols/commit/68a9e148), [#725](https://github.com/espressif/esp-protocols/issues/725)) +- Allow advertizing service with port==0 ([827ea65f](https://github.com/espressif/esp-protocols/commit/827ea65f)) +- Fixed complier warning if MDNS_MAX_SERVICES==0 ([95377216](https://github.com/espressif/esp-protocols/commit/95377216), [#611](https://github.com/espressif/esp-protocols/issues/611)) + +## [1.4.3](https://github.com/espressif/esp-protocols/commits/mdns-v1.4.3) + +### Features + +- support zero item when update subtype ([5bd82c01](https://github.com/espressif/esp-protocols/commit/5bd82c01)) + +## [1.4.2](https://github.com/espressif/esp-protocols/commits/mdns-v1.4.2) + +### Features + +- support update subtype ([062b8dca](https://github.com/espressif/esp-protocols/commit/062b8dca)) + +### Updated + +- chore(mdns): Add more info to idf_component.yml ([4a1cb65c](https://github.com/espressif/esp-protocols/commit/4a1cb65c)) + +## [1.4.1](https://github.com/espressif/esp-protocols/commits/mdns-v1.4.1) + +### Features + +- Send PTR query for mdns browse when interface is ready ([010a404a](https://github.com/espressif/esp-protocols/commit/010a404a)) + +### Bug Fixes + +- Prevent deadlock when deleting a browse request ([3f48f9ea](https://github.com/espressif/esp-protocols/commit/3f48f9ea)) +- Fix use after free reported by coverity ([25b3d5fd](https://github.com/espressif/esp-protocols/commit/25b3d5fd)) +- Fixed dead-code reported by coverity ([11846c7d](https://github.com/espressif/esp-protocols/commit/11846c7d)) + +## [1.4.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.4.0) + +### Major changes + +- Fixed mdns API issues when add/remove/update records from multiple threads ([Fix services API races to directly add/remove services](https://github.com/espressif/esp-protocols/commit/8a690503)) + +### Features + +- Unit tests for add/remove/update deleg/selfhosted services ([0660ece1](https://github.com/espressif/esp-protocols/commit/0660ece1)) +- Add console command for mdns browsing ([1e8ede33](https://github.com/espressif/esp-protocols/commit/1e8ede33)) +- Console test: set instance for service ([f107dcd1](https://github.com/espressif/esp-protocols/commit/f107dcd1)) +- Console test: add subtype for service ([ee00e97b](https://github.com/espressif/esp-protocols/commit/ee00e97b)) +- Console test: set port for (delegated) srvs ([07b79abf](https://github.com/espressif/esp-protocols/commit/07b79abf)) +- Console test: add/remove TXT recs for delegated srvs ([c9a58d73](https://github.com/espressif/esp-protocols/commit/c9a58d73)) +- Console test for changing TXT records ([6b9a6ce6](https://github.com/espressif/esp-protocols/commit/6b9a6ce6)) +- Console test for add/remove delegated service APIs ([43de7e5c](https://github.com/espressif/esp-protocols/commit/43de7e5c)) +- Console test for add/remove delegated host APIs ([ce7f326a](https://github.com/espressif/esp-protocols/commit/ce7f326a)) +- Console test for lookup service APIs ([a91ead8e](https://github.com/espressif/esp-protocols/commit/a91ead8e)) +- Add linux console functional tests ([50d059af](https://github.com/espressif/esp-protocols/commit/50d059af)) +- check if the txt items is changed when browsing ([e2f0477a](https://github.com/espressif/esp-protocols/commit/e2f0477a)) + +### Bug Fixes + +- Fix mdns_delegate_hostname_add() to block until done ([2c1b1661](https://github.com/espressif/esp-protocols/commit/2c1b1661)) +- Fix API races when removing all services ([169405b5](https://github.com/espressif/esp-protocols/commit/169405b5)) +- Fix API races setting instance name for services ([643dc6d4](https://github.com/espressif/esp-protocols/commit/643dc6d4)) +- Fix API races while adding subtypes for services ([f9f234c4](https://github.com/espressif/esp-protocols/commit/f9f234c4)) +- Fix API races removing txt item for services ([3f97a822](https://github.com/espressif/esp-protocols/commit/3f97a822)) +- Fix API races adding txt item for services ([c62b920b](https://github.com/espressif/esp-protocols/commit/c62b920b)) +- Fix API races while setting txt for services ([a927bf3a](https://github.com/espressif/esp-protocols/commit/a927bf3a)) +- Fix API races while setting port for services ([99d5fb27](https://github.com/espressif/esp-protocols/commit/99d5fb27)) +- Fix services API races to directly add/remove services ([8a690503](https://github.com/espressif/esp-protocols/commit/8a690503)) +- Fix mdns mdns_lookup_service() to handle empty TXT ([d4da9cb0](https://github.com/espressif/esp-protocols/commit/d4da9cb0)) + +## [1.3.2](https://github.com/espressif/esp-protocols/commits/mdns-v1.3.2) + +### Features + +- add check of instance when handling PTR query ([6af6ca5](https://github.com/espressif/esp-protocols/commit/6af6ca5)) + +### Bug Fixes + +- Fix of mdns afl tests ([139166c](https://github.com/espressif/esp-protocols/commit/139166c)) +- remove same protocol services with different instances ([042533a](https://github.com/espressif/esp-protocols/commit/042533a)) + +## [1.3.1](https://github.com/espressif/esp-protocols/commits/mdns-v1.3.1) + +### Bug Fixes + +- free txt value len ([afd98bb](https://github.com/espressif/esp-protocols/commit/afd98bb)) + +## [1.3.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.3.0) + +### Features + +- add a new mdns query mode `browse` ([af330b6](https://github.com/espressif/esp-protocols/commit/af330b6)) +- Make including mdns_console KConfigurable ([27adbfe](https://github.com/espressif/esp-protocols/commit/27adbfe)) + +### Bug Fixes + +- Schedule all queued Tx packets from timer task ([d4e693e](https://github.com/espressif/esp-protocols/commit/d4e693e)) +- add lock for some common apis ([21c84bf](https://github.com/espressif/esp-protocols/commit/21c84bf)) +- fix mdns answer append while host is invalid ([7be16bc](https://github.com/espressif/esp-protocols/commit/7be16bc)) + +## [1.2.5](https://github.com/espressif/esp-protocols/commits/mdns-v1.2.5) + +### Bug Fixes + +- Fixed build issues for targets without WiFi caps ([302b46f](https://github.com/espressif/esp-protocols/commit/302b46f)) + +## [1.2.4](https://github.com/espressif/esp-protocols/commits/mdns-v1.2.4) + +### Bug Fixes + +- Correction on 6d2c475 MDNS_PREDEF_NETIF_ETH fix ([fc59f87c4e](https://github.com/espressif/esp-protocols/commit/fc59f87c4e)) +- fix the logic of creating pcb for networking socket ([5000a9a20a](https://github.com/espressif/esp-protocols/commit/5000a9a20a)) +- fix compiling issue when disabling IPv4 ([2646dcd23a](https://github.com/espressif/esp-protocols/commit/2646dcd23a)) +- Fix compile error when MDNS_PREDEF_NETIF_ETH is defined, but ETH_ENABLED is not (#459) ([6d2c475c20](https://github.com/espressif/esp-protocols/commit/6d2c475c20)) + +## [1.2.3](https://github.com/espressif/esp-protocols/commits/mdns-v1.2.3) + +### Bug Fixes + +- fixed CI issues for host and afl tests ([4be5efc84e](https://github.com/espressif/esp-protocols/commit/4be5efc84e)) +- fix copy delegated host addr ([19fb36000c](https://github.com/espressif/esp-protocols/commit/19fb36000c)) +- enable CONFIG_ESP_WIFI_ENABLED if CONFIG_SOC_WIFI_SUPPORTED is also enabled (for ESP-IDF <= 5.1) ([d20a718320](https://github.com/espressif/esp-protocols/commit/d20a718320)) +- remove protocol_examples_common ([1ee9dae6bf](https://github.com/espressif/esp-protocols/commit/1ee9dae6bf)) +- move the example into a subdirectory ([d28232b9f8](https://github.com/espressif/esp-protocols/commit/d28232b9f8)) +- reference protocol_examples_common from IDF ([c83b76ea8f](https://github.com/espressif/esp-protocols/commit/c83b76ea8f)) + +## [1.2.2](https://github.com/espressif/esp-protocols/commits/mdns-v1.2.2) + +### Bug Fixes + +- add terminator for the getting host name ([b6a4d94](https://github.com/espressif/esp-protocols/commit/b6a4d94)) +- Enable ESP_WIFI_CONFIG when ESP-IDF <= 5.1 ([0b783c0](https://github.com/espressif/esp-protocols/commit/0b783c0)) +- set host list NULL on destroy ([ea54eef](https://github.com/espressif/esp-protocols/commit/ea54eef)) +- removed Wno-format flag and fixed formatting warnings ([c48e442](https://github.com/espressif/esp-protocols/commit/c48e442)) +- remove the the range of MDNS_MAX_SERVICES and fix issues of string functions ([3dadce2](https://github.com/espressif/esp-protocols/commit/3dadce2)) + +## [1.2.1](https://github.com/espressif/esp-protocols/commits/mdns-v1.2.1) + +### Features + +- Allow setting length of mDNS action queue in menuconfig ([28cd898](https://github.com/espressif/esp-protocols/commit/28cd898)) + +### Bug Fixes + +- fix build issue if CONFIG_ESP_WIFI_ENABLED disabled ([24f7031](https://github.com/espressif/esp-protocols/commit/24f7031)) +- added idf_component.yml for examples ([d273e10](https://github.com/espressif/esp-protocols/commit/d273e10)) +- added guard check for null pointer ([71bb461](https://github.com/espressif/esp-protocols/commit/71bb461)) + +## [1.2.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.2.0) + +### Features + +- add an API for setting address to a delegated host ([ddc3eb6](https://github.com/espressif/esp-protocols/commit/ddc3eb6)) +- Add support for lwip build under linux ([588465d](https://github.com/espressif/esp-protocols/commit/588465d)) +- Allow for adding a delegated host with no address ([c562461](https://github.com/espressif/esp-protocols/commit/c562461)) +- Add APIs for looking up self hosted services and getting the self hostname ([f0df12d](https://github.com/espressif/esp-protocols/commit/f0df12d)) + +### Bug Fixes + +- Refactor freertos linux compat layers ([79a0e57](https://github.com/espressif/esp-protocols/commit/79a0e57)) +- Fix delegated service PTR response ([cab0e1d](https://github.com/espressif/esp-protocols/commit/cab0e1d)) +- Added unit tests to CI + minor fix to pass it ([c974c14](https://github.com/espressif/esp-protocols/commit/c974c14)) + +### Updated + +- docs: update documentation links ([4de5298](https://github.com/espressif/esp-protocols/commit/4de5298)) + +## [1.1.0](https://github.com/espressif/esp-protocols/commits/mdns-v1.1.0) + +### Features + +- Decouple main module from mdns-networking ([d238e93](https://github.com/espressif/esp-protocols/commit/d238e93)) + +### Bug Fixes + +- Use idf-build-apps package for building mdns ([1a0a41f](https://github.com/espressif/esp-protocols/commit/1a0a41f)) +- socket networking to init interfaces properly ([ee9b04f](https://github.com/espressif/esp-protocols/commit/ee9b04f)) +- Removed unused internal lock from mdns_server struct ([a06fb77](https://github.com/espressif/esp-protocols/commit/a06fb77)) +- Resolve conflicts only on self hosted items ([e69a9eb](https://github.com/espressif/esp-protocols/commit/e69a9eb), [#185](https://github.com/espressif/esp-protocols/issues/185)) +- Fix memory issues reported by valgrind ([0a682e7](https://github.com/espressif/esp-protocols/commit/0a682e7)) + +### Updated + +- docs(common): updated component and example links ([f48d9b2](https://github.com/espressif/esp-protocols/commit/f48d9b2)) +- Add APIs to look up delegated services ([87dcd7d](https://github.com/espressif/esp-protocols/commit/87dcd7d)) +- Fix deadly mdns crash ([4fa3023](https://github.com/espressif/esp-protocols/commit/4fa3023)) +- docs(common): improving documentation ([ca3fce0](https://github.com/espressif/esp-protocols/commit/ca3fce0)) +- append all ipv6 address in mdns answer ([5ed3e9a](https://github.com/espressif/esp-protocols/commit/5ed3e9a)) +- test(mdns): Host tests to use IDF's esp_event_stub ([537d170](https://github.com/espressif/esp-protocols/commit/537d170)) + +## [1.0.9](https://github.com/espressif/esp-protocols/commits/mdns-v1.0.9) + +### Features + +- Add reverse lookup to the example and test ([d464ed7](https://github.com/espressif/esp-protocols/commit/d464ed7)) +- Add support for IPv6 reverse query ([d4825f5](https://github.com/espressif/esp-protocols/commit/d4825f5)) + +### Bug Fixes + +- Reintroduce missing CHANGELOGs ([200cbb3](https://github.com/espressif/esp-protocols/commit/200cbb3)) +- use semaphore instead of task notification bits (IDFGH-9380) ([73f2800](https://github.com/espressif/esp-protocols/commit/73f2800), [IDF#10754](https://github.com/espressif/esp-idf/issues/10754)) + +### Updated + +- ci(common): force scoping commit messages with components ([c55fcc0](https://github.com/espressif/esp-protocols/commit/c55fcc0)) +- Add homepage URL and License to all components ([ef3f0ee](https://github.com/espressif/esp-protocols/commit/ef3f0ee)) +- docs: fix of mdns link translation ([1c850dd](https://github.com/espressif/esp-protocols/commit/1c850dd)) +- unite all tags under common structure py test: update tags under common structure ([c6db3ea](https://github.com/espressif/esp-protocols/commit/c6db3ea)) + +## [1.0.8](https://github.com/espressif/esp-protocols/commits/b9b4a75) + +### Features + +- Add support for IPv4 reverse query ([b87bef5](https://github.com/espressif/esp-protocols/commit/b87bef5)) + +### Bug Fixes + +- Host test with IDFv5.1 ([fb8a2f0](https://github.com/espressif/esp-protocols/commit/fb8a2f0)) +- Remove strict mode as it's invalid ([d0c9070](https://github.com/espressif/esp-protocols/commit/d0c9070)) +- Allow setting instance name only after hostname set ([a8339e4](https://github.com/espressif/esp-protocols/commit/a8339e4), [#190](https://github.com/espressif/esp-protocols/issues/190)) +- Make unit test executable with pytest ([12cfcb5](https://github.com/espressif/esp-protocols/commit/12cfcb5)) +- AFL port layer per IDF-latest changes ([0247926](https://github.com/espressif/esp-protocols/commit/0247926)) + +### Updated + +- bump the component version to 1.0.8 ([b9b4a75](https://github.com/espressif/esp-protocols/commit/b9b4a75)) +- Make reverse query conditional per Kconfig ([91134f1](https://github.com/espressif/esp-protocols/commit/91134f1)) +- Added badges with version of components to the respective README files ([e4c8a59](https://github.com/espressif/esp-protocols/commit/e4c8a59)) +- fix some coverity reported issues ([c73c797](https://github.com/espressif/esp-protocols/commit/c73c797)) +- Examples: using pytest.ini from top level directory ([aee016d](https://github.com/espressif/esp-protocols/commit/aee016d)) +- mDNS: test_app pytest migration ([f71f61f](https://github.com/espressif/esp-protocols/commit/f71f61f)) +- CI: fixing the files to be complient with pre-commit hooks ([945bd17](https://github.com/espressif/esp-protocols/commit/945bd17)) +- prevent crash when hostname is null ([3498e86](https://github.com/espressif/esp-protocols/commit/3498e86)) +- Example tests integration ([a045c1c](https://github.com/espressif/esp-protocols/commit/a045c1c)) +- Replace hardcoded TTL values with named defines ([bb4c002](https://github.com/espressif/esp-protocols/commit/bb4c002)) +- Fix add_service() to report error if no-hostname ([656ab21](https://github.com/espressif/esp-protocols/commit/656ab21)) + + +## [1.0.7](https://github.com/espressif/esp-protocols/commits/088f7ac) + +### Updated + +- bump up the component version ([088f7ac](https://github.com/espressif/esp-protocols/commit/088f7ac)) +- fix IPV4 only build and also update CI configuration ([e079f8b](https://github.com/espressif/esp-protocols/commit/e079f8b)) +- add test configuration for IPV6 disabled build ([330332a](https://github.com/espressif/esp-protocols/commit/330332a)) + + +## [1.0.6](https://github.com/espressif/esp-protocols/commits/48c157b) + +### Bug Fixes + +- Example makefile to add only mdns as extra comps ([d74c296](https://github.com/espressif/esp-protocols/commit/d74c296)) +- ignore authoritative flag on reception ([415e04a](https://github.com/espressif/esp-protocols/commit/415e04a)) + +### Updated + +- fix build issue with CONFIG_LWIP_IPV6 disabled ([48c157b](https://github.com/espressif/esp-protocols/commit/48c157b)) +- fix bit order issue in DNS header flags ([c4e85bd](https://github.com/espressif/esp-protocols/commit/c4e85bd)) +- updated package version to 0.1.19 ([469f953](https://github.com/espressif/esp-protocols/commit/469f953)) + + +## [1.0.5](https://github.com/espressif/esp-protocols/commits/36de9af) + +### Features + +- Define explicit dependencies on esp-wifi ([36de9af](https://github.com/espressif/esp-protocols/commit/36de9af)) + +### Updated + +- bugfix: mdns IPv6 address convert error ([238ee96](https://github.com/espressif/esp-protocols/commit/238ee96)) + + +## [1.0.4](https://github.com/espressif/esp-protocols/commits/57afa38) + +### Updated + +- Bump asio/mdns/esp_websocket_client versions ([57afa38](https://github.com/espressif/esp-protocols/commit/57afa38)) +- ignore format warnings ([d66f9dc](https://github.com/espressif/esp-protocols/commit/d66f9dc)) +- Fix test_app build ([0b102f6](https://github.com/espressif/esp-protocols/commit/0b102f6)) + + +## [1.0.3](https://github.com/espressif/esp-protocols/commits/4868689) + +### Updated + +- Updated mDNS to explicitely use esp-eth dependency if needed ([4868689](https://github.com/espressif/esp-protocols/commit/4868689), [IDF@5e19b9c](https://github.com/espressif/esp-idf/commit/5e19b9c9518ae253d82400ab24b86af8af832425)) + + +## [1.0.2](https://github.com/espressif/esp-protocols/commits/8fe2a3a) + +### Features + +- fix bug when clean action memory ([81c219d](https://github.com/espressif/esp-protocols/commit/81c219d), [IDF@3d4deb9](https://github.com/espressif/esp-idf/commit/3d4deb972620cae8e8ce4d0050153cc6f39db372)) + +### Bug Fixes + +- add the maximum number of services ([0191d6f](https://github.com/espressif/esp-protocols/commit/0191d6f), [IDF@ba458c6](https://github.com/espressif/esp-idf/commit/ba458c69cfb2f18478d73690c289b09641c62004)) +- fix the exception when remove one of multiple service ([b26c866](https://github.com/espressif/esp-protocols/commit/b26c866), [IDF@696d733](https://github.com/espressif/esp-idf/commit/696d733eb04ee98f764dffdc82bcef51a724c9c6)) + +### Updated + +- Minor fixes here and there ([8fe2a3a](https://github.com/espressif/esp-protocols/commit/8fe2a3a)) +- mDNS: Initial version based on IDF 5.0 ([b6b20ad](https://github.com/espressif/esp-protocols/commit/b6b20ad)) +- soc: moved kconfig options out of the target component. ([4a52cf2](https://github.com/espressif/esp-protocols/commit/4a52cf2), [IDF@d287209](https://github.com/espressif/esp-idf/commit/d2872095f93ed82fb91c776081bc1d032493d93e)) +- cmake: fix issue with passing cxx_std option for GCC 11, a common workaround ([87c2699](https://github.com/espressif/esp-protocols/commit/87c2699), [IDF@ea0d212](https://github.com/espressif/esp-idf/commit/ea0d2123c806bd0ad77bc49843ee905cf9be65ff)) +- kconfig: Changed default values of bool configs - Some bool configs were using default values true and false, instead of y and n. ([eb536a7](https://github.com/espressif/esp-protocols/commit/eb536a7), [IDF@25c5c21](https://github.com/espressif/esp-idf/commit/25c5c214f38ca690b03533e12fb5a4d774c7eae0)) +- esp_netif: Remove tcpip_adapter compatibility layer ([3e93ea9](https://github.com/espressif/esp-protocols/commit/3e93ea9), [IDF@795b7ed](https://github.com/espressif/esp-idf/commit/795b7ed993784e3134195e12b0978504d83dfd56)) +- Fix copyright messages, update API descrition ([2c764b1](https://github.com/espressif/esp-protocols/commit/2c764b1), [IDF@42ba8a8](https://github.com/espressif/esp-idf/commit/42ba8a8338fd5efd82498a5989fc5c105938d447)) +- Add API to control custom network interfaces ([f836ae7](https://github.com/espressif/esp-protocols/commit/f836ae7), [IDF@b02468d](https://github.com/espressif/esp-idf/commit/b02468dc98d614f931d14cd8b5e2373ca51fb18d)) +- CI/mdns: Fix fuzzer build ([4b5f24f](https://github.com/espressif/esp-protocols/commit/4b5f24f), [IDF@98e9426](https://github.com/espressif/esp-idf/commit/98e9426b660a6e825f811cccd45a0722cc801ccd)) +- Add support for registering custom netif ([30f37c0](https://github.com/espressif/esp-protocols/commit/30f37c0), [IDF@bec42ff](https://github.com/espressif/esp-idf/commit/bec42ff85d5091d71e1cb1063bea20d7c6ac8c76)) +- Indicate interface using esp_netif in search results ([ddc58e8](https://github.com/espressif/esp-protocols/commit/ddc58e8), [IDF@f8495f1](https://github.com/espressif/esp-idf/commit/f8495f1e86de9a8e7d046bf13d0ca04775041b4c)) +- Use predefined interfaces to prepare for custom netifs ([fa951bf](https://github.com/espressif/esp-protocols/commit/fa951bf), [IDF@f90b3b7](https://github.com/espressif/esp-idf/commit/f90b3b798b446382d848f8c55c5e1653c81871cd)) +- Prepare for dynamic esp-netif support ([605d1fa](https://github.com/espressif/esp-protocols/commit/605d1fa), [IDF@f9892f7](https://github.com/espressif/esp-idf/commit/f9892f77b88ba77dc6608ba746175f6dc64a7607)) +- esp_hw_support/esp_system: Re-evaluate header inclusions and include directories ([58bf218](https://github.com/espressif/esp-protocols/commit/58bf218), [IDF@a9fda54](https://github.com/espressif/esp-idf/commit/a9fda54d39d1321005c3bc9b3cc268d0b7e9f052)) +- system: move kconfig options out of target component ([ec491ec](https://github.com/espressif/esp-protocols/commit/ec491ec), [IDF@bb88338](https://github.com/espressif/esp-idf/commit/bb88338118957c2214a4c0a33cd4a152e2e1f8ba)) +- Update to drop our own packet if bounced back ([94ae672](https://github.com/espressif/esp-protocols/commit/94ae672), [IDF@b5149e3](https://github.com/espressif/esp-idf/commit/b5149e3ee73728f790798e6757d732fe426e21c7)) +- Fix potential read behind parsed packet ([e5a3a3d](https://github.com/espressif/esp-protocols/commit/e5a3a3d), [IDF@51a5de2](https://github.com/espressif/esp-idf/commit/51a5de2525d0e82adea2e298a0edcc9b2dee5edd)) +- Fix memleak when adding delegated host ([7710ea9](https://github.com/espressif/esp-protocols/commit/7710ea9), [IDF@9cbdb87](https://github.com/espressif/esp-idf/commit/9cbdb8767bdf6e9745e895b2c5af74d0376965e7)) +- Fix null-service issue when parsing packets ([034c55e](https://github.com/espressif/esp-protocols/commit/034c55e), [IDF#8307](https://github.com/espressif/esp-idf/issues/8307), [IDF@a57be7b](https://github.com/espressif/esp-idf/commit/a57be7b7d1135ddb29f9da636e9ad315f7fa1fa7)) +- Update fuzzer test (add delegation, check memory) ([ec03fec](https://github.com/espressif/esp-protocols/commit/ec03fec), [IDF@2c10071](https://github.com/espressif/esp-idf/commit/2c1007156e01b4707b5c89d73cad05c0eef0264f)) +- Remove legacy esp_event API ([5909e9e](https://github.com/espressif/esp-protocols/commit/5909e9e), [IDF@e46aa51](https://github.com/espressif/esp-idf/commit/e46aa515bdf5606a3d868f1034774d5fc96904b8)) +- added missing includes ([82e2a5d](https://github.com/espressif/esp-protocols/commit/82e2a5d), [IDF@28d09c7](https://github.com/espressif/esp-idf/commit/28d09c7dbe145ffa6a7dd90531062d4f7669a9c8)) +- Clear notification value in mdns_hostname_set ([48e4d40](https://github.com/espressif/esp-protocols/commit/48e4d40), [IDF@83a4ddb](https://github.com/espressif/esp-idf/commit/83a4ddbd250e2b386bccabb4705d4c58c1a22bcb)) +- esp_timer: remove legacy ESP32 FRC timer implementation. ([ac6dcb6](https://github.com/espressif/esp-protocols/commit/ac6dcb6), [IDF@edb76f1](https://github.com/espressif/esp-idf/commit/edb76f14d6b3e925568ff04a87befe733ecc4517)) +- freertos: Remove legacy data types ([085dbd8](https://github.com/espressif/esp-protocols/commit/085dbd8), [IDF@57fd78f](https://github.com/espressif/esp-idf/commit/57fd78f5baf93a368a82cf4b2e00ca17ffc09115)) +- Tools: Custom baud-rate setup is not possible for IDF Monitor from menuconfig anymore ([f78e8cf](https://github.com/espressif/esp-protocols/commit/f78e8cf), [IDF@36a4011](https://github.com/espressif/esp-idf/commit/36a4011ff8985bfbae08ba0272194e6c3ef93bbf)) +- Use memcpy() for copy to support non-text TXTs ([6cdf5ee](https://github.com/espressif/esp-protocols/commit/6cdf5ee), [IDF@6aefe9c](https://github.com/espressif/esp-idf/commit/6aefe9c18563ed567d384a956cf02b6f57d6894c)) +- Support for null-value TXT records ([fcb5515](https://github.com/espressif/esp-protocols/commit/fcb5515), [IDF#8267](https://github.com/espressif/esp-idf/issues/8267), [IDF@23c2db4](https://github.com/espressif/esp-idf/commit/23c2db406dee8df09dbdba21cb7eef9fbca8bf27)) +- Fix alloc issue if TXT has empty value ([9fdbe5f](https://github.com/espressif/esp-protocols/commit/9fdbe5f), [IDF@205f6ba](https://github.com/espressif/esp-idf/commit/205f6ba8541e12d958c7c56af5a7136090f12a0e)) +- Fix random crash when defalt service instance queried ([20e6e9e](https://github.com/espressif/esp-protocols/commit/20e6e9e), [IDF@f46dffc](https://github.com/espressif/esp-idf/commit/f46dffca627e9578e49a510580f9754ec1e27e2e)) +- Fix minor memory leaks when creating services ([c588263](https://github.com/espressif/esp-protocols/commit/c588263), [IDF@fad62cc](https://github.com/espressif/esp-idf/commit/fad62cc1ed3dce63b58297172a72a489d7af2d9d)) +- Fix mDNS memory leak ([6258edf](https://github.com/espressif/esp-protocols/commit/6258edf), [IDF@119b4a9](https://github.com/espressif/esp-idf/commit/119b4a9dd12cf89cc5eaf63f8aa19730607ef30b)) +- Fix mDNS memory leak ([c8b0d5e](https://github.com/espressif/esp-protocols/commit/c8b0d5e), [IDF@f5ffd53](https://github.com/espressif/esp-idf/commit/f5ffd53aeb402afc1333a98168bb2fa35d7cdc77)) +- Use multi/uni-cast types in API ([5252b1d](https://github.com/espressif/esp-protocols/commit/5252b1d), [IDF@125c312](https://github.com/espressif/esp-idf/commit/125c3125524c71f4f48f635eda12e22fa3bca500)) +- Allow for unicast PTR queries ([4e11cc8](https://github.com/espressif/esp-protocols/commit/4e11cc8), [IDF@7eeeb01](https://github.com/espressif/esp-idf/commit/7eeeb01ea705745b027bd8bc11d2b142418e9927)) +- Fix potential null deref for ANY query type ([7af91ec](https://github.com/espressif/esp-protocols/commit/7af91ec), [IDF@99dd8ee](https://github.com/espressif/esp-idf/commit/99dd8eedb1a0e957f5f74344e3e4172e61c29ef8)) +- Make fuzzer layers compatible with llvm>=6 ([01256d3](https://github.com/espressif/esp-protocols/commit/01256d3), [IDF@1882cbe](https://github.com/espressif/esp-idf/commit/1882cbe44e6140bebb2d27dc18af06dfcb0157f5)) +- Fix copyright ([5a2d4ea](https://github.com/espressif/esp-protocols/commit/5a2d4ea), [IDF@c83678f](https://github.com/espressif/esp-idf/commit/c83678f64fe27844fc28050bde6433ccb04a0704)) +- Add mDNS miss comment ([9de3f53](https://github.com/espressif/esp-protocols/commit/9de3f53), [IDF@08e0813](https://github.com/espressif/esp-idf/commit/08e081340d9d76d1244e9f2dc527e5ae370b1fbe)) +- freertos: remove FREERTOS_ASSERT option ([bcabc8e](https://github.com/espressif/esp-protocols/commit/bcabc8e), [IDF@7255497](https://github.com/espressif/esp-idf/commit/72554971467a5edc9bd6e390cf8fe7b05e6ade81)) +- Minor err print fix in socket-networking layer ([dfb27b3](https://github.com/espressif/esp-protocols/commit/dfb27b3), [IDF@f1b8f5c](https://github.com/espressif/esp-idf/commit/f1b8f5c1023df7d649161bc76f2bcc9a8f8f4d8b)) +- unified errno format ([076c095](https://github.com/espressif/esp-protocols/commit/076c095), [IDF@87506f4](https://github.com/espressif/esp-idf/commit/87506f46e2922710f48a6b96ca75e53543ff45c4)) +- always send A/AAAA records in announcements ([7dd0bc1](https://github.com/espressif/esp-protocols/commit/7dd0bc1), [IDF@456f80b](https://github.com/espressif/esp-idf/commit/456f80b754ebd0bd74e02c7febdf461c6b573b7a)) +- filter instance name for ANY queries ([7e82a7c](https://github.com/espressif/esp-protocols/commit/7e82a7c), [IDF@5d0c473](https://github.com/espressif/esp-idf/commit/5d0c47303dd9ead0f2ad291dca1d4b7ce4e23b2b)) +- Fix potential null deref reported by fuzzer test ([ae381b7](https://github.com/espressif/esp-protocols/commit/ae381b7), [IDF@cb5653f](https://github.com/espressif/esp-idf/commit/cb5653fd940a9cd41e8554a6d753fab46e0459d7)) +- Minor fix of API description and API usage ([941dc5c](https://github.com/espressif/esp-protocols/commit/941dc5c), [IDF@c297301](https://github.com/espressif/esp-idf/commit/c297301ecc350f8315d7eaf78c72b4aba68d422a)) +- Added results count to MDNS ([525c649](https://github.com/espressif/esp-protocols/commit/525c649), [IDF@f391d61](https://github.com/espressif/esp-idf/commit/f391d610e8185631b5361dc6c844c4c04aac30b1)) +- fix mdns server instance mismatch ([f0839d9](https://github.com/espressif/esp-protocols/commit/f0839d9), [IDF@6173dd7](https://github.com/espressif/esp-idf/commit/6173dd78097216261277c20ebd92a53c68c47f89)) +- support multiple instance for mdns service txt set ([69902ea](https://github.com/espressif/esp-protocols/commit/69902ea), [IDF@50f6302](https://github.com/espressif/esp-idf/commit/50f6302c5d7c0498fa1baa6fd6129d8233971a81)) +- fix wrong PTR record count ([d0bbe88](https://github.com/espressif/esp-protocols/commit/d0bbe88), [IDF@5d3f815](https://github.com/espressif/esp-idf/commit/5d3f8157e0e481363ef93d54a29d957fc91cca86)) +- Build & config: Remove leftover files from the unsupported "make" build system ([4a9d55e](https://github.com/espressif/esp-protocols/commit/4a9d55e), [IDF@766aa57](https://github.com/espressif/esp-idf/commit/766aa5708443099f3f033b739cda0e1de101cca6)) +- Build & config: Remove the "make" build system ([be2a924](https://github.com/espressif/esp-protocols/commit/be2a924), [IDF@9c1d4f5](https://github.com/espressif/esp-idf/commit/9c1d4f5b549d6a7125e5c7c323c80d37361991cb)) +- freertos: update freertos folder structure to match upstream ([76fcd41](https://github.com/espressif/esp-protocols/commit/76fcd41), [IDF@4846222](https://github.com/espressif/esp-idf/commit/48462221029c7da4b1ea233e9e781cd57ff91c7e)) +- support service subtype ([fd8499c](https://github.com/espressif/esp-protocols/commit/fd8499c), [IDF#5508](https://github.com/espressif/esp-idf/issues/5508), [IDF@e7e8610](https://github.com/espressif/esp-idf/commit/e7e8610f563e0b8532a093ea8b803f0eb132fd0e)) +- Fix parsing non-standard queries ([38b4fe2](https://github.com/espressif/esp-protocols/commit/38b4fe2), [IDF#7694](https://github.com/espressif/esp-idf/issues/7694), [IDF@d16f9ba](https://github.com/espressif/esp-idf/commit/d16f9bade5beab3785677dd5b39ebc4e9c895008)) +- allow mutiple instances with same service type ([b266062](https://github.com/espressif/esp-protocols/commit/b266062), [IDF@b7a99f4](https://github.com/espressif/esp-idf/commit/b7a99f46587a69a2cd07e7616c3bb30b7b1a6edf)) +- Update copyright header ([5e087d8](https://github.com/espressif/esp-protocols/commit/5e087d8), [IDF@2a2b95b](https://github.com/espressif/esp-idf/commit/2a2b95b9c22bc5090d87a4f4317288b64b14fcd9)) +- Fix potential null dereference identified by fuzzer tests ([91a3d95](https://github.com/espressif/esp-protocols/commit/91a3d95), [IDF@e7dabb1](https://github.com/espressif/esp-idf/commit/e7dabb14f7c8fd9bd2bea55d8f1accc65323a1c0)) +- components/bt: move config BT_RESERVE_DRAM from bluedroid to ESP32 controller ([6d6dd2b](https://github.com/espressif/esp-protocols/commit/6d6dd2b), [IDF@b310c06](https://github.com/espressif/esp-idf/commit/b310c062cd25f249e00dd03dd27baed783921630)) +- add notification callback for async APIs ([52306e9](https://github.com/espressif/esp-protocols/commit/52306e9), [IDF@986603c](https://github.com/espressif/esp-idf/commit/986603cf07413b46c88c76c324bf500edcfb6171)) +- add more mdns result attributes ([d37ab6d](https://github.com/espressif/esp-protocols/commit/d37ab6d), [IDF@76ec76c](https://github.com/espressif/esp-idf/commit/76ec76c12c871554147343bb7141da1e5de58011)) +- Add host test using linux target ([5c55ea6](https://github.com/espressif/esp-protocols/commit/5c55ea6), [IDF@fc7e2d9](https://github.com/espressif/esp-idf/commit/fc7e2d9e908f61fb4b852cfae72aa5ff7c662ebc)) +- Implement mdns_networking using BSD sockets ([0c71c7b](https://github.com/espressif/esp-protocols/commit/0c71c7b), [IDF@73dfe84](https://github.com/espressif/esp-idf/commit/73dfe84bf295a850edfad39b6b097a71f15964dc)) +- fix crash when adding services without hostname set ([4c368c0](https://github.com/espressif/esp-protocols/commit/4c368c0), [IDF@5e98772](https://github.com/espressif/esp-idf/commit/5e98772eaf7e50d96cf2e6ecdfedcd928b61c864)) +- Fix fuzzer IDF-mock layer ([af22753](https://github.com/espressif/esp-protocols/commit/af22753), [IDF@619235c](https://github.com/espressif/esp-idf/commit/619235c2ee5a1fe8411bd2be2de8798209f95902)) +- Clean the main mdns module from lwip dependencies ([b0957e7](https://github.com/espressif/esp-protocols/commit/b0957e7), [IDF@54e3294](https://github.com/espressif/esp-idf/commit/54e329444a5dd19c51e84b5f1e16455a0f1c6225)) +- Add asynchronous query API ([47c7266](https://github.com/espressif/esp-protocols/commit/47c7266), [IDF#7090](https://github.com/espressif/esp-idf/issues/7090), [IDF@d81482d](https://github.com/espressif/esp-idf/commit/d81482d699232b22f4a5cbee2a76199a5285dadb)) +- Fix crashes reported by the fuzzer tests ([40da0d2](https://github.com/espressif/esp-protocols/commit/40da0d2), [IDF@4a2e726](https://github.com/espressif/esp-idf/commit/4a2e72677c6fb7681a7e2acd1a878d3deb114079)) +- mdns/fuzzer: Fix non-instrumentation test to reproduce fuzzer issues ([5f6b6f9](https://github.com/espressif/esp-protocols/commit/5f6b6f9), [IDF@dae8033](https://github.com/espressif/esp-idf/commit/dae803335e6bc6d9751a360cd3f675ce4027853b)) +- return ESP_OK rather than ERR_OK in API functions ([8a12082](https://github.com/espressif/esp-protocols/commit/8a12082), [IDF@2386113](https://github.com/espressif/esp-idf/commit/2386113972ee51ea93e9740d8c34bfe9289ce909)) +- fix memory leak in mdns_free when adding delegated hostnames ([46f28a8](https://github.com/espressif/esp-protocols/commit/46f28a8), [IDF@0baee93](https://github.com/espressif/esp-idf/commit/0baee932111268c4a2103e1c1adeb7d99914a937)) +- Support for One-Shot mDNS queries ([5a81eae](https://github.com/espressif/esp-protocols/commit/5a81eae), [IDF@f167238](https://github.com/espressif/esp-idf/commit/f167238fac37818aed75dc689eed54ad47528ab9)) +- allow explicit txt value length ([2ddaee2](https://github.com/espressif/esp-protocols/commit/2ddaee2), [IDF@b4e0088](https://github.com/espressif/esp-idf/commit/b4e0088b68321acc4698b01faec7e2ffbe1e37c1)) +- Fix crashes reported by the fuzzer ([27fc285](https://github.com/espressif/esp-protocols/commit/27fc285), [IDF@79ba738](https://github.com/espressif/esp-idf/commit/79ba738626d643d8c6f32bdcd455e0d2476f94c7)) +- Minor correction of the test code ([93e6efe](https://github.com/espressif/esp-protocols/commit/93e6efe), [IDF@7d76245](https://github.com/espressif/esp-idf/commit/7d762451731cb305c3b090509827740f0195a496)) +- Fix fuzzer from miss-interpreting adding services as timeouts ([bc4cda8](https://github.com/espressif/esp-protocols/commit/bc4cda8), [IDF@14099fe](https://github.com/espressif/esp-idf/commit/14099fe15efb1b0cde0a8370096c55bba62ff937)) +- fix test script delayed response ([8a8d58d](https://github.com/espressif/esp-protocols/commit/8a8d58d), [IDF@a4f2639](https://github.com/espressif/esp-idf/commit/a4f263948c35c13340b6f4b59a649c5073787d5e)) +- fix wrong SRV/PTR record handling ([402baeb](https://github.com/espressif/esp-protocols/commit/402baeb), [IDF@e613555](https://github.com/espressif/esp-idf/commit/e6135552d26480e39e11632437020535b1667b7a)) +- fix wrong service hostname after mangling ([9fa25ef](https://github.com/espressif/esp-protocols/commit/9fa25ef), [IDF@439b31d](https://github.com/espressif/esp-idf/commit/439b31d065eddfdfb6eb4cf9c00454edfebc3d9b)) +- fix empty address change announce packets ([121b525](https://github.com/espressif/esp-protocols/commit/121b525), [IDF@7bbb72d](https://github.com/espressif/esp-idf/commit/7bbb72d86540f04d37b0e2c4efb6dc66ee9c9ea0)) +- fix mdns probe/reply behavior ([418fb60](https://github.com/espressif/esp-protocols/commit/418fb60), [IDF@d2a5d25](https://github.com/espressif/esp-idf/commit/d2a5d25984432d149ca31aea4a0d177f3509dd7b)) +- make delegate host address a list ([4049b3b](https://github.com/espressif/esp-protocols/commit/4049b3b), [IDF@2d34352](https://github.com/espressif/esp-idf/commit/2d34352f3db0fa71366a838933a29138a90eb2af)) +- add remove delegate host api ([c882119](https://github.com/espressif/esp-protocols/commit/c882119), [IDF@2174693](https://github.com/espressif/esp-idf/commit/2174693096b73ce93261611c44ecba647cd01859)) +- add mdns delegation ([1eb5df9](https://github.com/espressif/esp-protocols/commit/1eb5df9), [IDF@401ff56](https://github.com/espressif/esp-idf/commit/401ff56cc1ad1d11284143a348cc0c0e4a363e98)) +- fix memory free issue when repeating the query in reply ([b62b4b3](https://github.com/espressif/esp-protocols/commit/b62b4b3), [IDF@5f244c8](https://github.com/espressif/esp-idf/commit/5f244c86f29da46c17610563a245d1663a46b439)) +- Fix of crash when wifi interface get deleted and mdns receives the packets ([4d8aec1](https://github.com/espressif/esp-protocols/commit/4d8aec1), [IDF#6973](https://github.com/espressif/esp-idf/issues/6973), [IDF@03de74a](https://github.com/espressif/esp-idf/commit/03de74a728d4b278f55e1fc30e0425483b806e80)) +- Docs: Added README.md for lwip fuzzer tests ([6d64910](https://github.com/espressif/esp-protocols/commit/6d64910), [IDF@53c18a8](https://github.com/espressif/esp-idf/commit/53c18a85db104bb37ebeadec2faf5d42d764d0f9)) +- Fixed the ip header TTL to be correctly set to 255 ([ab3fa69](https://github.com/espressif/esp-protocols/commit/ab3fa69), [IDF@5cce919](https://github.com/espressif/esp-idf/commit/5cce919cbef87f543bb9f5275b77b97b3b1ea67e)) +- Fix parsing answers with questions when instance name not set ([c3a5826](https://github.com/espressif/esp-protocols/commit/c3a5826), [IDF#6598](https://github.com/espressif/esp-idf/issues/6598), [IDF@3404945](https://github.com/espressif/esp-idf/commit/34049454dfaf5132d9b258ef4d04921befc8997b)) +- Fix the resolver to correctly parse it's own non-strict answers ([cbcbe4f](https://github.com/espressif/esp-protocols/commit/cbcbe4f), [IDF@b649603](https://github.com/espressif/esp-idf/commit/b649603a0d70ec804567f57752c3eddaed56198f)) +- Add MDNS_STRICT_MODE config option ([adc3430](https://github.com/espressif/esp-protocols/commit/adc3430), [IDF@0eee315](https://github.com/espressif/esp-idf/commit/0eee31546dd4e6df0d1c1cc2740da0675dffb4bf)) +- freertos: common config header ([c30617d](https://github.com/espressif/esp-protocols/commit/c30617d), [IDF@39cf818](https://github.com/espressif/esp-idf/commit/39cf818838b0259b3e00b3c198ad47b4add41939)) +- Removed freeRTOS dependancies from fuzzer tests ([1e5eeb1](https://github.com/espressif/esp-protocols/commit/1e5eeb1), [IDF@5571694](https://github.com/espressif/esp-idf/commit/55716945a9908e057743d69e1d59399df03e49bd)) +- mDNS: Updated APIs description and shows the warning when hostname contains domain name during the query ([22c7c0a](https://github.com/espressif/esp-protocols/commit/22c7c0a), [IDF#6590](https://github.com/espressif/esp-idf/issues/6590), [IDF@9f8d2b9](https://github.com/espressif/esp-idf/commit/9f8d2b944d2b3736a012e0dff1a8459b6941d295)) +- components: Use CONFIG_LWIP_IPV6 to strip IPv6 function in components ([1623c0e](https://github.com/espressif/esp-protocols/commit/1623c0e), [IDF@da58235](https://github.com/espressif/esp-idf/commit/da58235a0ee262ff552c5f1155d531b5c31e8de6)) +- add bound check when setting interface as duplicate ([b114ed6](https://github.com/espressif/esp-protocols/commit/b114ed6), [IDF@2b9d2c0](https://github.com/espressif/esp-idf/commit/2b9d2c06f54924b680c41ae641978c8d81612f65)) +- mDNS: Fix of text length calculation when detecting a collision ([2ffd223](https://github.com/espressif/esp-protocols/commit/2ffd223), [IDF@be0ae1e](https://github.com/espressif/esp-idf/commit/be0ae1ebbbe9fae6ecf7de09e8d50cba063b61f4)) +- global: fix sign-compare warnings ([1fe901f](https://github.com/espressif/esp-protocols/commit/1fe901f), [IDF@753a929](https://github.com/espressif/esp-idf/commit/753a9295259126217a9fe6ef1c5e9da21e9b4e28)) +- lwip: Moved default SNTP API to esp_sntp.h ([2cf9fd8](https://github.com/espressif/esp-protocols/commit/2cf9fd8), [IDF@76f6dd6](https://github.com/espressif/esp-idf/commit/76f6dd6214ca583b1a94c7c553ccac739a27f6d5)) +- Allow resolve its own non-strict answers ([89439e0](https://github.com/espressif/esp-protocols/commit/89439e0), [IDF#6190](https://github.com/espressif/esp-idf/issues/6190), [IDF@0693e17](https://github.com/espressif/esp-idf/commit/0693e172de392086b9bfd8cf1474d8d133af3298)) +- mDNS: Fix of collision detection during txt length calculation ([becd5d0](https://github.com/espressif/esp-protocols/commit/becd5d0), [IDF#6114](https://github.com/espressif/esp-idf/issues/6114), [IDF@f33772c](https://github.com/espressif/esp-idf/commit/f33772c96037c795366e60082bdbbefe2a69165f)) +- esp32c3: Apply one-liner/small changes for ESP32-C3 ([0d7a309](https://github.com/espressif/esp-protocols/commit/0d7a309), [IDF@5228d9f](https://github.com/espressif/esp-idf/commit/5228d9f9ced16118d87326f94d9f9dfd411e0be9)) +- test: fix several test build error ([1fdffbb](https://github.com/espressif/esp-protocols/commit/1fdffbb), [IDF@b7ecccd](https://github.com/espressif/esp-idf/commit/b7ecccd9010f1deaba83de54374231c3c7f5b472)) +- freertos: Add RISC-V port ([988d120](https://github.com/espressif/esp-protocols/commit/988d120), [IDF@87e13ba](https://github.com/espressif/esp-idf/commit/87e13baaf12fe6deae715d95e912a310fea4ba88)) +- Fix wrong mdns source address if lwIP IPv6 zones disabled ([fd47df3](https://github.com/espressif/esp-protocols/commit/fd47df3), [IDF@7ac9761](https://github.com/espressif/esp-idf/commit/7ac97616c119e4d2f4cdd377dfc5abbf75ec5e30)) +- Whitespace: Automated whitespace fixes (large commit) ([2cb3a6e](https://github.com/espressif/esp-protocols/commit/2cb3a6e), [IDF@66fb5a2](https://github.com/espressif/esp-idf/commit/66fb5a29bbdc2482d67c52e6f66b303378c9b789)) +- test_compile_fuzzers: Fix include paths for host build ([825652f](https://github.com/espressif/esp-protocols/commit/825652f), [IDF@98a0cc7](https://github.com/espressif/esp-idf/commit/98a0cc783f701b238bea232b53250a538d34920a)) +- CI: Add a test to pre-check fuzzer tests compilation before weekly run ([fc53888](https://github.com/espressif/esp-protocols/commit/fc53888), [IDF@637f5c0](https://github.com/espressif/esp-idf/commit/637f5c0a6842c42ee6cf7f41d3c5ae0cb28a68af)) +- soc: descriptive part occupy whole component ([7635c04](https://github.com/espressif/esp-protocols/commit/7635c04), [IDF@79887fd](https://github.com/espressif/esp-idf/commit/79887fdc6c3d9a2e509cc189bb43c998d3f0f4ee)) +- Coredump config option rename throughout IDF ([d5fe42b](https://github.com/espressif/esp-protocols/commit/d5fe42b), [IDF@20af94f](https://github.com/espressif/esp-idf/commit/20af94ff53c5147a76342800d007a6c49be50a7b)) +- mdns, dns, dhcp, dhcps: update fuzzer test to work in CI ([e0bc60a](https://github.com/espressif/esp-protocols/commit/e0bc60a), [IDF@a43c06a](https://github.com/espressif/esp-idf/commit/a43c06a592bcf9404297b22268c33bb7a246632c)) +- cmock: added cmock as component ([9772e49](https://github.com/espressif/esp-protocols/commit/9772e49), [IDF@20c068e](https://github.com/espressif/esp-idf/commit/20c068ef3b49999387896b90f8011b02f718485f)) +- Support queries in responses in mDNS non-strict mode ([6021a88](https://github.com/espressif/esp-protocols/commit/6021a88), [IDF#5521](https://github.com/espressif/esp-idf/issues/5521), [IDF@bcfa36d](https://github.com/espressif/esp-idf/commit/bcfa36db8ffff997f1f95eaf6b011ffc4d46a10f)) +- Fix include query ID in reponses ([78f71ec](https://github.com/espressif/esp-protocols/commit/78f71ec), [IDF#5574](https://github.com/espressif/esp-idf/issues/5574), [IDF@f62e321](https://github.com/espressif/esp-idf/commit/f62e321d87c1d520cccca951715c27730e06607a)) +- Allow config mDNS task stack size ([3319844](https://github.com/espressif/esp-protocols/commit/3319844), [IDF@cf7e48c](https://github.com/espressif/esp-idf/commit/cf7e48c779edd84c3f99d5e8ed81027932302382)) +- Remove mbedtls dependency ([ac70c9a](https://github.com/espressif/esp-protocols/commit/ac70c9a), [IDF@f4a4549](https://github.com/espressif/esp-idf/commit/f4a4549a344e7ff2444a188adbebbc136b47a7bb)) +- limit the GOT_IP6_EVENT to only known network interfaces ([2b7d43e](https://github.com/espressif/esp-protocols/commit/2b7d43e), [IDF@ab8cab1](https://github.com/espressif/esp-idf/commit/ab8cab1c553ee5312ef47a7dea002f2585605006)) +- esp32: add implementation of esp_timer based on TG0 LAC timer ([4eb3e89](https://github.com/espressif/esp-protocols/commit/4eb3e89), [IDF@739eb05](https://github.com/espressif/esp-idf/commit/739eb05bb97736b70507e7ebcfee58e670672d23)) +- fixed typos in the variable names and the comments ([b5e5a64](https://github.com/espressif/esp-protocols/commit/b5e5a64), [IDF@ecca39e](https://github.com/espressif/esp-idf/commit/ecca39e19f663e32e16aef2a09df15443de347e9)) +- fix preset of esp_netif ptr for local interfaces ([6713ffe](https://github.com/espressif/esp-protocols/commit/6713ffe), [IDF@09e36f9](https://github.com/espressif/esp-idf/commit/09e36f9f3354092b2a528baaaaccab28ff4774d6)) +- fixed crash on event during deinit ([817c4fd](https://github.com/espressif/esp-protocols/commit/817c4fd), [IDF@eaa2f12](https://github.com/espressif/esp-idf/commit/eaa2f12d6761710d2633b4934fe09f6f45e20f4f)) +- respond to discovery with the proper pseudo name _services._dns-sd._udp ([8f0dc6d](https://github.com/espressif/esp-protocols/commit/8f0dc6d), [IDF#4369](https://github.com/espressif/esp-idf/issues/4369), [IDF@de17a14](https://github.com/espressif/esp-idf/commit/de17a1487f8ba6f432b06199f2261132ec6e735f)) +- fixed forgotten merge conflicts in debug code ([d20666f](https://github.com/espressif/esp-protocols/commit/d20666f), [IDF@d9433ef](https://github.com/espressif/esp-idf/commit/d9433ef69223a32d05abdca543fb530f2e6679e4)) +- add missing include of esp_task.h ([662a4ce](https://github.com/espressif/esp-protocols/commit/662a4ce), [IDF@5884b80](https://github.com/espressif/esp-idf/commit/5884b80908d680874e27fa0c8b2df85b69d03dd3)) +- add configuration values for task priority, affinity and internal service timeouts ([fb1de80](https://github.com/espressif/esp-protocols/commit/fb1de80), [IDF@c6f38f0](https://github.com/espressif/esp-idf/commit/c6f38f04f8eec1aae937cc87c111609772681cb3)) +- tcpip_adapter: updated tcpip_adapter compatablity layer to include all public API and keep 100% backward compatibility update build of tcpip adapter when ethernet disabled ([1f35e9a](https://github.com/espressif/esp-protocols/commit/1f35e9a), [IDF@7f5cda1](https://github.com/espressif/esp-idf/commit/7f5cda1b825586903f85dc4ad7736b35712e46d7)) +- update mdns to use esp-netif for mdns supported services such as STA, AP, ETH ([48b819b](https://github.com/espressif/esp-protocols/commit/48b819b), [IDF@19e24fe](https://github.com/espressif/esp-idf/commit/19e24fe61ed5ea6698dfd5e1f427e783360aa846)) +- esp_netif: Introduction of esp-netif component as a replacement of tcpip_adpter ([53e2aa3](https://github.com/espressif/esp-protocols/commit/53e2aa3), [IDF@ffe043b](https://github.com/espressif/esp-idf/commit/ffe043b1a81a0f9e1cc2cfa8873e21318ec89143)) +- examples: removed ip4addr_ntoa and used prefered IP2STR for displaying IP addresses ([3cc6446](https://github.com/espressif/esp-protocols/commit/3cc6446), [IDF@ec9f245](https://github.com/espressif/esp-idf/commit/ec9f245dd35d3e8e7b19a8dec5e05e003dc21f39)) +- esp_event, mdns: fixes for CONFIG_ETH_ENABLED=n ([248b11b](https://github.com/espressif/esp-protocols/commit/248b11b), [IDF@569ad75](https://github.com/espressif/esp-idf/commit/569ad7545c32a2f1d0eff3f1e81df70fb76ad125)) +- build and link hello-world for esp32s2beta ([901124b](https://github.com/espressif/esp-protocols/commit/901124b), [IDF@84b2f9f](https://github.com/espressif/esp-idf/commit/84b2f9f14d16533c84db2210f13a24cd817e0b0a)) +- fix crash for hostname queries ([f6ff165](https://github.com/espressif/esp-protocols/commit/f6ff165), [IDF#4224](https://github.com/espressif/esp-idf/issues/4224), [IDF@3d11700](https://github.com/espressif/esp-idf/commit/3d1170031b340a231949fdc0d9c46d87af0d1b5d)) +- fix possible race condition when checking DHCP status on WIFI_EVENT_STA_CONNECTED event. ([f44c569](https://github.com/espressif/esp-protocols/commit/f44c569), [IDF@7f410a0](https://github.com/espressif/esp-idf/commit/7f410a0bcbafa85dba05807c53c3c38999506509)) +- use constant size of AAAA answer in mdns packets instead of deriving from lwip struct size, since the struct could contain also zones ([286c646](https://github.com/espressif/esp-protocols/commit/286c646), [IDF@e5e31c5](https://github.com/espressif/esp-idf/commit/e5e31c5d0172d68fd207fa31cc5d3bba82dad020)) +- esp_wifi: wifi support new event mechanism ([c70d527](https://github.com/espressif/esp-protocols/commit/c70d527), [IDF@003a987](https://github.com/espressif/esp-idf/commit/003a9872b7de69d799e9d37521cfbcaff9b37e85)) +- fix missing bye packet if services removed with mdns_service_remove_all() or mdns_free() ([7cdf96c](https://github.com/espressif/esp-protocols/commit/7cdf96c), [IDF#3660](https://github.com/espressif/esp-idf/issues/3660), [IDF@a001998](https://github.com/espressif/esp-idf/commit/a001998d5283b29ca9a374adf7cef3357b39a03a)) +- mdns_service_remove_all doesn't take an argument ([407875d](https://github.com/espressif/esp-protocols/commit/407875d), [IDF@c2764f6](https://github.com/espressif/esp-idf/commit/c2764f6fe85681cfaf5dbbe168295284f09c09cd)) +- tools: Mass fixing of empty prototypes (for -Wstrict-prototypes) ([3e753f5](https://github.com/espressif/esp-protocols/commit/3e753f5), [IDF@afbaf74](https://github.com/espressif/esp-idf/commit/afbaf74007e89d016dbade4072bf2e7a3874139a)) +- fix ignoring mdns packet with some invalid name entries in question field ([144d4ad](https://github.com/espressif/esp-protocols/commit/144d4ad), [IDF@4bd4c7c](https://github.com/espressif/esp-idf/commit/4bd4c7caf3f9ef8402c5a27ab44561537407eb60)) +- add esp_eth component ([680bad6](https://github.com/espressif/esp-protocols/commit/680bad6), [IDF@90c4827](https://github.com/espressif/esp-idf/commit/90c4827bd22aa61894a5b22b3b39247a7e44d6cf)) +- components: use new component registration api ([7fb6686](https://github.com/espressif/esp-protocols/commit/7fb6686), [IDF@9eccd7c](https://github.com/espressif/esp-idf/commit/9eccd7c0826d6cc2e9de59304d1e5f76c0063ccf)) +- fix static analysis warnings ([4912bef](https://github.com/espressif/esp-protocols/commit/4912bef), [IDF@c34de4c](https://github.com/espressif/esp-idf/commit/c34de4cba658e8331f8a3ab2f466190c7640595b)) +- added initial suite of api unit tests ([181a22e](https://github.com/espressif/esp-protocols/commit/181a22e), [IDF@e680191](https://github.com/espressif/esp-idf/commit/e6801912c5c4861f828ab1f447280628bba9a5d7)) +- mdns tests: adapt mdns fuzzer test to compile with event loop library ([4172219](https://github.com/espressif/esp-protocols/commit/4172219), [IDF@38d15cb](https://github.com/espressif/esp-idf/commit/38d15cbd637e8b8baacda9fc43e8e99d224530f5)) +- fixed mdns crashing on reception of txt packet without a corresponding service closes #2866 ([98d2c1a](https://github.com/espressif/esp-protocols/commit/98d2c1a), [IDF@af48977](https://github.com/espressif/esp-idf/commit/af48977f21cea6b18dae10b2c8b64a78acfc647f)) +- use const char* for mdns txt items types to remove warning when assigning ([84cbb1f](https://github.com/espressif/esp-protocols/commit/84cbb1f), [IDF@c050a75](https://github.com/espressif/esp-idf/commit/c050a75616803c7871ef11c060e440fae09000d9)) +- updated doxygen comments documenting mdns api ([4c6818e](https://github.com/espressif/esp-protocols/commit/4c6818e), [IDF#1718](https://github.com/espressif/esp-idf/issues/1718), [IDF@a851aac](https://github.com/espressif/esp-idf/commit/a851aac255311124529f504486ca55bad15c1951)) +- update mdns_out_question_s to be in line with mdns_parsed_question_s struct ([c440114](https://github.com/espressif/esp-protocols/commit/c440114), [IDF#1568]( https://github.com/espressif/esp-idf/issues/1568), [IDF@eddd5c4](https://github.com/espressif/esp-idf/commit/eddd5c4f2c686d9a1d6d3258569cc33752e78880)) +- use esp_event library to handle events ([6ea0ea9](https://github.com/espressif/esp-protocols/commit/6ea0ea9), [IDF@a2d5952](https://github.com/espressif/esp-idf/commit/a2d59525e53099ee1ad63c3d60ff853f573ab535)) +- fuzzer tests: update of mdns and lwip host compilation for fuzzer testing ([d9aec9f](https://github.com/espressif/esp-protocols/commit/d9aec9f), [IDF@bc60bbb](https://github.com/espressif/esp-idf/commit/bc60bbbeaf89f2bbfc5db4bd4f1e7ace81a2ab37)) +- fix possible crash when probing on particular interface with duplicated service instances due to naming conflicts on network ([985e691](https://github.com/espressif/esp-protocols/commit/985e691), [IDF@265e983](https://github.com/espressif/esp-idf/commit/265e983a452a7eaefc1662cdc0e6ed839a37fe1a)) +- enable pcbs before starting service thread to avoid updating pcb's internal variables from concurent tasks ([75deebb](https://github.com/espressif/esp-protocols/commit/75deebb), [IDF@c87f0cb](https://github.com/espressif/esp-idf/commit/c87f0cb6cad3c36b077f4aaeb1ca52fe6ed0cdaf)) +- fix possible deadlock on mdns deinit calling mdns_free() ([fdd27dc](https://github.com/espressif/esp-protocols/commit/fdd27dc), [IDF#1696](https://github.com/espressif/esp-idf/issues/1696), [IDF@48b5501](https://github.com/espressif/esp-idf/commit/48b5501c250ed90da51a55ad4fc18e09f466a517)) +- mdsn: fix race condition in updating packet data from user task when failed to allocate or queue a new service ([2ec3b55](https://github.com/espressif/esp-protocols/commit/2ec3b55), [IDF@021dc5d](https://github.com/espressif/esp-idf/commit/021dc5d453e21e2d1707f194668e69cf63ef4e84)) +- fix possible crash when packet scheduled to transmit contained service which might have been already removed ([450cbf0](https://github.com/espressif/esp-protocols/commit/450cbf0), [IDF@67051a2](https://github.com/espressif/esp-idf/commit/67051a286ba60a01d4755c3682129153c2f95953)) +- use binary semaphore instead of mutex when searching ([34f6d8d](https://github.com/espressif/esp-protocols/commit/34f6d8d), [IDF@eef0b50](https://github.com/espressif/esp-idf/commit/eef0b5090aee87efef1a6a37772b3b88c9ce8df8)) +- fix memory leak in pbuf if tcpipadapter failed to get netif ([b6efc68](https://github.com/espressif/esp-protocols/commit/b6efc68), [IDF@8462751](https://github.com/espressif/esp-idf/commit/8462751f95a3ff18bdc1b01d02fabd1829fd9135)) +- fix malfuctional query_txt ([90e4bab](https://github.com/espressif/esp-protocols/commit/90e4bab), [IDF@1a02773](https://github.com/espressif/esp-idf/commit/1a027734af06abf08fcb1c34ee65bdf50d12be4d)) +- fix possible crash when mdns_free called while action queue not empty ([c546ab8](https://github.com/espressif/esp-protocols/commit/c546ab8), [IDF@206b47c](https://github.com/espressif/esp-idf/commit/206b47c03aca0acdf40d1d9c250e18aeddfe1bd7)) +- fix memory leak when query for service receives multiple ptr entries for one instance ([6582b41](https://github.com/espressif/esp-protocols/commit/6582b41), [IDF@9a4da97](https://github.com/espressif/esp-idf/commit/9a4da97fb4b3c241998cb969a08c3a917ffb4cd1)) +- fix crash after init if no memory for task ([358d26c](https://github.com/espressif/esp-protocols/commit/358d26c), [IDF@a47768d](https://github.com/espressif/esp-idf/commit/a47768dc4e4750fd7e1c29b15d6e2dd3c76e6591)) +- fixed crash on free undefined ptr after skipped strdup ([2ac83d0](https://github.com/espressif/esp-protocols/commit/2ac83d0), [IDF@e0a8044](https://github.com/espressif/esp-idf/commit/e0a8044a16907e642001b883469618a999dbe6db)) +- Correct Kconfigs according to the coding style ([98e3171](https://github.com/espressif/esp-protocols/commit/98e3171), [IDF@37126d3](https://github.com/espressif/esp-idf/commit/37126d3451eabb44eeeb48b8e2ee554dc233e2a8)) +- fix networking running udp_sendif from lwip thread ([2f85c07](https://github.com/espressif/esp-protocols/commit/2f85c07), [IDF@f7d4a4b](https://github.com/espressif/esp-idf/commit/f7d4a4be6a9e0b0ac5edb9400d3b123dbbed2ffc)) +- fixed static memory leak ([b30a7fe](https://github.com/espressif/esp-protocols/commit/b30a7fe), [IDF@6bb68a5](https://github.com/espressif/esp-idf/commit/6bb68a5a7567a94c3605136d44960ff060c74663)) +- check all mallocs for failure and add default hook to log error with free heap ([7a4fdad](https://github.com/espressif/esp-protocols/commit/7a4fdad), [IDF@c8cb4cd](https://github.com/espressif/esp-idf/commit/c8cb4cd3c8eb56d5901ade03302ad1231d7f3de5)) +- resolve memory leak when txt record received multiple times ([b4e5742](https://github.com/espressif/esp-protocols/commit/b4e5742), [IDF@a6b2b73](https://github.com/espressif/esp-idf/commit/a6b2b73f03bbb75a39685ddba6cf877fd1e5e6d7)) +- skip sending search when finished, not properly locked timer task ([2763bcd](https://github.com/espressif/esp-protocols/commit/2763bcd), [IDF@31163f0](https://github.com/espressif/esp-idf/commit/31163f02d5c414d8b492dce6f729b43a0061581b)) +- sending search packets also in probing and announcing state ([8cd0e8a](https://github.com/espressif/esp-protocols/commit/8cd0e8a), [IDF@d16762a](https://github.com/espressif/esp-idf/commit/d16762a036e35ce86ece86bb44e6e99f9cc7c431)) +- fixed crashes on network changes ([9b3b41c](https://github.com/espressif/esp-protocols/commit/9b3b41c), [IDF@097282a](https://github.com/espressif/esp-idf/commit/097282a8e3f85958747430d9931ce0a545d37700)) +- Update network code for mDNS to work with newest LwIP ([ea23007](https://github.com/espressif/esp-protocols/commit/ea23007), [IDF@3ec0e7e](https://github.com/espressif/esp-idf/commit/3ec0e7e2d2ddea70e9f8fb5025664d0fe24c301a)) +- bugfix: mdns_service_txt_set() wasn't allocating memory for TXT records ([0c17121](https://github.com/espressif/esp-protocols/commit/0c17121), [IDF@e5e2702](https://github.com/espressif/esp-idf/commit/e5e2702ca3f63a29da57eb138f75a20c74fb2a94)) +- cmake: make main a component again ([67173f6](https://github.com/espressif/esp-protocols/commit/67173f6), [IDF@d9939ce](https://github.com/espressif/esp-idf/commit/d9939cedd9b44d63dc148354c3a0a139b9c7113d)) +- Feature/sync lwip as submodule ([fed787f](https://github.com/espressif/esp-protocols/commit/fed787f), [IDF@3578fe3](https://github.com/espressif/esp-idf/commit/3578fe39e01ba0c2d54824ac70c3276502661c6b)) +- Fix a portion of the queries are issued with the wildcard query type ([b4ab30b](https://github.com/espressif/esp-protocols/commit/b4ab30b), [IDF@f3f0445](https://github.com/espressif/esp-idf/commit/f3f0445f4db7c9ad97ae10a9728767337aa7bb62)) +- added CI job for AFL fuzzer tests ([dd71494](https://github.com/espressif/esp-protocols/commit/dd71494), [IDF@0c14764](https://github.com/espressif/esp-idf/commit/0c147648f7642d058b63fbe2ddd5de31c2326304)) +- Minor fix for mdns_service_remove() ([39de491](https://github.com/espressif/esp-protocols/commit/39de491), [IDF@5c7eb7e](https://github.com/espressif/esp-idf/commit/5c7eb7e27be7508130459d896cf7d13ffefda87f)) +- Replace all DOS line endings with Unix ([19acac7](https://github.com/espressif/esp-protocols/commit/19acac7), [IDF@a67d5d8](https://github.com/espressif/esp-idf/commit/a67d5d89e0e90390fa7ff02816a6a79008d75d40)) +- remove executable permission from source files ([98069f9](https://github.com/espressif/esp-protocols/commit/98069f9), [IDF@cb649e4](https://github.com/espressif/esp-idf/commit/cb649e452f3c64a7db1f4a61e162a16b70248204)) +- Fixed nullptr dereference in MDNS.c ([ad29d34](https://github.com/espressif/esp-protocols/commit/ad29d34), [IDF@fffbf7b](https://github.com/espressif/esp-idf/commit/fffbf7b75065b5852e064e04b0c5102dd0fc2244)) +- MDNS-Fuzzer: AFL fuzzer tests for mdsn packet parser ([9f1be36](https://github.com/espressif/esp-protocols/commit/9f1be36), [IDF@e983230](https://github.com/espressif/esp-idf/commit/e983230be933fb83cebdd1945ba6539a7dc99b28)) +- cmake: Add component dependency support ([c7701d4](https://github.com/espressif/esp-protocols/commit/c7701d4), [IDF@1cb5712](https://github.com/espressif/esp-idf/commit/1cb5712463a8963cd3e8331da90fb5e03f13575f)) +- cmake: Remove defaults for COMPONENT_SRCDIRS, COMPONENT_SRCS, COMPONENT_ADD_INCLUDEDIRS ([f1ccc40](https://github.com/espressif/esp-protocols/commit/f1ccc40), [IDF@4f1a856](https://github.com/espressif/esp-idf/commit/4f1a856dbfd752336cd71730105e02ad8c045541)) +- build system: Initial cmake support, work in progress ([84bd1d7](https://github.com/espressif/esp-protocols/commit/84bd1d7), [IDF@c671a0c](https://github.com/espressif/esp-idf/commit/c671a0c3ebf90f18576d6db55b51b62730c58301)) +- fix the bug that in mdns test code redefine esp_err_t to uint32_t, which should be int32_t ([259d3fc](https://github.com/espressif/esp-protocols/commit/259d3fc), [IDF@81e4cad](https://github.com/espressif/esp-idf/commit/81e4cad61593cde879a5c44a08060d9d336e5a3f)) +- Fix exception when service is removed while there are pending packets that depend on it ([7784d00](https://github.com/espressif/esp-protocols/commit/7784d00), [IDF@421c6f1](https://github.com/espressif/esp-idf/commit/421c6f154b10d9253b78875ab28ee6bdcaaaf3c0)) +- Fix case where service is NULL and that will cause exception ([bce7d52](https://github.com/espressif/esp-protocols/commit/bce7d52), [IDF@4fa130a](https://github.com/espressif/esp-idf/commit/4fa130ae4fb5de99ddddc5a7bed7e26ae645591c)) +- Fix issue with some mDNS parsers ([ef924f1](https://github.com/espressif/esp-protocols/commit/ef924f1), [IDF@51dde19](https://github.com/espressif/esp-idf/commit/51dde19a765533af67fc7be21f116641773a9be4)) +- Import mDNS changes ([ad8c92d](https://github.com/espressif/esp-protocols/commit/ad8c92d), [IDF@4bddbc0](https://github.com/espressif/esp-idf/commit/4bddbc031cee83935c0e4df1dc72cc7000c97ba5)) +- Fix compilation errors when using gcc-7.2.0 for the crosstool-ng toolchain ([3aa605f](https://github.com/espressif/esp-protocols/commit/3aa605f), [IDF@519edc3](https://github.com/espressif/esp-idf/commit/519edc332dae0160069fd790467cde8de78f1a0e)) +- components/mdns: wrong Message compression detect ([00a72b8](https://github.com/espressif/esp-protocols/commit/00a72b8), [IDF@6e24566](https://github.com/espressif/esp-idf/commit/6e24566186c52dc5432b6b25c81abda577c21e85)) +- fix leak after _mdns_create_service if we have a malloc error. ([907e7ee](https://github.com/espressif/esp-protocols/commit/907e7ee), [IDF@b6b36bd](https://github.com/espressif/esp-idf/commit/b6b36bd9ddf169039a5528f8b766048d97b975f7)) +- Use LwIP IPC for low-level API calls ([b367484](https://github.com/espressif/esp-protocols/commit/b367484), [IDF@713964f](https://github.com/espressif/esp-idf/commit/713964fe9e98b4fa34145c497b7ab638dc57614c)) +- Add AFL fuzz test ([4a8582f](https://github.com/espressif/esp-protocols/commit/4a8582f), [IDF@4c26227](https://github.com/espressif/esp-idf/commit/4c2622755d92efa1818d062d433725553437993c)) +- implement fixes for issues found while fuzz testing ([75de31c](https://github.com/espressif/esp-protocols/commit/75de31c), [IDF@99d3990](https://github.com/espressif/esp-idf/commit/99d39909c4f19c63909d663e927ac0a8933a3ed5)) +- add simple dns-sd meta query support ([4acf639](https://github.com/espressif/esp-protocols/commit/4acf639), [IDF@96e8a3c](https://github.com/espressif/esp-idf/commit/96e8a3c725095562d2725aaefa15adcfc5d78dd5)) +- address security issues with mDNS ([91bb509](https://github.com/espressif/esp-protocols/commit/91bb509), [IDF@c89e11c](https://github.com/espressif/esp-idf/commit/c89e11c8fa64641edddf9a055745d825ae3fab9d)) +- Initial mDNS component and example ([7fbf8e5](https://github.com/espressif/esp-protocols/commit/7fbf8e5), [IDF@dd3f18d](https://github.com/espressif/esp-idf/commit/dd3f18d2d88ee78909d4af2840dfdf0b9f715f28)) diff --git a/managed_components/espressif__mdns/CMakeLists.txt b/managed_components/espressif__mdns/CMakeLists.txt new file mode 100644 index 0000000..5823849 --- /dev/null +++ b/managed_components/espressif__mdns/CMakeLists.txt @@ -0,0 +1,42 @@ +if(CONFIG_MDNS_NETWORKING_SOCKET) + set(MDNS_NETWORKING "mdns_networking_socket.c") +else() + set(MDNS_NETWORKING "mdns_networking_lwip.c") +endif() + +if(CONFIG_MDNS_ENABLE_CONSOLE_CLI) + set(MDNS_CONSOLE "mdns_console.c") +else() + set(MDNS_CONSOLE "") +endif() + +set(MDNS_MEMORY "mdns_mem_caps.c") + +idf_build_get_property(target IDF_TARGET) +if(${target} STREQUAL "linux") + set(dependencies esp_netif_linux esp_event) + set(private_dependencies esp_timer console esp_system) + set(srcs "mdns.c" ${MDNS_MEMORY} ${MDNS_NETWORKING} ${MDNS_CONSOLE}) +else() + set(dependencies lwip console esp_netif) + set(private_dependencies esp_timer esp_wifi) + set(srcs "mdns.c" ${MDNS_MEMORY} ${MDNS_NETWORKING} ${MDNS_CONSOLE}) +endif() + +idf_component_register( + SRCS ${srcs} + INCLUDE_DIRS "include" + PRIV_INCLUDE_DIRS "private_include" + REQUIRES ${dependencies} + PRIV_REQUIRES ${private_dependencies}) + +if(${target} STREQUAL "linux") + target_link_libraries(${COMPONENT_LIB} PRIVATE "-lbsd") +endif() + +if(CONFIG_ETH_ENABLED) + idf_component_optional_requires(PRIVATE esp_eth) +endif() + +idf_component_get_property(MDNS_VERSION ${COMPONENT_NAME} COMPONENT_VERSION) +target_compile_definitions(${COMPONENT_LIB} PUBLIC "-DESP_MDNS_VERSION_NUMBER=\"${MDNS_VERSION}\"") diff --git a/managed_components/espressif__mdns/Kconfig b/managed_components/espressif__mdns/Kconfig new file mode 100644 index 0000000..04380a4 --- /dev/null +++ b/managed_components/espressif__mdns/Kconfig @@ -0,0 +1,190 @@ +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" + 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. + + 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_ACTION_QUEUE_LEN + int "Maximum actions pending to the server" + range 8 64 + default 16 + help + Allows setting the length of mDNS action queue. + + 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 + + menu "MDNS Memory Configuration" + + choice MDNS_TASK_MEMORY_ALLOC_FROM + prompt "Select mDNS task create on which type of memory" + default MDNS_TASK_CREATE_FROM_INTERNAL + config MDNS_TASK_CREATE_FROM_SPIRAM + bool "mDNS task creates on the SPIRAM (READ HELP)" + depends on (SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC) + help + mDNS task creates on the SPIRAM. + This option requires FreeRTOS component to allow creating + tasks on the external memory. + Please read the documentation about FREERTOS_TASK_CREATE_ALLOW_EXT_MEM + + config MDNS_TASK_CREATE_FROM_INTERNAL + bool "mDNS task creates on the internal RAM" + + endchoice + + choice MDNS_MEMORY_ALLOC_FROM + prompt "Select mDNS memory allocation type" + default MDNS_MEMORY_ALLOC_INTERNAL + + config MDNS_MEMORY_ALLOC_SPIRAM + bool "Allocate mDNS memory from SPIRAM" + depends on (SPIRAM_USE_CAPS_ALLOC || SPIRAM_USE_MALLOC) + + config MDNS_MEMORY_ALLOC_INTERNAL + bool "Allocate mDNS memory from internal RAM" + + endchoice + + config MDNS_MEMORY_CUSTOM_IMPL + bool "Implement custom memory functions" + default n + help + Enable to implement custom memory functions for mDNS library. + This option is useful when the application wants to use custom + memory allocation functions for mDNS library. + + endmenu # MDNS Memory Configuration + + 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_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_SKIP_SUPPRESSING_OWN_QUERIES + bool "Skip suppressing our own packets" + default n + help + Enable only if the querier and the responder share the same IP address. + This usually happens in test mode, where we may run multiple instances of + responders/queriers on the same interface. + + config MDNS_ENABLE_DEBUG_PRINTS + bool "Enable debug prints of mDNS packets" + default n + help + Enable for the library to log received and sent mDNS packets to stdout. + + config MDNS_ENABLE_CONSOLE_CLI + bool "Enable Command Line Interface on device console" + default y + help + Enable for the console cli to be available on the device. + + config MDNS_RESPOND_REVERSE_QUERIES + bool "Enable responding to IPv4 reverse queries" + default n + help + Enables support for IPv4 reverse lookup. If enabled, the mDNS library + response to PTR queries of "A.B.C.D.in-addr.arpa" type. + + 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 diff --git a/managed_components/espressif__mdns/LICENSE b/managed_components/espressif__mdns/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/managed_components/espressif__mdns/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/managed_components/espressif__mdns/README.md b/managed_components/espressif__mdns/README.md new file mode 100644 index 0000000..a644ad4 --- /dev/null +++ b/managed_components/espressif__mdns/README.md @@ -0,0 +1,14 @@ +# mDNS Service + +[![Component Registry](https://components.espressif.com/components/espressif/mdns/badge.svg)](https://components.espressif.com/components/espressif/mdns) + +mDNS is a multicast UDP service that is used to provide local network service and host discovery. + +## Examples + +Get started with example test [Example](https://github.com/espressif/esp-protocols/tree/master/components/mdns/examples): + +## Documentation + +* View the full [documentation(English)](https://docs.espressif.com/projects/esp-protocols/mdns/docs/latest/en/index.html) +* View the full [documentation(Chinese)](https://docs.espressif.com/projects/esp-protocols/mdns/docs/latest/zh_CN/index.html) diff --git a/managed_components/espressif__mdns/examples/query_advertise/CMakeLists.txt b/managed_components/espressif__mdns/examples/query_advertise/CMakeLists.txt new file mode 100644 index 0000000..9a16f14 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/CMakeLists.txt @@ -0,0 +1,6 @@ +# 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) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +project(query_advertise) diff --git a/managed_components/espressif__mdns/examples/query_advertise/README.md b/managed_components/espressif__mdns/examples/query_advertise/README.md new file mode 100644 index 0000000..6ccdef9 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/README.md @@ -0,0 +1,91 @@ +# mDNS example + +Shows how to use mDNS to advertise and query 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) +``` diff --git a/managed_components/espressif__mdns/examples/query_advertise/main/CMakeLists.txt b/managed_components/espressif__mdns/examples/query_advertise/main/CMakeLists.txt new file mode 100644 index 0000000..eb0e6d9 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/main/CMakeLists.txt @@ -0,0 +1,2 @@ +idf_component_register(SRCS "mdns_example_main.c" + INCLUDE_DIRS ".") diff --git a/managed_components/espressif__mdns/examples/query_advertise/main/Kconfig.projbuild b/managed_components/espressif__mdns/examples/query_advertise/main/Kconfig.projbuild new file mode 100644 index 0000000..18e1cc2 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/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 diff --git a/managed_components/espressif__mdns/examples/query_advertise/main/idf_component.yml b/managed_components/espressif__mdns/examples/query_advertise/main/idf_component.yml new file mode 100644 index 0000000..f7245a2 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/main/idf_component.yml @@ -0,0 +1,6 @@ +dependencies: + espressif/mdns: + version: ^1.0.0 + idf: '>=5.0' + protocol_examples_common: + path: ${IDF_PATH}/examples/common_components/protocol_examples_common diff --git a/managed_components/espressif__mdns/examples/query_advertise/main/mdns_example_main.c b/managed_components/espressif__mdns/examples/query_advertise/main/mdns_example_main.c new file mode 100644 index 0000000..afe256e --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/main/mdns_example_main.c @@ -0,0 +1,423 @@ +/* + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ + +/* + * MDNS-SD Query and advertise Example +*/ +#include +#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" + +#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 1, 0) +/* CONFIG_LWIP_IPV4 was introduced in IDF v5.1, set CONFIG_LWIP_IPV4 to 1 by default for IDF v5.0 */ +#ifndef CONFIG_LWIP_IPV4 +#define CONFIG_LWIP_IPV4 1 +#endif // CONFIG_LWIP_IPV4 +#endif // ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 1, 0) + +#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) { + if (r->esp_netif) { + printf("%d: Interface: %s, Type: %s, TTL: %" PRIu32 "\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); +} + +#if CONFIG_MDNS_PUBLISH_DELEGATE_HOST +static void lookup_mdns_delegated_service(const char *service_name, const char *proto) +{ + ESP_LOGI(TAG, "Lookup delegated service: %s.%s.local", service_name, proto); + + mdns_result_t *results = NULL; + esp_err_t err = mdns_lookup_delegated_service(NULL, service_name, proto, 20, &results); + if (err) { + ESP_LOGE(TAG, "Lookup 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); +} +#endif // CONFIG_MDNS_PUBLISH_DELEGATE_HOST + +static void lookup_mdns_selfhosted_service(const char *service_name, const char *proto) +{ + ESP_LOGI(TAG, "Lookup selfhosted service: %s.%s.local", service_name, proto); + mdns_result_t *results = NULL; + esp_err_t err = mdns_lookup_selfhosted_service(NULL, service_name, proto, 20, &results); + if (err) { + ESP_LOGE(TAG, "Lookup 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); + } +} +#ifdef CONFIG_LWIP_IPV4 +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)); +} +#endif // CONFIG_LWIP_IPV4 + +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"); +#ifdef CONFIG_LWIP_IPV4 + query_mdns_host("esp32"); +#endif + 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"); +#if CONFIG_MDNS_PUBLISH_DELEGATE_HOST + lookup_mdns_delegated_service("_http", "_tcp"); +#endif // CONFIG_MDNS_PUBLISH_DELEGATE_HOST + lookup_mdns_selfhosted_service("_http", "_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 */ +#ifdef CONFIG_LWIP_IPV4 + query_mdns_host("tinytester"); +#endif + 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()); + + ESP_LOGI(TAG, "mDNS Ver: %s", ESP_MDNS_VERSION_NUMBER); + + 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 | MDNS_EVENT_ENABLE_IP6)); + ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_ANNOUNCE_IP4 | MDNS_EVENT_ANNOUNCE_IP6)); + +#if defined(CONFIG_MDNS_RESPOND_REVERSE_QUERIES) + ESP_ERROR_CHECK(mdns_netif_action(EXAMPLE_INTERFACE, MDNS_EVENT_IP4_REVERSE_LOOKUP | MDNS_EVENT_IP6_REVERSE_LOOKUP)); +#endif + +#endif // CONFIG_MDNS_ADD_CUSTOM_NETIF + + 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, +#if defined(CONFIG_LWIP_IPV6) && defined(CONFIG_LWIP_IPV4) + res->h_addrtype == AF_INET ? inet_ntoa(*(struct in_addr *)(res->h_addr_list[i])) : + inet6_ntoa(*(struct in6_addr *)(res->h_addr_list[i])) +#elif defined(CONFIG_LWIP_IPV6) + inet6_ntoa(*(struct in6_addr *)(res->h_addr_list[i])) +#else + inet_ntoa(*(struct in_addr *)(res->h_addr_list[i])) +#endif + ); + 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) { + char *resolved_addr; +#if defined(CONFIG_LWIP_IPV6) && defined(CONFIG_LWIP_IPV4) + resolved_addr = res->ai_family == AF_INET ? + inet_ntoa(((struct sockaddr_in *) res->ai_addr)->sin_addr) : + inet6_ntoa(((struct sockaddr_in6 *) res->ai_addr)->sin6_addr); +#elif defined(CONFIG_LWIP_IPV6) + resolved_addr = inet6_ntoa(((struct sockaddr_in6 *) res->ai_addr)->sin6_addr); +#else + resolved_addr = inet_ntoa(((struct sockaddr_in *) res->ai_addr)->sin_addr); +#endif // CONFIG_LWIP_IPV6 + ESP_LOGI(TAG, "getaddrinfo: %s resolved to: %s", host, resolved_addr); + res = res->ai_next; + } + } +} +#endif diff --git a/managed_components/espressif__mdns/examples/query_advertise/pytest_mdns.py b/managed_components/espressif__mdns/examples/query_advertise/pytest_mdns.py new file mode 100644 index 0000000..e78e094 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/pytest_mdns.py @@ -0,0 +1,203 @@ +# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD +# SPDX-License-Identifier: Unlicense OR CC0-1.0 +import re +import select +import socket +import struct +import subprocess +import time +from threading import Event, Thread + +try: + import dpkt + import dpkt.dns +except ImportError: + pass + + +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' + print('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) + print('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: + for dns_query in dns.qd: + if dns_query.type == dpkt.dns.DNS_A: + if dns_query.name == TESTER_NAME: + print('Received query: {} '.format(dns.__repr__())) + sock.sendto(get_dns_answer_to_mdns(TESTER_NAME), + (MCAST_GRP, UDP_PORT)) + elif dns_query.name == TESTER_NAME_LWIP: + print('Received query: {} '.format(dns.__repr__())) + sock.sendto( + get_dns_answer_to_mdns_lwip(TESTER_NAME_LWIP, dns.id), + addr) + if len(dns.an) > 0: + for dns_answer in dns.an: + if dns_answer.type == dpkt.dns.DNS_A: + print('Received answer from {}'.format(dns_answer.name)) + if dns_answer.name == esp_host + u'.local': + print('Received answer to esp32-mdns query: {}'.format( + dns.__repr__())) + events['esp_answered'].set() + if dns_answer.name == esp_host + u'-delegated.local': + print('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(dut): + """ + 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 + 5. check if DUT responds to dig + 6. check the DUT is searchable via reverse IP lookup + """ + + specific_host = dut.expect(r'mdns hostname set to: \[(.*?)\]')[1].decode() + + 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)) + ip_addresses = [] + if dut.app.sdkconfig.get('LWIP_IPV4') is True: + ipv4 = dut.expect(r'IPv4 address: (\d+\.\d+\.\d+\.\d+)[^\d]', + timeout=30)[1].decode() + ip_addresses.append(ipv4) + if dut.app.sdkconfig.get('LWIP_IPV6') is True: + ipv6_r = r':'.join((r'[0-9a-fA-F]{4}', ) * 8) + ipv6 = dut.expect(ipv6_r, timeout=30)[0].decode() + ip_addresses.append(ipv6) + print('Connected with IP addresses: {}'.format(','.join(ip_addresses))) + try: + # TODO: Add test for example disabling IPV4 + mdns_responder.start() + if dut.app.sdkconfig.get('LWIP_IPV4') is True: + # 3. check the mdns name is accessible. + 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 + dut.expect( + re.compile( + b'mdns-test: Query A: tinytester.local resolved to: 127.0.0.1') + ) + dut.expect( + re.compile( + b'mdns-test: gethostbyname: tinytester-lwip.local resolved to: 127.0.0.1' + )) + dut.expect( + re.compile( + b'mdns-test: getaddrinfo: tinytester-lwip.local resolved to: 127.0.0.1' + )) + # 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) + ]) + print('Resolving {} using "dig" succeeded with:\n{}'.format( + specific_host, dig_output)) + if not ipv4.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(ipv4)) + # 6. check the DUT reverse lookup + if dut.app.sdkconfig.get('MDNS_RESPOND_REVERSE_QUERIES') is True: + for ip_address in ip_addresses: + dig_output = subprocess.check_output([ + 'dig', '+short', '-p', '5353', '@224.0.0.251', '-x', + '{}'.format(ip_address) + ]) + print('Reverse lookup for {} using "dig" succeeded with:\n{}'. + format(ip_address, dig_output)) + if specific_host not in dig_output.decode(): + raise ValueError( + 'Test has failed: Incorrectly resolved DUT IP address using dig' + "Output should've contained DUT's name:{}".format( + specific_host)) + + finally: + mdns_server_events['stop'].set() + mdns_responder.join() diff --git a/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_custom_netif b/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_custom_netif new file mode 100644 index 0000000..a8dee3f --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_custom_netif @@ -0,0 +1,21 @@ +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_MDNS_RESPOND_REVERSE_QUERIES=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_PHY_GENERIC=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 diff --git a/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_def b/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_def new file mode 100644 index 0000000..703b454 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/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 diff --git a/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_no_ipv4 b/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_no_ipv4 new file mode 100644 index 0000000..b77a752 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_no_ipv4 @@ -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_LWIP_IPV4=n +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_MDNS_BUTTON_GPIO=32 diff --git a/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_no_ipv6 b/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_no_ipv6 new file mode 100644 index 0000000..d669ec0 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_no_ipv6 @@ -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_LWIP_DNS_SUPPORT_MDNS_QUERIES=y +CONFIG_LWIP_IPV6=n +CONFIG_EXAMPLE_CONNECT_IPV6=n +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_MDNS_BUTTON_GPIO=32 diff --git a/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_socket b/managed_components/espressif__mdns/examples/query_advertise/sdkconfig.ci.eth_socket new file mode 100644 index 0000000..5d92405 --- /dev/null +++ b/managed_components/espressif__mdns/examples/query_advertise/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 diff --git a/managed_components/espressif__mdns/idf_component.yml b/managed_components/espressif__mdns/idf_component.yml new file mode 100644 index 0000000..6465f4d --- /dev/null +++ b/managed_components/espressif__mdns/idf_component.yml @@ -0,0 +1,13 @@ +dependencies: + idf: + version: '>=5.0' +description: Multicast UDP service used to provide local network service and host + discovery. +documentation: https://docs.espressif.com/projects/esp-protocols/mdns/docs/latest/en/index.html +issues: https://github.com/espressif/esp-protocols/issues +repository: git://github.com/espressif/esp-protocols.git +repository_info: + commit_sha: 3bfa00389de6f0d6d40efda8bea808380899a43d + path: components/mdns +url: https://github.com/espressif/esp-protocols/tree/master/components/mdns +version: 1.9.1 diff --git a/managed_components/espressif__mdns/include/mdns.h b/managed_components/espressif__mdns/include/mdns.h new file mode 100644 index 0000000..4c89dde --- /dev/null +++ b/managed_components/espressif__mdns/include/mdns.h @@ -0,0 +1,937 @@ +/* + * SPDX-FileCopyrightText: 2015-2025 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 "sdkconfig.h" +#include + +#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 + +#if defined(CONFIG_LWIP_IPV6) && defined(CONFIG_MDNS_RESPOND_REVERSE_QUERIES) +#define MDNS_NAME_MAX_LEN (64+4) // Need to account for IPv6 reverse queries (64 char address + ".ip6" ) +#else +#define MDNS_NAME_MAX_LEN 64 // Maximum string length of hostname, instance, service and proto +#endif +#define MDNS_NAME_BUF_LEN (MDNS_NAME_MAX_LEN+1) // Maximum char buffer size to hold hostname, instance, service or proto + +/** + * @brief Asynchronous query handle + */ +typedef struct mdns_search_once_s mdns_search_once_t; + +/** + * @brief Daemon query handle + */ +typedef struct mdns_browse_s mdns_browse_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_IP4_REVERSE_LOOKUP = 1 << 7, + MDNS_EVENT_IP6_REVERSE_LOOKUP = 1 << 8, +} 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 basic subtype item structure + * Used in mdns_service_subtype_xxx() APIs + */ +typedef struct { + const char *subtype; /*!< subtype name */ +} mdns_subtype_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); +typedef void (*mdns_browse_notify_t)(mdns_result_t *result); + +/** + * @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 Get the hostname for mDNS server + * + * @param hostname pointer to the hostname, it should be allocated + * and hold at least MDNS_NAME_BUF_LEN chars + * + * @return + * - ESP_OK success + * - ESP_ERR_INVALID_ARG Parameter error + * - ESP_ERR_INVALID_STATE when mdns is not initialized + */ +esp_err_t mdns_hostname_get(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 Set the address to a delegated hostname + * + * @param hostname Hostname to set + * @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_set_address(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 a 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 a 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 remove. + * + * @return + * - ESP_OK success + * - ESP_ERR_INVALID_ARG Parameter error + * - ESP_ERR_NOT_FOUND Service not found + */ +esp_err_t mdns_service_subtype_remove_for_host(const char *instance_name, const char *service_type, const char *proto, + const char *hostname, const char *subtype); + +/** + * @brief Add multiple subtypes for service at once. + * + * @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 pointer of subtype array to add. + * @param num_items number of items in subtype array + * + * @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_multiple_items_for_host(const char *instance_name, const char *service_type, const char *proto, + const char *hostname, mdns_subtype_item_t subtype[], uint8_t num_items); + +/** + * @brief Update 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 pointer of subtype array to add. + * @param num_items number of items in subtype array + * + * @note If `num_items` is 0, then remove all subtypes. + * + * @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_update_multiple_items_for_host(const char *instance_name, const char *service_type, const char *proto, + const char *hostname, mdns_subtype_item_t subtype[], uint8_t num_items); +/** + * @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 Look up delegated services. + * + * @param instance instance name (NULL for uncertain instance) + * @param service_type service type (_http, _ftp, etc) + * @param proto service protocol (_tcp, _udp) + * @param max_results maximum results to be collected + * @param result pointer to the result of the search + * + * @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_lookup_delegated_service(const char *instance, const char *service_type, const char *proto, size_t max_results, + mdns_result_t **result); + +/** + * @brief Look up self hosted services. + * + * @param instance instance name (NULL for uncertain instance) + * @param service_type service type (_http, _ftp, etc) + * @param proto service protocol (_tcp, _udp) + * @param max_results maximum results to be collected + * @param result pointer to the result of the search + * + * @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_lookup_selfhosted_service(const char *instance, const char *service_type, const char *proto, size_t max_results, + 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); + +/** + * @brief Browse mDNS for a service `_service._proto`. + * + * @param service Pointer to the `_service` which will be browsed. + * @param proto Pointer to the `_proto` which will be browsed. + * @param notifier The callback which will be called when the browsing service changed. + * @return mdns_browse_t pointer to new browse object if initiated successfully. + * NULL otherwise. + */ +mdns_browse_t *mdns_browse_new(const char *service, const char *proto, mdns_browse_notify_t notifier); + +/** + * @brief Stop the `_service._proto` browse. + * @param service Pointer to the `_service` which will be browsed. + * @param proto Pointer to the `_proto` which will be browsed. + * @return + * - ESP_OK success. + * - ESP_ERR_FAIL mDNS is not running or the browsing of `_service._proto` is never started. + * - ESP_ERR_NO_MEM memory error. + */ +esp_err_t mdns_browse_delete(const char *service, const char *proto); + +#ifdef __cplusplus +} +#endif + +#endif /* ESP_MDNS_H_ */ diff --git a/managed_components/espressif__mdns/include/mdns_console.h b/managed_components/espressif__mdns/include/mdns_console.h new file mode 100644 index 0000000..cb28eca --- /dev/null +++ b/managed_components/espressif__mdns/include/mdns_console.h @@ -0,0 +1,14 @@ +/* + * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#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_ */ diff --git a/managed_components/espressif__mdns/mdns.c b/managed_components/espressif__mdns/mdns.c new file mode 100644 index 0000000..22cfaf7 --- /dev/null +++ b/managed_components/espressif__mdns/mdns.c @@ -0,0 +1,7869 @@ +/* + * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/queue.h" +#include "freertos/semphr.h" +#include "esp_log.h" +#include "esp_event.h" +#include "esp_random.h" +#include "esp_check.h" +#include "mdns.h" +#include "mdns_private.h" +#include "mdns_networking.h" +#include "mdns_mem_caps.h" + +static void _mdns_browse_item_free(mdns_browse_t *browse); +static esp_err_t _mdns_send_browse_action(mdns_action_type_t type, mdns_browse_t *browse); +static esp_err_t _mdns_sync_browse_action(mdns_action_type_t type, mdns_browse_sync_t *browse_sync); +static void _mdns_browse_sync(mdns_browse_sync_t *browse_sync); +static void _mdns_browse_finish(mdns_browse_t *browse); +static void _mdns_browse_add(mdns_browse_t *browse); +static void _mdns_browse_send(mdns_browse_t *browse, mdns_if_t interface); + +#if CONFIG_ETH_ENABLED && CONFIG_MDNS_PREDEF_NETIF_ETH +#include "esp_eth.h" +#endif + +#if ESP_IDF_VERSION <= ESP_IDF_VERSION_VAL(5, 1, 0) +#define MDNS_ESP_WIFI_ENABLED CONFIG_SOC_WIFI_SUPPORTED +#else +#define MDNS_ESP_WIFI_ENABLED (CONFIG_ESP_WIFI_ENABLED || CONFIG_ESP_WIFI_REMOTE_ENABLED) +#endif + +#if MDNS_ESP_WIFI_ENABLED && (CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP) +#include "esp_wifi.h" +#endif + +#ifdef MDNS_ENABLE_DEBUG +void mdns_debug_packet(const uint8_t *data, size_t len); +#endif + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])) +#endif + +// Internal size of IPv6 address is defined here as size of AAAA record in mdns packet +// since the ip6_addr_t is defined in lwip and depends on using IPv6 zones +#define _MDNS_SIZEOF_IP6_ADDR (MDNS_ANSWER_AAAA_SIZE) + +static const char *MDNS_DEFAULT_DOMAIN = "local"; +static const char *MDNS_SUB_STR = "_sub"; + +mdns_server_t *_mdns_server = NULL; +static mdns_host_item_t *_mdns_host_list = NULL; +static mdns_host_item_t _mdns_self_host; + +static const char *TAG = "mdns"; + +static volatile TaskHandle_t _mdns_service_task_handle = NULL; +static SemaphoreHandle_t _mdns_service_semaphore = NULL; +static StackType_t *_mdns_stack_buffer; + +static void _mdns_search_finish_done(void); +static mdns_search_once_t *_mdns_search_find_from(mdns_search_once_t *search, mdns_name_t *name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); +static mdns_browse_t *_mdns_browse_find_from(mdns_browse_t *b, mdns_name_t *name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); +static void _mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostname, const char *instance, const char *service, const char *proto, + uint16_t port, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl, mdns_browse_sync_t *out_sync_browse); +static void _mdns_browse_result_add_ip(mdns_browse_t *browse, const char *hostname, esp_ip_addr_t *ip, + mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl, mdns_browse_sync_t *out_sync_browse); +static void _mdns_browse_result_add_txt(mdns_browse_t *browse, const char *instance, const char *service, const char *proto, + mdns_txt_item_t *txt, uint8_t *txt_value_len, size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, + uint32_t ttl, mdns_browse_sync_t *out_sync_browse); +#ifdef MDNS_ENABLE_DEBUG +static void debug_printf_browse_result(mdns_result_t *r_t, mdns_browse_t *b_t); +static void debug_printf_browse_result_all(mdns_result_t *r_t); +#endif // MDNS_ENABLE_DEBUG +static void _mdns_search_result_add_ip(mdns_search_once_t *search, const char *hostname, esp_ip_addr_t *ip, + mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl); +static void _mdns_search_result_add_srv(mdns_search_once_t *search, const char *hostname, uint16_t port, + mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl); +static void _mdns_search_result_add_txt(mdns_search_once_t *search, mdns_txt_item_t *txt, uint8_t *txt_value_len, + size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, + uint32_t ttl); +static mdns_result_t *_mdns_search_result_add_ptr(mdns_search_once_t *search, const char *instance, + const char *service_type, const char *proto, mdns_if_t tcpip_if, + mdns_ip_protocol_t ip_protocol, uint32_t ttl); +static bool _mdns_append_host_list_in_services(mdns_out_answer_t **destination, mdns_srv_item_t *services[], size_t services_len, bool flush, bool bye); +static bool _mdns_append_host_list(mdns_out_answer_t **destination, bool flush, bool bye); +static void _mdns_remap_self_service_hostname(const char *old_hostname, const char *new_hostname); +static esp_err_t mdns_post_custom_action_tcpip_if(mdns_if_t mdns_if, mdns_event_actions_t event_action); + +static void _mdns_query_results_free(mdns_result_t *results); +typedef enum { + MDNS_IF_STA = 0, + MDNS_IF_AP = 1, + MDNS_IF_ETH = 2, +} mdns_predef_if_t; + +typedef struct mdns_interfaces mdns_interfaces_t; + +struct mdns_interfaces { + const bool predefined; + esp_netif_t *netif; + const mdns_predef_if_t predef_if; + mdns_if_t duplicate; +}; + +/* + * @brief Internal collection of mdns supported interfaces + * + */ +static mdns_interfaces_t s_esp_netifs[MDNS_MAX_INTERFACES] = { +#if CONFIG_MDNS_PREDEF_NETIF_STA + { .predefined = true, .netif = NULL, .predef_if = MDNS_IF_STA, .duplicate = MDNS_MAX_INTERFACES }, +#endif +#if CONFIG_MDNS_PREDEF_NETIF_AP + { .predefined = true, .netif = NULL, .predef_if = MDNS_IF_AP, .duplicate = MDNS_MAX_INTERFACES }, +#endif +#if CONFIG_MDNS_PREDEF_NETIF_ETH + { .predefined = true, .netif = NULL, .predef_if = MDNS_IF_ETH, .duplicate = MDNS_MAX_INTERFACES }, +#endif +}; + + +/** + * @brief Convert Predefined interface to the netif id from the internal netif list + * @param predef_if Predefined interface enum + * @return Ordinal number of internal list of mdns network interface. + * Returns MDNS_MAX_INTERFACES if the predefined interface wasn't found in the list + */ +static mdns_if_t mdns_if_from_preset_if(mdns_predef_if_t predef_if) +{ + for (int i = 0; i < MDNS_MAX_INTERFACES; ++i) { + if (s_esp_netifs[i].predefined && s_esp_netifs[i].predef_if == predef_if) { + return i; + } + } + return MDNS_MAX_INTERFACES; +} + +/** + * @brief Convert Predefined interface to esp-netif handle + * @param predef_if Predefined interface enum + * @return esp_netif pointer from system list of network interfaces + */ +static inline esp_netif_t *esp_netif_from_preset_if(mdns_predef_if_t predef_if) +{ + switch (predef_if) { + case MDNS_IF_STA: + return esp_netif_get_handle_from_ifkey("WIFI_STA_DEF"); + case MDNS_IF_AP: + return esp_netif_get_handle_from_ifkey("WIFI_AP_DEF"); +#if CONFIG_ETH_ENABLED && CONFIG_MDNS_PREDEF_NETIF_ETH + case MDNS_IF_ETH: + return esp_netif_get_handle_from_ifkey("ETH_DEF"); +#endif + default: + return NULL; + } +} + +/** + * @brief Gets the actual esp_netif pointer from the internal network interface list + * + * The supplied ordinal number could + * - point to a predef netif -> "STA", "AP", "ETH" + * - if no entry in the list (NULL) -> check if the system added this netif + * - point to a custom netif -> just return the entry in the list + * - users is responsible for the lifetime of this netif (to be valid between mdns-init -> deinit) + * + * @param tcpip_if Ordinal number of the interface + * @return Pointer ot the esp_netif object if the interface is available, NULL otherwise + */ +esp_netif_t *_mdns_get_esp_netif(mdns_if_t tcpip_if) +{ + if (tcpip_if < MDNS_MAX_INTERFACES) { + if (s_esp_netifs[tcpip_if].netif == NULL && s_esp_netifs[tcpip_if].predefined) { + // If the local copy is NULL and this netif is predefined -> we can find it in the global netif list + s_esp_netifs[tcpip_if].netif = esp_netif_from_preset_if(s_esp_netifs[tcpip_if].predef_if); + // failing to find it means that the netif is *not* available -> return NULL + } + return s_esp_netifs[tcpip_if].netif; + } + return NULL; +} + + +/* + * @brief Clean internal mdns interface's pointer + */ +static inline void _mdns_clean_netif_ptr(mdns_if_t tcpip_if) +{ + if (tcpip_if < MDNS_MAX_INTERFACES) { + s_esp_netifs[tcpip_if].netif = NULL; + } +} + + +/* + * @brief Convert esp-netif handle to mdns if + */ +static mdns_if_t _mdns_get_if_from_esp_netif(esp_netif_t *esp_netif) +{ + for (int i = 0; i < MDNS_MAX_INTERFACES; ++i) { + // The predefined netifs in the static array are NULL when firstly calling this function + // if IPv4 is disabled. Set these netifs here. + if (s_esp_netifs[i].netif == NULL && s_esp_netifs[i].predefined) { + s_esp_netifs[i].netif = esp_netif_from_preset_if(s_esp_netifs[i].predef_if); + } + if (esp_netif == s_esp_netifs[i].netif) { + return i; + } + } + return MDNS_MAX_INTERFACES; +} + + + +static inline bool _str_null_or_empty(const char *str) +{ + return (str == NULL || *str == 0); +} + +/* + * @brief Appends/increments a number to name/instance in case of collision + * */ +static char *_mdns_mangle_name(char *in) +{ + char *p = strrchr(in, '-'); + int suffix = 0; + if (p == NULL) { + //No - in ``in`` + suffix = 2; + } else { + char *endp = NULL; + suffix = strtol(p + 1, &endp, 10); + if (*endp != 0) { + //suffix is not numerical + suffix = 2; + p = NULL; //so we append -suffix to the entire string + } + } + char *ret; + if (p == NULL) { + //need to add -2 to string + ret = mdns_mem_malloc(strlen(in) + 3); + if (ret == NULL) { + HOOK_MALLOC_FAILED; + return NULL; + } + sprintf(ret, "%s-2", in); + } else { + size_t in_len = strlen(in); + ret = mdns_mem_malloc(in_len + 2); //one extra byte in case 9-10 or 99-100 etc + if (ret == NULL) { + HOOK_MALLOC_FAILED; + return NULL; + } + memcpy(ret, in, in_len); + int baseLen = p - in; //length of 'bla' in 'bla-123' + //overwrite suffix with new suffix + sprintf(ret + baseLen, "-%d", suffix + 1); + } + return ret; +} + +static bool _mdns_service_match(const mdns_service_t *srv, const char *service, const char *proto, + const char *hostname) +{ + if (!service || !proto || !srv->hostname) { + return false; + } + return !strcasecmp(srv->service, service) && !strcasecmp(srv->proto, proto) && + (_str_null_or_empty(hostname) || !strcasecmp(srv->hostname, hostname)); +} + +/** + * @brief finds service from given service type + * @param server the server + * @param service service type to match + * @param proto proto to match + * @param hostname hostname of the service (if non-null) + * + * @return the service item if found or NULL on error + */ +static mdns_srv_item_t *_mdns_get_service_item(const char *service, const char *proto, const char *hostname) +{ + mdns_srv_item_t *s = _mdns_server->services; + while (s) { + if (_mdns_service_match(s->service, service, proto, hostname)) { + return s; + } + s = s->next; + } + return NULL; +} + +static mdns_srv_item_t *_mdns_get_service_item_subtype(const char *subtype, const char *service, const char *proto) +{ + mdns_srv_item_t *s = _mdns_server->services; + while (s) { + if (_mdns_service_match(s->service, service, proto, NULL)) { + mdns_subtype_t *subtype_item = s->service->subtype; + while (subtype_item) { + if (!strcasecmp(subtype_item->subtype, subtype)) { + return s; + } + subtype_item = subtype_item->next; + } + } + s = s->next; + } + return NULL; +} + +static mdns_host_item_t *mdns_get_host_item(const char *hostname) +{ + if (hostname == NULL || strcasecmp(hostname, _mdns_server->hostname) == 0) { + return &_mdns_self_host; + } + mdns_host_item_t *host = _mdns_host_list; + while (host != NULL) { + if (strcasecmp(host->hostname, hostname) == 0) { + return host; + } + host = host->next; + } + return NULL; +} + +static bool _mdns_can_add_more_services(void) +{ +#if MDNS_MAX_SERVICES == 0 + return false; +#else + mdns_srv_item_t *s = _mdns_server->services; + uint16_t service_num = 0; + while (s) { + service_num ++; + s = s->next; + if (service_num >= MDNS_MAX_SERVICES) { + return false; + } + } + return true; +#endif +} + +esp_err_t _mdns_send_rx_action(mdns_rx_packet_t *packet) +{ + mdns_action_t *action = NULL; + + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + return ESP_ERR_NO_MEM; + } + + action->type = ACTION_RX_HANDLE; + action->data.rx_handle.packet = packet; + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + return ESP_OK; +} + +static const char *_mdns_get_default_instance_name(void) +{ + if (_mdns_server && !_str_null_or_empty(_mdns_server->instance)) { + return _mdns_server->instance; + } + + if (_mdns_server && !_str_null_or_empty(_mdns_server->hostname)) { + return _mdns_server->hostname; + } + + return NULL; +} + +/** + * @brief Get the service name of a service + */ +static const char *_mdns_get_service_instance_name(const mdns_service_t *service) +{ + if (service && !_str_null_or_empty(service->instance)) { + return service->instance; + } + + return _mdns_get_default_instance_name(); +} + +static bool _mdns_instance_name_match(const char *lhs, const char *rhs) +{ + if (lhs == NULL) { + lhs = _mdns_get_default_instance_name(); + } + if (rhs == NULL) { + rhs = _mdns_get_default_instance_name(); + } + return !strcasecmp(lhs, rhs); +} + +static bool _mdns_service_match_instance(const mdns_service_t *srv, const char *instance, const char *service, + const char *proto, const char *hostname) +{ + // service and proto must be supplied, if not this instance won't match + if (!service || !proto) { + return false; + } + // instance==NULL -> _mdns_instance_name_match() will check the default instance + // hostname==NULL -> matches if instance, service and proto matches + return !strcasecmp(srv->service, service) && _mdns_instance_name_match(srv->instance, instance) && + !strcasecmp(srv->proto, proto) && (_str_null_or_empty(hostname) || !strcasecmp(srv->hostname, hostname)); +} + +static mdns_srv_item_t *_mdns_get_service_item_instance(const char *instance, const char *service, const char *proto, + const char *hostname) +{ + mdns_srv_item_t *s = _mdns_server->services; + while (s) { + if (instance) { + if (_mdns_service_match_instance(s->service, instance, service, proto, hostname)) { + return s; + } + } else { + if (_mdns_service_match(s->service, service, proto, hostname)) { + return s; + } + } + s = s->next; + } + return NULL; +} + +/** + * @brief reads MDNS FQDN into mdns_name_t structure + * FQDN is in format: [hostname.|[instance.]_service._proto.]local. + * + * @param packet MDNS packet + * @param start Starting point of FQDN + * @param name mdns_name_t structure to populate + * @param buf temporary char buffer + * + * @return the address after the parsed FQDN in the packet or NULL on error + */ +static const uint8_t *_mdns_read_fqdn(const uint8_t *packet, const uint8_t *start, mdns_name_t *name, char *buf, size_t packet_len) +{ + size_t index = 0; + const uint8_t *packet_end = packet + packet_len; + while (start + index < packet_end && start[index]) { + if (name->parts == 4) { + name->invalid = true; + } + uint8_t len = start[index++]; + if (len < 0xC0) { + if (len > 63) { + //length can not be more than 63 + return NULL; + } + uint8_t i; + for (i = 0; i < len; i++) { + if (start + index >= packet_end) { + return NULL; + } + buf[i] = start[index++]; + } + buf[len] = '\0'; + if (name->parts == 1 && buf[0] != '_' + && (strcasecmp(buf, MDNS_DEFAULT_DOMAIN) != 0) + && (strcasecmp(buf, "arpa") != 0) +#ifndef CONFIG_MDNS_RESPOND_REVERSE_QUERIES + && (strcasecmp(buf, "ip6") != 0) + && (strcasecmp(buf, "in-addr") != 0) +#endif + ) { + strlcat(name->host, ".", sizeof(name->host)); + strlcat(name->host, buf, sizeof(name->host)); + } else if (strcasecmp(buf, MDNS_SUB_STR) == 0) { + name->sub = 1; + } else if (!name->invalid) { + char *mdns_name_ptrs[] = {name->host, name->service, name->proto, name->domain}; + memcpy(mdns_name_ptrs[name->parts++], buf, len + 1); + } + } else { + size_t address = (((uint16_t)len & 0x3F) << 8) | start[index++]; + if ((packet + address) >= start) { + //reference address can not be after where we are + return NULL; + } + if (_mdns_read_fqdn(packet, packet + address, name, buf, packet_len)) { + return start + index; + } + return NULL; + } + } + return start + index + 1; +} + +/** + * @brief sets uint16_t value in a packet + * + * @param packet MDNS packet + * @param index offset of uint16_t value + * @param value the value to set + */ +static inline void _mdns_set_u16(uint8_t *packet, uint16_t index, uint16_t value) +{ + if ((index + 1) >= MDNS_MAX_PACKET_SIZE) { + return; + } + packet[index] = (value >> 8) & 0xFF; + packet[index + 1] = value & 0xFF; +} + +/** + * @brief appends byte in a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param value the value to set + * + * @return length of added data: 0 on error or 1 on success + */ +static inline uint8_t _mdns_append_u8(uint8_t *packet, uint16_t *index, uint8_t value) +{ + if (*index >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + packet[*index] = value; + *index += 1; + return 1; +} + +/** + * @brief appends uint16_t in a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param value the value to set + * + * @return length of added data: 0 on error or 2 on success + */ +static inline uint8_t _mdns_append_u16(uint8_t *packet, uint16_t *index, uint16_t value) +{ + if ((*index + 1) >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + _mdns_append_u8(packet, index, (value >> 8) & 0xFF); + _mdns_append_u8(packet, index, value & 0xFF); + return 2; +} + +/** + * @brief appends uint32_t in a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param value the value to set + * + * @return length of added data: 0 on error or 4 on success + */ +static inline uint8_t _mdns_append_u32(uint8_t *packet, uint16_t *index, uint32_t value) +{ + if ((*index + 3) >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + _mdns_append_u8(packet, index, (value >> 24) & 0xFF); + _mdns_append_u8(packet, index, (value >> 16) & 0xFF); + _mdns_append_u8(packet, index, (value >> 8) & 0xFF); + _mdns_append_u8(packet, index, value & 0xFF); + return 4; +} + +/** + * @brief appends answer type, class, ttl and data length to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param type answer type + * @param ttl answer ttl + * + * @return length of added data: 0 on error or 10 on success + */ +static inline uint8_t _mdns_append_type(uint8_t *packet, uint16_t *index, uint8_t type, bool flush, uint32_t ttl) +{ + if ((*index + 10) >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + uint16_t mdns_class = MDNS_CLASS_IN; + if (flush) { + mdns_class = MDNS_CLASS_IN_FLUSH_CACHE; + } + if (type == MDNS_ANSWER_PTR) { + _mdns_append_u16(packet, index, MDNS_TYPE_PTR); + _mdns_append_u16(packet, index, mdns_class); + } else if (type == MDNS_ANSWER_TXT) { + _mdns_append_u16(packet, index, MDNS_TYPE_TXT); + _mdns_append_u16(packet, index, mdns_class); + } else if (type == MDNS_ANSWER_SRV) { + _mdns_append_u16(packet, index, MDNS_TYPE_SRV); + _mdns_append_u16(packet, index, mdns_class); + } else if (type == MDNS_ANSWER_A) { + _mdns_append_u16(packet, index, MDNS_TYPE_A); + _mdns_append_u16(packet, index, mdns_class); + } else if (type == MDNS_ANSWER_AAAA) { + _mdns_append_u16(packet, index, MDNS_TYPE_AAAA); + _mdns_append_u16(packet, index, mdns_class); + } else { + return 0; + } + _mdns_append_u32(packet, index, ttl); + _mdns_append_u16(packet, index, 0); + return 10; +} + +static inline uint8_t _mdns_append_string_with_len(uint8_t *packet, uint16_t *index, const char *string, uint8_t len) +{ + if ((*index + len + 1) >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + _mdns_append_u8(packet, index, len); + memcpy(packet + *index, string, len); + *index += len; + return len + 1; +} + +/** + * @brief appends single string to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param string the string to append + * + * @return length of added data: 0 on error or length of the string + 1 on success + */ +static inline uint8_t _mdns_append_string(uint8_t *packet, uint16_t *index, const char *string) +{ + uint8_t len = strlen(string); + if ((*index + len + 1) >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + _mdns_append_u8(packet, index, len); + memcpy(packet + *index, string, len); + *index += len; + return len + 1; +} + +/** + * @brief appends one TXT record ("key=value" or "key") + * + * @param packet MDNS packet + * @param index offset in the packet + * @param txt one txt record + * + * @return length of added data: length of the added txt value + 1 on success + * 0 if data won't fit the packet + * -1 if invalid TXT entry + */ +static inline int append_one_txt_record_entry(uint8_t *packet, uint16_t *index, mdns_txt_linked_item_t *txt) +{ + if (txt == NULL || txt->key == NULL) { + return -1; + } + size_t key_len = strlen(txt->key); + size_t len = key_len + txt->value_len + (txt->value ? 1 : 0); + if ((*index + len + 1) >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + _mdns_append_u8(packet, index, len); + memcpy(packet + *index, txt->key, key_len); + if (txt->value) { + packet[*index + key_len] = '='; + memcpy(packet + *index + key_len + 1, txt->value, txt->value_len); + } + *index += len; + return len + 1; +} + +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES +static inline int append_single_str(uint8_t *packet, uint16_t *index, const char *str, int len) +{ + if ((*index + len + 1) >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + if (!_mdns_append_u8(packet, index, len)) { + return 0; + } + memcpy(packet + *index, str, len); + *index += len; + return *index; +} + +/** + * @brief appends FQDN to a packet from hostname separated by dots. This API works the same way as + * _mdns_append_fqdn(), but refrains from DNS compression (as it's mainly used for IP addresses (many short items), + * where we gain very little (or compression even gets counter-productive mainly for IPv6 addresses) + * + * @param packet MDNS packet + * @param index offset in the packet + * @param name name representing FQDN in '.' separated parts + * @param last true if appending the last part (domain, typically "arpa") + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t append_fqdn_dots(uint8_t *packet, uint16_t *index, const char *name, bool last) +{ + int len = strlen(name); + char *host = (char *)name; + char *end = host; + char *start = host; + do { + end = memchr(start, '.', host + len - start); + end = end ? end : host + len; + int part_len = end - start; + if (!append_single_str(packet, index, start, part_len)) { + return 0; + } + start = ++end; + } while (end < name + len); + + if (!append_single_str(packet, index, "arpa", sizeof("arpa") - 1)) { + return 0; + } + + //empty string so terminate + if (!_mdns_append_u8(packet, index, 0)) { + return 0; + } + return *index; +} +#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ + +/** + * @brief appends FQDN to a packet, incrementing the index and + * compressing the output if previous occurrence of the string (or part of it) has been found + * + * @param packet MDNS packet + * @param index offset in the packet + * @param strings string array containing the parts of the FQDN + * @param count number of strings in the array + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t _mdns_append_fqdn(uint8_t *packet, uint16_t *index, const char *strings[], uint8_t count, size_t packet_len) +{ + if (!count) { + //empty string so terminate + return _mdns_append_u8(packet, index, 0); + } + static char buf[MDNS_NAME_BUF_LEN]; + uint8_t len = strlen(strings[0]); + //try to find first the string length in the packet (if it exists) + uint8_t *len_location = (uint8_t *)memchr(packet, (char)len, *index); + while (len_location) { + mdns_name_t name; + //check if the string after len_location is the string that we are looking for + if (memcmp(len_location + 1, strings[0], len)) { //not continuing with our string +search_next: + //try and find the length byte further in the packet + len_location = (uint8_t *)memchr(len_location + 1, (char)len, *index - (len_location + 1 - packet)); + continue; + } + //seems that we might have found the string that we are looking for + //read the destination into name and compare + name.parts = 0; + name.sub = 0; + name.invalid = false; + name.host[0] = 0; + name.service[0] = 0; + name.proto[0] = 0; + name.domain[0] = 0; + const uint8_t *content = _mdns_read_fqdn(packet, len_location, &name, buf, packet_len); + if (!content) { + //not a readable fqdn? + goto search_next; // could be our unfinished fqdn, continue searching + } + if (name.parts == count) { + uint8_t i; + for (i = 0; i < count; i++) { + if (strcasecmp(strings[i], (const char *)&name + (i * (MDNS_NAME_BUF_LEN)))) { + //not our string! let's search more + goto search_next; + } + } + //we actually have found the string + break; + } else { + goto search_next; + } + } + //string is not yet in the packet, so let's add it + if (!len_location) { + uint8_t written = _mdns_append_string(packet, index, strings[0]); + if (!written) { + return 0; + } + //run the same for the other strings in the name + return written + _mdns_append_fqdn(packet, index, &strings[1], count - 1, packet_len); + } + + //we have found the string so let's insert a pointer to it instead + uint16_t offset = len_location - packet; + offset |= MDNS_NAME_REF; + return _mdns_append_u16(packet, index, offset); +} + +/** + * @brief appends PTR record for service to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param server the server that is hosting the service + * @param service the service to add record for + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t _mdns_append_ptr_record(uint8_t *packet, uint16_t *index, const char *instance, const char *service, const char *proto, bool flush, bool bye) +{ + const char *str[4]; + uint16_t record_length = 0; + uint8_t part_length; + + if (service == NULL) { + return 0; + } + + str[0] = instance; + str[1] = service; + str[2] = proto; + str[3] = MDNS_DEFAULT_DOMAIN; + + part_length = _mdns_append_fqdn(packet, index, str + 1, 3, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + record_length += part_length; + + part_length = _mdns_append_type(packet, index, MDNS_ANSWER_PTR, false, bye ? 0 : MDNS_ANSWER_PTR_TTL); + if (!part_length) { + return 0; + } + record_length += part_length; + + uint16_t data_len_location = *index - 2; + part_length = _mdns_append_fqdn(packet, index, str, 4, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + _mdns_set_u16(packet, data_len_location, part_length); + record_length += part_length; + return record_length; +} + +/** + * @brief appends PTR record for a subtype to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param instance the service instance name + * @param subtype the service subtype + * @param proto the service protocol + * @param flush whether to set the flush flag + * @param bye whether to set the bye flag + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t _mdns_append_subtype_ptr_record(uint8_t *packet, uint16_t *index, const char *instance, + const char *subtype, const char *service, const char *proto, bool flush, + bool bye) +{ + const char *subtype_str[5] = {subtype, MDNS_SUB_STR, service, proto, MDNS_DEFAULT_DOMAIN}; + const char *instance_str[4] = {instance, service, proto, MDNS_DEFAULT_DOMAIN}; + uint16_t record_length = 0; + uint8_t part_length; + + if (service == NULL) { + return 0; + } + + part_length = _mdns_append_fqdn(packet, index, subtype_str, ARRAY_SIZE(subtype_str), MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + record_length += part_length; + + part_length = _mdns_append_type(packet, index, MDNS_ANSWER_PTR, false, bye ? 0 : MDNS_ANSWER_PTR_TTL); + if (!part_length) { + return 0; + } + record_length += part_length; + + uint16_t data_len_location = *index - 2; + part_length = _mdns_append_fqdn(packet, index, instance_str, ARRAY_SIZE(instance_str), MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + _mdns_set_u16(packet, data_len_location, part_length); + record_length += part_length; + return record_length; +} + +/** + * @brief appends DNS-SD PTR record for service to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param server the server that is hosting the service + * @param service the service to add record for + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t _mdns_append_sdptr_record(uint8_t *packet, uint16_t *index, mdns_service_t *service, bool flush, bool bye) +{ + const char *str[3]; + const char *sd_str[4]; + uint16_t record_length = 0; + uint8_t part_length; + + if (service == NULL) { + return 0; + } + + sd_str[0] = (char *)"_services"; + sd_str[1] = (char *)"_dns-sd"; + sd_str[2] = (char *)"_udp"; + sd_str[3] = MDNS_DEFAULT_DOMAIN; + + str[0] = service->service; + str[1] = service->proto; + str[2] = MDNS_DEFAULT_DOMAIN; + + part_length = _mdns_append_fqdn(packet, index, sd_str, 4, MDNS_MAX_PACKET_SIZE); + + record_length += part_length; + + part_length = _mdns_append_type(packet, index, MDNS_ANSWER_PTR, flush, MDNS_ANSWER_PTR_TTL); + if (!part_length) { + return 0; + } + record_length += part_length; + + uint16_t data_len_location = *index - 2; + part_length = _mdns_append_fqdn(packet, index, str, 3, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + _mdns_set_u16(packet, data_len_location, part_length); + record_length += part_length; + return record_length; +} + +/** + * @brief appends TXT record for service to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param server the server that is hosting the service + * @param service the service to add record for + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t _mdns_append_txt_record(uint8_t *packet, uint16_t *index, mdns_service_t *service, bool flush, bool bye) +{ + const char *str[4]; + uint16_t record_length = 0; + uint8_t part_length; + + if (service == NULL) { + return 0; + } + + str[0] = _mdns_get_service_instance_name(service); + str[1] = service->service; + str[2] = service->proto; + str[3] = MDNS_DEFAULT_DOMAIN; + + if (!str[0]) { + return 0; + } + + part_length = _mdns_append_fqdn(packet, index, str, 4, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + record_length += part_length; + + part_length = _mdns_append_type(packet, index, MDNS_ANSWER_TXT, flush, bye ? 0 : MDNS_ANSWER_TXT_TTL); + if (!part_length) { + return 0; + } + record_length += part_length; + + uint16_t data_len_location = *index - 2; + uint16_t data_len = 0; + + mdns_txt_linked_item_t *txt = service->txt; + while (txt) { + int l = append_one_txt_record_entry(packet, index, txt); + if (l > 0) { + data_len += l; + } else if (l == 0) { // TXT entry won't fit into the mdns packet + return 0; + } + txt = txt->next; + } + if (!data_len) { + data_len = 1; + packet[*index] = 0; + *index = *index + 1; + } + _mdns_set_u16(packet, data_len_location, data_len); + record_length += data_len; + return record_length; +} + +/** + * @brief appends SRV record for service to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param server the server that is hosting the service + * @param service the service to add record for + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t _mdns_append_srv_record(uint8_t *packet, uint16_t *index, mdns_service_t *service, bool flush, bool bye) +{ + const char *str[4]; + uint16_t record_length = 0; + uint8_t part_length; + + if (service == NULL) { + return 0; + } + + str[0] = _mdns_get_service_instance_name(service); + str[1] = service->service; + str[2] = service->proto; + str[3] = MDNS_DEFAULT_DOMAIN; + + if (!str[0]) { + return 0; + } + + part_length = _mdns_append_fqdn(packet, index, str, 4, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + record_length += part_length; + + part_length = _mdns_append_type(packet, index, MDNS_ANSWER_SRV, flush, bye ? 0 : MDNS_ANSWER_SRV_TTL); + if (!part_length) { + return 0; + } + record_length += part_length; + + uint16_t data_len_location = *index - 2; + + part_length = 0; + part_length += _mdns_append_u16(packet, index, service->priority); + part_length += _mdns_append_u16(packet, index, service->weight); + part_length += _mdns_append_u16(packet, index, service->port); + if (part_length != 6) { + return 0; + } + + if (service->hostname) { + str[0] = service->hostname; + } else { + str[0] = _mdns_server->hostname; + } + str[1] = MDNS_DEFAULT_DOMAIN; + + if (_str_null_or_empty(str[0])) { + return 0; + } + + part_length = _mdns_append_fqdn(packet, index, str, 2, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + _mdns_set_u16(packet, data_len_location, part_length + 6); + + record_length += part_length + 6; + return record_length; +} + +#ifdef CONFIG_LWIP_IPV4 +/** + * @brief appends A record to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param hostname the hostname address to add + * @param ip the IP address to add + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t _mdns_append_a_record(uint8_t *packet, uint16_t *index, const char *hostname, uint32_t ip, bool flush, bool bye) +{ + const char *str[2]; + uint16_t record_length = 0; + uint8_t part_length; + + str[0] = hostname; + str[1] = MDNS_DEFAULT_DOMAIN; + + if (_str_null_or_empty(str[0])) { + return 0; + } + + part_length = _mdns_append_fqdn(packet, index, str, 2, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + record_length += part_length; + + part_length = _mdns_append_type(packet, index, MDNS_ANSWER_A, flush, bye ? 0 : MDNS_ANSWER_A_TTL); + if (!part_length) { + return 0; + } + record_length += part_length; + + uint16_t data_len_location = *index - 2; + + if ((*index + 3) >= MDNS_MAX_PACKET_SIZE) { + return 0; + } + _mdns_append_u8(packet, index, ip & 0xFF); + _mdns_append_u8(packet, index, (ip >> 8) & 0xFF); + _mdns_append_u8(packet, index, (ip >> 16) & 0xFF); + _mdns_append_u8(packet, index, (ip >> 24) & 0xFF); + _mdns_set_u16(packet, data_len_location, 4); + + record_length += 4; + return record_length; +} +#endif /* CONFIG_LWIP_IPV4 */ + +#ifdef CONFIG_LWIP_IPV6 +/** + * @brief appends AAAA record to a packet, incrementing the index + * + * @param packet MDNS packet + * @param index offset in the packet + * @param hostname the hostname address to add + * @param ipv6 the IPv6 address to add + * + * @return length of added data: 0 on error or length on success + */ +static uint16_t _mdns_append_aaaa_record(uint8_t *packet, uint16_t *index, const char *hostname, uint8_t *ipv6, bool flush, bool bye) +{ + const char *str[2]; + uint16_t record_length = 0; + uint8_t part_length; + + str[0] = hostname; + str[1] = MDNS_DEFAULT_DOMAIN; + + if (_str_null_or_empty(str[0])) { + return 0; + } + + + part_length = _mdns_append_fqdn(packet, index, str, 2, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + record_length += part_length; + + part_length = _mdns_append_type(packet, index, MDNS_ANSWER_AAAA, flush, bye ? 0 : MDNS_ANSWER_AAAA_TTL); + if (!part_length) { + return 0; + } + record_length += part_length; + + uint16_t data_len_location = *index - 2; + + if ((*index + MDNS_ANSWER_AAAA_SIZE) > MDNS_MAX_PACKET_SIZE) { + return 0; + } + + part_length = MDNS_ANSWER_AAAA_SIZE; + memcpy(packet + *index, ipv6, part_length); + *index += part_length; + _mdns_set_u16(packet, data_len_location, part_length); + record_length += part_length; + return record_length; +} +#endif + +/** + * @brief Append question to packet + */ +static uint16_t _mdns_append_question(uint8_t *packet, uint16_t *index, mdns_out_question_t *q) +{ + uint8_t part_length; +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES + if (q->host && (strstr(q->host, "in-addr") || strstr(q->host, "ip6"))) { + part_length = append_fqdn_dots(packet, index, q->host, false); + if (!part_length) { + return 0; + } + } else +#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ + { + const char *str[4]; + uint8_t str_index = 0; + if (q->host) { + str[str_index++] = q->host; + } + if (q->service) { + str[str_index++] = q->service; + } + if (q->proto) { + str[str_index++] = q->proto; + } + if (q->domain) { + str[str_index++] = q->domain; + } + part_length = _mdns_append_fqdn(packet, index, str, str_index, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + } + + part_length += _mdns_append_u16(packet, index, q->type); + part_length += _mdns_append_u16(packet, index, q->unicast ? 0x8001 : 0x0001); + return part_length; +} + +/** + * @brief Helper to get either ETH or STA if the other is provided + * Used when two interfaces are on the same subnet + */ +static mdns_if_t _mdns_get_other_if(mdns_if_t tcpip_if) +{ + if (tcpip_if < MDNS_MAX_INTERFACES) { + return s_esp_netifs[tcpip_if].duplicate; + } + return MDNS_MAX_INTERFACES; +} + +/** + * @brief Check if interface is duplicate (two interfaces on the same subnet) + */ +static bool _mdns_if_is_dup(mdns_if_t tcpip_if) +{ + mdns_if_t other_if = _mdns_get_other_if(tcpip_if); + if (other_if == MDNS_MAX_INTERFACES) { + return false; + } + if (_mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].state == PCB_DUP + || _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].state == PCB_DUP + || _mdns_server->interfaces[other_if].pcbs[MDNS_IP_PROTOCOL_V4].state == PCB_DUP + || _mdns_server->interfaces[other_if].pcbs[MDNS_IP_PROTOCOL_V6].state == PCB_DUP + ) { + return true; + } + return false; +} + +#ifdef CONFIG_LWIP_IPV6 +/** + * @brief Check if IPv6 address is NULL + */ +static bool _ipv6_address_is_zero(esp_ip6_addr_t ip6) +{ + uint8_t i; + uint8_t *data = (uint8_t *)ip6.addr; + for (i = 0; i < _MDNS_SIZEOF_IP6_ADDR; i++) { + if (data[i]) { + return false; + } + } + return true; +} +#endif /* CONFIG_LWIP_IPV6 */ + +static uint8_t _mdns_append_host_answer(uint8_t *packet, uint16_t *index, mdns_host_item_t *host, + uint8_t address_type, bool flush, bool bye) +{ + mdns_ip_addr_t *addr = host->address_list; + uint8_t num_records = 0; + + while (addr != NULL) { + if (addr->addr.type == address_type) { +#ifdef CONFIG_LWIP_IPV4 + if (address_type == ESP_IPADDR_TYPE_V4 && + _mdns_append_a_record(packet, index, host->hostname, addr->addr.u_addr.ip4.addr, flush, bye) <= 0) { + break; + } +#endif /* CONFIG_LWIP_IPV4 */ +#ifdef CONFIG_LWIP_IPV6 + if (address_type == ESP_IPADDR_TYPE_V6 && + _mdns_append_aaaa_record(packet, index, host->hostname, (uint8_t *)addr->addr.u_addr.ip6.addr, flush, + bye) <= 0) { + break; + } +#endif /* CONFIG_LWIP_IPV6 */ + num_records++; + } + addr = addr->next; + } + return num_records; +} + +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES +/** + * @brief Appends reverse lookup PTR record + */ +static uint8_t _mdns_append_reverse_ptr_record(uint8_t *packet, uint16_t *index, const char *name) +{ + if (strstr(name, "in-addr") == NULL && strstr(name, "ip6") == NULL) { + return 0; + } + + if (!append_fqdn_dots(packet, index, name, false)) { + return 0; + } + + if (!_mdns_append_type(packet, index, MDNS_ANSWER_PTR, false, 10 /* TTL set to 10s*/)) { + return 0; + } + + uint16_t data_len_location = *index - 2; /* store the position of size (2=16bis) of this record */ + const char *str[2] = { _mdns_self_host.hostname, MDNS_DEFAULT_DOMAIN }; + + int part_length = _mdns_append_fqdn(packet, index, str, 2, MDNS_MAX_PACKET_SIZE); + if (!part_length) { + return 0; + } + + _mdns_set_u16(packet, data_len_location, part_length); + return 1; /* appending only 1 record */ +} +#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ + +/** + * @brief Append PTR answers to packet + * + * @return number of answers added to the packet + */ +static uint8_t _mdns_append_service_ptr_answers(uint8_t *packet, uint16_t *index, mdns_service_t *service, bool flush, + bool bye) +{ + uint8_t appended_answers = 0; + + if (_mdns_append_ptr_record(packet, index, _mdns_get_service_instance_name(service), service->service, + service->proto, flush, bye) <= 0) { + return appended_answers; + } + appended_answers++; + + mdns_subtype_t *subtype = service->subtype; + while (subtype) { + appended_answers += + (_mdns_append_subtype_ptr_record(packet, index, _mdns_get_service_instance_name(service), subtype->subtype, + service->service, service->proto, flush, bye) > 0); + subtype = subtype->next; + } + + return appended_answers; +} + + +/** + * @brief Append answer to packet + * + * @return number of answers added to the packet + */ +static uint8_t _mdns_append_answer(uint8_t *packet, uint16_t *index, mdns_out_answer_t *answer, mdns_if_t tcpip_if) +{ + if (answer->host) { + bool is_host_valid = (&_mdns_self_host == answer->host); + mdns_host_item_t *target_host = _mdns_host_list; + while (target_host && !is_host_valid) { + if (target_host == answer->host) { + is_host_valid = true; + } + target_host = target_host->next; + } + if (!is_host_valid) { + return 0; + } + } + + if (answer->type == MDNS_TYPE_PTR) { + if (answer->service) { + return _mdns_append_service_ptr_answers(packet, index, answer->service, answer->flush, answer->bye); +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES + } else if (answer->host && answer->host->hostname && + (strstr(answer->host->hostname, "in-addr") || strstr(answer->host->hostname, "ip6"))) { + return _mdns_append_reverse_ptr_record(packet, index, answer->host->hostname) > 0; +#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ + } else { + return _mdns_append_ptr_record(packet, index, + answer->custom_instance, answer->custom_service, answer->custom_proto, + answer->flush, answer->bye) > 0; + } + } else if (answer->type == MDNS_TYPE_SRV) { + return _mdns_append_srv_record(packet, index, answer->service, answer->flush, answer->bye) > 0; + } else if (answer->type == MDNS_TYPE_TXT) { + return _mdns_append_txt_record(packet, index, answer->service, answer->flush, answer->bye) > 0; + } else if (answer->type == MDNS_TYPE_SDPTR) { + return _mdns_append_sdptr_record(packet, index, answer->service, answer->flush, answer->bye) > 0; + } +#ifdef CONFIG_LWIP_IPV4 + else if (answer->type == MDNS_TYPE_A) { + if (answer->host == &_mdns_self_host) { + esp_netif_ip_info_t if_ip_info; + if (!mdns_is_netif_ready(tcpip_if, MDNS_IP_PROTOCOL_V4) && _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V4].state != PCB_DUP) { + return 0; + } + if (esp_netif_get_ip_info(_mdns_get_esp_netif(tcpip_if), &if_ip_info)) { + return 0; + } + if (_mdns_append_a_record(packet, index, _mdns_server->hostname, if_ip_info.ip.addr, answer->flush, answer->bye) <= 0) { + return 0; + } + if (!_mdns_if_is_dup(tcpip_if)) { + return 1; + } + mdns_if_t other_if = _mdns_get_other_if(tcpip_if); + if (esp_netif_get_ip_info(_mdns_get_esp_netif(other_if), &if_ip_info)) { + return 1; + } + if (_mdns_append_a_record(packet, index, _mdns_server->hostname, if_ip_info.ip.addr, answer->flush, answer->bye) > 0) { + return 2; + } + return 1; + } else if (answer->host != NULL) { + return _mdns_append_host_answer(packet, index, answer->host, ESP_IPADDR_TYPE_V4, answer->flush, answer->bye); + } + } +#endif /* CONFIG_LWIP_IPV4 */ +#ifdef CONFIG_LWIP_IPV6 + else if (answer->type == MDNS_TYPE_AAAA) { + if (answer->host == &_mdns_self_host) { + struct esp_ip6_addr if_ip6s[NETIF_IPV6_MAX_NUMS]; + uint8_t count = 0; + if (!mdns_is_netif_ready(tcpip_if, MDNS_IP_PROTOCOL_V6) && _mdns_server->interfaces[tcpip_if].pcbs[MDNS_IP_PROTOCOL_V6].state != PCB_DUP) { + return 0; + } + count = esp_netif_get_all_ip6(_mdns_get_esp_netif(tcpip_if), if_ip6s); + assert(count <= NETIF_IPV6_MAX_NUMS); + for (int i = 0; i < count; i++) { + if (_ipv6_address_is_zero(if_ip6s[i])) { + return 0; + } + if (_mdns_append_aaaa_record(packet, index, _mdns_server->hostname, (uint8_t *)if_ip6s[i].addr, + answer->flush, answer->bye) <= 0) { + return 0; + } + } + if (!_mdns_if_is_dup(tcpip_if)) { + return count; + } + + mdns_if_t other_if = _mdns_get_other_if(tcpip_if); + struct esp_ip6_addr other_ip6; + if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(other_if), &other_ip6)) { + return count; + } + if (_mdns_append_aaaa_record(packet, index, _mdns_server->hostname, (uint8_t *)other_ip6.addr, + answer->flush, answer->bye) > 0) { + return 1 + count; + } + return count; + } else if (answer->host != NULL) { + return _mdns_append_host_answer(packet, index, answer->host, ESP_IPADDR_TYPE_V6, answer->flush, + answer->bye); + } + } +#endif /* CONFIG_LWIP_IPV6 */ + return 0; +} + +/** + * @brief sends a packet + * + * @param p the packet + */ +static void _mdns_dispatch_tx_packet(mdns_tx_packet_t *p) +{ + static uint8_t packet[MDNS_MAX_PACKET_SIZE]; + uint16_t index = MDNS_HEAD_LEN; + memset(packet, 0, MDNS_HEAD_LEN); + mdns_out_question_t *q; + mdns_out_answer_t *a; + uint8_t count; + + _mdns_set_u16(packet, MDNS_HEAD_FLAGS_OFFSET, p->flags); + _mdns_set_u16(packet, MDNS_HEAD_ID_OFFSET, p->id); + + count = 0; + q = p->questions; + while (q) { + if (_mdns_append_question(packet, &index, q)) { + count++; + } + q = q->next; + } + _mdns_set_u16(packet, MDNS_HEAD_QUESTIONS_OFFSET, count); + + count = 0; + a = p->answers; + while (a) { + count += _mdns_append_answer(packet, &index, a, p->tcpip_if); + a = a->next; + } + _mdns_set_u16(packet, MDNS_HEAD_ANSWERS_OFFSET, count); + + count = 0; + a = p->servers; + while (a) { + count += _mdns_append_answer(packet, &index, a, p->tcpip_if); + a = a->next; + } + _mdns_set_u16(packet, MDNS_HEAD_SERVERS_OFFSET, count); + + count = 0; + a = p->additional; + while (a) { + count += _mdns_append_answer(packet, &index, a, p->tcpip_if); + a = a->next; + } + _mdns_set_u16(packet, MDNS_HEAD_ADDITIONAL_OFFSET, count); + +#ifdef MDNS_ENABLE_DEBUG + _mdns_dbg_printf("\nTX[%lu][%lu]: ", (unsigned long)p->tcpip_if, (unsigned long)p->ip_protocol); +#ifdef CONFIG_LWIP_IPV4 + if (p->dst.type == ESP_IPADDR_TYPE_V4) { + _mdns_dbg_printf("To: " IPSTR ":%u, ", IP2STR(&p->dst.u_addr.ip4), p->port); + } +#endif +#ifdef CONFIG_LWIP_IPV6 + if (p->dst.type == ESP_IPADDR_TYPE_V6) { + _mdns_dbg_printf("To: " IPV6STR ":%u, ", IPV62STR(p->dst.u_addr.ip6), p->port); + } +#endif + mdns_debug_packet(packet, index); +#endif + + _mdns_udp_pcb_write(p->tcpip_if, p->ip_protocol, &p->dst, p->port, packet, index); +} + +/** + * @brief frees a packet + * + * @param packet the packet + */ +static void _mdns_free_tx_packet(mdns_tx_packet_t *packet) +{ + if (!packet) { + return; + } + mdns_out_question_t *q = packet->questions; + while (q) { + mdns_out_question_t *next = q->next; + if (q->own_dynamic_memory) { + mdns_mem_free((char *)q->host); + mdns_mem_free((char *)q->service); + mdns_mem_free((char *)q->proto); + mdns_mem_free((char *)q->domain); + } + mdns_mem_free(q); + q = next; + } + queueFree(mdns_out_answer_t, packet->answers); + queueFree(mdns_out_answer_t, packet->servers); + queueFree(mdns_out_answer_t, packet->additional); + mdns_mem_free(packet); +} + +/** + * @brief schedules a packet to be sent after given milliseconds + * + * @param packet the packet + * @param ms_after number of milliseconds after which the packet should be dispatched + */ +static void _mdns_schedule_tx_packet(mdns_tx_packet_t *packet, uint32_t ms_after) +{ + if (!packet) { + return; + } + packet->send_at = (xTaskGetTickCount() * portTICK_PERIOD_MS) + ms_after; + packet->next = NULL; + if (!_mdns_server->tx_queue_head || _mdns_server->tx_queue_head->send_at > packet->send_at) { + packet->next = _mdns_server->tx_queue_head; + _mdns_server->tx_queue_head = packet; + return; + } + mdns_tx_packet_t *q = _mdns_server->tx_queue_head; + while (q->next && q->next->send_at <= packet->send_at) { + q = q->next; + } + packet->next = q->next; + q->next = packet; +} + +/** + * @brief free all packets scheduled for sending + */ +static void _mdns_clear_tx_queue_head(void) +{ + mdns_tx_packet_t *q; + while (_mdns_server->tx_queue_head) { + q = _mdns_server->tx_queue_head; + _mdns_server->tx_queue_head = _mdns_server->tx_queue_head->next; + _mdns_free_tx_packet(q); + } +} + +/** + * @brief clear packets scheduled for sending on a specific interface + * + * @param tcpip_if the interface + * @param ip_protocol pcb type V4/V6 + */ +static void _mdns_clear_pcb_tx_queue_head(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + mdns_tx_packet_t *q, * p; + while (_mdns_server->tx_queue_head && _mdns_server->tx_queue_head->tcpip_if == tcpip_if && _mdns_server->tx_queue_head->ip_protocol == ip_protocol) { + q = _mdns_server->tx_queue_head; + _mdns_server->tx_queue_head = _mdns_server->tx_queue_head->next; + _mdns_free_tx_packet(q); + } + if (_mdns_server->tx_queue_head) { + q = _mdns_server->tx_queue_head; + while (q->next) { + if (q->next->tcpip_if == tcpip_if && q->next->ip_protocol == ip_protocol) { + p = q->next; + q->next = p->next; + _mdns_free_tx_packet(p); + } else { + q = q->next; + } + } + } +} + +/** + * @brief get the next packet scheduled for sending on a specific interface + * + * @param tcpip_if the interface + * @param ip_protocol pcb type V4/V6 + */ +static mdns_tx_packet_t *_mdns_get_next_pcb_packet(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + mdns_tx_packet_t *q = _mdns_server->tx_queue_head; + while (q) { + if (q->tcpip_if == tcpip_if && q->ip_protocol == ip_protocol) { + return q; + } + q = q->next; + } + return NULL; +} + +/** + * @brief Find, remove and free answer from the scheduled packets + */ +static void _mdns_remove_scheduled_answer(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint16_t type, mdns_srv_item_t *service) +{ + mdns_srv_item_t s = {NULL, NULL}; + if (!service) { + service = &s; + } + mdns_tx_packet_t *q = _mdns_server->tx_queue_head; + while (q) { + if (q->tcpip_if == tcpip_if && q->ip_protocol == ip_protocol && q->distributed) { + mdns_out_answer_t *a = q->answers; + if (a) { + if (a->type == type && a->service == service->service) { + q->answers = q->answers->next; + mdns_mem_free(a); + } else { + while (a->next) { + if (a->next->type == type && a->next->service == service->service) { + mdns_out_answer_t *b = a->next; + a->next = b->next; + mdns_mem_free(b); + break; + } + a = a->next; + } + } + } + } + q = q->next; + } +} + +/** + * @brief Remove and free answer from answer list (destination) + */ +static void _mdns_dealloc_answer(mdns_out_answer_t **destination, uint16_t type, mdns_srv_item_t *service) +{ + mdns_out_answer_t *d = *destination; + if (!d) { + return; + } + mdns_srv_item_t s = {NULL, NULL}; + if (!service) { + service = &s; + } + if (d->type == type && d->service == service->service) { + *destination = d->next; + mdns_mem_free(d); + return; + } + while (d->next) { + mdns_out_answer_t *a = d->next; + if (a->type == type && a->service == service->service) { + d->next = a->next; + mdns_mem_free(a); + return; + } + d = d->next; + } +} + +/** + * @brief Allocate new answer and add it to answer list (destination) + */ +static bool _mdns_alloc_answer(mdns_out_answer_t **destination, uint16_t type, mdns_service_t *service, + mdns_host_item_t *host, bool flush, bool bye) +{ + mdns_out_answer_t *d = *destination; + while (d) { + if (d->type == type && d->service == service && d->host == host) { + return true; + } + d = d->next; + } + + mdns_out_answer_t *a = (mdns_out_answer_t *)mdns_mem_malloc(sizeof(mdns_out_answer_t)); + if (!a) { + HOOK_MALLOC_FAILED; + return false; + } + a->type = type; + a->service = service; + a->host = host; + a->custom_service = NULL; + a->bye = bye; + a->flush = flush; + a->next = NULL; + queueToEnd(mdns_out_answer_t, *destination, a); + return true; +} + +/** + * @brief Allocate new packet for sending + */ +static mdns_tx_packet_t *_mdns_alloc_packet_default(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + mdns_tx_packet_t *packet = (mdns_tx_packet_t *)mdns_mem_malloc(sizeof(mdns_tx_packet_t)); + if (!packet) { + HOOK_MALLOC_FAILED; + return NULL; + } + memset((uint8_t *)packet, 0, sizeof(mdns_tx_packet_t)); + packet->tcpip_if = tcpip_if; + packet->ip_protocol = ip_protocol; + packet->port = MDNS_SERVICE_PORT; +#ifdef CONFIG_LWIP_IPV4 + if (ip_protocol == MDNS_IP_PROTOCOL_V4) { + esp_ip_addr_t addr = ESP_IP4ADDR_INIT(224, 0, 0, 251); + memcpy(&packet->dst, &addr, sizeof(esp_ip_addr_t)); + } +#endif +#ifdef CONFIG_LWIP_IPV6 + if (ip_protocol == MDNS_IP_PROTOCOL_V6) { + esp_ip_addr_t addr = ESP_IP6ADDR_INIT(0x000002ff, 0, 0, 0xfb000000); + memcpy(&packet->dst, &addr, sizeof(esp_ip_addr_t)); + } +#endif + return packet; +} + +static bool _mdns_create_answer_from_service(mdns_tx_packet_t *packet, mdns_service_t *service, + mdns_parsed_question_t *question, bool shared, bool send_flush) +{ + mdns_host_item_t *host = mdns_get_host_item(service->hostname); + bool is_delegated = (host != &_mdns_self_host); + if (question->type == MDNS_TYPE_PTR || question->type == MDNS_TYPE_ANY) { + // According to RFC6763-section12.1, for DNS-SD, SRV, TXT and all address records + // should be included in additional records. + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, service, NULL, false, false) || + !_mdns_alloc_answer(&packet->additional, MDNS_TYPE_SRV, service, NULL, send_flush, false) || + !_mdns_alloc_answer(&packet->additional, MDNS_TYPE_TXT, service, NULL, send_flush, false) || + !_mdns_alloc_answer((shared || is_delegated) ? &packet->additional : &packet->answers, MDNS_TYPE_A, service, host, send_flush, + false) || + !_mdns_alloc_answer((shared || is_delegated) ? &packet->additional : &packet->answers, MDNS_TYPE_AAAA, service, host, + send_flush, false)) { + return false; + } + } else if (question->type == MDNS_TYPE_SRV) { + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SRV, service, NULL, send_flush, false) || + !_mdns_alloc_answer(&packet->additional, MDNS_TYPE_A, service, host, send_flush, false) || + !_mdns_alloc_answer(&packet->additional, MDNS_TYPE_AAAA, service, host, send_flush, false)) { + return false; + } + } else if (question->type == MDNS_TYPE_TXT) { + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_TXT, service, NULL, send_flush, false)) { + return false; + } + } else if (question->type == MDNS_TYPE_SDPTR) { + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SDPTR, service, NULL, false, false)) { + return false; + } + } + return true; +} + +static bool _mdns_create_answer_from_hostname(mdns_tx_packet_t *packet, const char *hostname, bool send_flush) +{ + mdns_host_item_t *host = mdns_get_host_item(hostname); + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_A, NULL, host, send_flush, false) || + !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_AAAA, NULL, host, send_flush, false)) { + return false; + } + return true; +} + +static bool _mdns_service_match_ptr_question(const mdns_service_t *service, const mdns_parsed_question_t *question) +{ + if (!_mdns_service_match(service, question->service, question->proto, NULL)) { + return false; + } + // The question parser stores anything before _type._proto in question->host + // So the question->host can be subtype or instance name based on its content + if (question->sub) { + mdns_subtype_t *subtype = service->subtype; + while (subtype) { + if (!strcasecmp(subtype->subtype, question->host)) { + return true; + } + subtype = subtype->next; + } + return false; + } + if (question->host) { + if (strcasecmp(_mdns_get_service_instance_name(service), question->host) != 0) { + return false; + } + } + return true; +} + +/** + * @brief Create answer packet to questions from parsed packet + */ +static void _mdns_create_answer_from_parsed_packet(mdns_parsed_packet_t *parsed_packet) +{ + if (!parsed_packet->questions) { + return; + } + bool send_flush = parsed_packet->src_port == MDNS_SERVICE_PORT; + bool unicast = false; + bool shared = false; + mdns_tx_packet_t *packet = _mdns_alloc_packet_default(parsed_packet->tcpip_if, parsed_packet->ip_protocol); + if (!packet) { + return; + } + packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE; + packet->distributed = parsed_packet->distributed; + packet->id = parsed_packet->id; + + mdns_parsed_question_t *q = parsed_packet->questions; + uint32_t out_record_nums = 0; + while (q) { + shared = q->type == MDNS_TYPE_PTR || q->type == MDNS_TYPE_SDPTR || !parsed_packet->probe; + if (q->type == MDNS_TYPE_SRV || q->type == MDNS_TYPE_TXT) { + mdns_srv_item_t *service = _mdns_get_service_item_instance(q->host, q->service, q->proto, NULL); + if (service == NULL) { // Service not found, but we continue to the next question + q = q->next; + continue; + } + if (!_mdns_create_answer_from_service(packet, service->service, q, shared, send_flush)) { + _mdns_free_tx_packet(packet); + return; + } else { + out_record_nums++; + } + } else if (q->service && q->proto) { + mdns_srv_item_t *service = _mdns_server->services; + while (service) { + if (_mdns_service_match_ptr_question(service->service, q)) { + mdns_parsed_record_t *r = parsed_packet->records; + bool is_record_exist = false; + while (r) { + if (service->service->instance && r->host) { + if (_mdns_service_match_instance(service->service, r->host, r->service, r->proto, NULL) && r->ttl > (MDNS_ANSWER_PTR_TTL / 2)) { + is_record_exist = true; + break; + } + } else if (!service->service->instance && !r->host) { + if (_mdns_service_match(service->service, r->service, r->proto, NULL) && r->ttl > (MDNS_ANSWER_PTR_TTL / 2)) { + is_record_exist = true; + break; + } + } + r = r->next; + } + if (!is_record_exist) { + if (!_mdns_create_answer_from_service(packet, service->service, q, shared, send_flush)) { + _mdns_free_tx_packet(packet); + return; + } else { + out_record_nums++; + } + } + } + service = service->next; + } + } else if (q->type == MDNS_TYPE_A || q->type == MDNS_TYPE_AAAA) { + if (!_mdns_create_answer_from_hostname(packet, q->host, send_flush)) { + _mdns_free_tx_packet(packet); + return; + } else { + out_record_nums++; + } + } else if (q->type == MDNS_TYPE_ANY) { + if (!_mdns_append_host_list(&packet->answers, send_flush, false)) { + _mdns_free_tx_packet(packet); + return; + } else { + out_record_nums++; + } +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES + } else if (q->type == MDNS_TYPE_PTR) { + mdns_host_item_t *host = mdns_get_host_item(q->host); + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, NULL, host, send_flush, false)) { + _mdns_free_tx_packet(packet); + return; + } else { + out_record_nums++; + } +#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ + } else if (!_mdns_alloc_answer(&packet->answers, q->type, NULL, NULL, send_flush, false)) { + _mdns_free_tx_packet(packet); + return; + } else { + out_record_nums++; + } + + if (parsed_packet->src_port != MDNS_SERVICE_PORT && // Repeat the queries only for "One-Shot mDNS queries" + (q->type == MDNS_TYPE_ANY || q->type == MDNS_TYPE_A || q->type == MDNS_TYPE_AAAA +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES + || q->type == MDNS_TYPE_PTR +#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ + )) { + mdns_out_question_t *out_question = mdns_mem_malloc(sizeof(mdns_out_question_t)); + if (out_question == NULL) { + HOOK_MALLOC_FAILED; + _mdns_free_tx_packet(packet); + return; + } + out_question->type = q->type; + out_question->unicast = q->unicast; + out_question->host = q->host; + q->host = NULL; + out_question->service = q->service; + q->service = NULL; + out_question->proto = q->proto; + q->proto = NULL; + out_question->domain = q->domain; + q->domain = NULL; + out_question->next = NULL; + out_question->own_dynamic_memory = true; + queueToEnd(mdns_out_question_t, packet->questions, out_question); + } + if (q->unicast) { + unicast = true; + } + q = q->next; + } + if (out_record_nums == 0) { + _mdns_free_tx_packet(packet); + return; + } + if (unicast || !send_flush) { + memcpy(&packet->dst, &parsed_packet->src, sizeof(esp_ip_addr_t)); + packet->port = parsed_packet->src_port; + } + + static uint8_t share_step = 0; + if (shared) { + _mdns_schedule_tx_packet(packet, 25 + (share_step * 25)); + share_step = (share_step + 1) & 0x03; + } else { + _mdns_dispatch_tx_packet(packet); + _mdns_free_tx_packet(packet); + } +} + +/** + * @brief Check if question is already in the list + */ +static bool _mdns_question_exists(mdns_out_question_t *needle, mdns_out_question_t *haystack) +{ + while (haystack) { + if (haystack->type == needle->type + && haystack->host == needle->host + && haystack->service == needle->service + && haystack->proto == needle->proto) { + return true; + } + haystack = haystack->next; + } + return false; +} + +static bool _mdns_append_host(mdns_out_answer_t **destination, mdns_host_item_t *host, bool flush, bool bye) +{ + if (!_mdns_alloc_answer(destination, MDNS_TYPE_A, NULL, host, flush, bye)) { + return false; + } + if (!_mdns_alloc_answer(destination, MDNS_TYPE_AAAA, NULL, host, flush, bye)) { + return false; + } + return true; +} + +static bool _mdns_append_host_list_in_services(mdns_out_answer_t **destination, mdns_srv_item_t *services[], + size_t services_len, bool flush, bool bye) +{ + if (services == NULL) { + mdns_host_item_t *host = mdns_get_host_item(_mdns_server->hostname); + if (host != NULL) { + return _mdns_append_host(destination, host, flush, bye); + } + return true; + } + for (size_t i = 0; i < services_len; i++) { + mdns_host_item_t *host = mdns_get_host_item(services[i]->service->hostname); + if (!_mdns_append_host(destination, host, flush, bye)) { + return false; + } + } + return true; +} + +static bool _mdns_append_host_list(mdns_out_answer_t **destination, bool flush, bool bye) +{ + if (!_str_null_or_empty(_mdns_server->hostname)) { + mdns_host_item_t *self_host = mdns_get_host_item(_mdns_server->hostname); + if (!_mdns_append_host(destination, self_host, flush, bye)) { + return false; + } + } + mdns_host_item_t *host = _mdns_host_list; + while (host != NULL) { + host = host->next; + if (!_mdns_append_host(destination, host, flush, bye)) { + return false; + } + } + return true; +} + +static bool _mdns_append_host_question(mdns_out_question_t **questions, const char *hostname, bool unicast) +{ + mdns_out_question_t *q = (mdns_out_question_t *)mdns_mem_malloc(sizeof(mdns_out_question_t)); + if (!q) { + HOOK_MALLOC_FAILED; + return false; + } + q->next = NULL; + q->unicast = unicast; + q->type = MDNS_TYPE_ANY; + q->host = hostname; + q->service = NULL; + q->proto = NULL; + q->domain = MDNS_DEFAULT_DOMAIN; + q->own_dynamic_memory = false; + if (_mdns_question_exists(q, *questions)) { + mdns_mem_free(q); + } else { + queueToEnd(mdns_out_question_t, *questions, q); + } + return true; +} + +static bool _mdns_append_host_questions_for_services(mdns_out_question_t **questions, mdns_srv_item_t *services[], + size_t len, bool unicast) +{ + if (!_str_null_or_empty(_mdns_server->hostname) && + !_mdns_append_host_question(questions, _mdns_server->hostname, unicast)) { + return false; + } + for (size_t i = 0; i < len; i++) { + if (!_mdns_append_host_question(questions, services[i]->service->hostname, unicast)) { + return false; + } + } + return true; +} + +/** + * @brief Create probe packet for particular services on particular PCB + */ +static mdns_tx_packet_t *_mdns_create_probe_packet(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t *services[], size_t len, bool first, bool include_ip) +{ + mdns_tx_packet_t *packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); + if (!packet) { + return NULL; + } + + size_t i; + for (i = 0; i < len; i++) { + mdns_out_question_t *q = (mdns_out_question_t *)mdns_mem_malloc(sizeof(mdns_out_question_t)); + if (!q) { + HOOK_MALLOC_FAILED; + _mdns_free_tx_packet(packet); + return NULL; + } + q->next = NULL; + q->unicast = first; + q->type = MDNS_TYPE_ANY; + q->host = _mdns_get_service_instance_name(services[i]->service); + q->service = services[i]->service->service; + q->proto = services[i]->service->proto; + q->domain = MDNS_DEFAULT_DOMAIN; + q->own_dynamic_memory = false; + if (!q->host || _mdns_question_exists(q, packet->questions)) { + mdns_mem_free(q); + continue; + } else { + queueToEnd(mdns_out_question_t, packet->questions, q); + } + + if (!q->host || !_mdns_alloc_answer(&packet->servers, MDNS_TYPE_SRV, services[i]->service, NULL, false, false)) { + _mdns_free_tx_packet(packet); + return NULL; + } + } + + if (include_ip) { + if (!_mdns_append_host_questions_for_services(&packet->questions, services, len, first)) { + _mdns_free_tx_packet(packet); + return NULL; + } + + if (!_mdns_append_host_list_in_services(&packet->servers, services, len, false, false)) { + _mdns_free_tx_packet(packet); + return NULL; + } + } + + return packet; +} + +/** + * @brief Create announce packet for particular services on particular PCB + */ +static mdns_tx_packet_t *_mdns_create_announce_packet(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t *services[], size_t len, bool include_ip) +{ + mdns_tx_packet_t *packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); + if (!packet) { + return NULL; + } + packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE; + + uint8_t i; + for (i = 0; i < len; i++) { + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SDPTR, services[i]->service, NULL, false, false) + || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, services[i]->service, NULL, false, false) + || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SRV, services[i]->service, NULL, true, false) + || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_TXT, services[i]->service, NULL, true, false)) { + _mdns_free_tx_packet(packet); + return NULL; + } + } + if (include_ip) { + if (!_mdns_append_host_list_in_services(&packet->servers, services, len, true, false)) { + _mdns_free_tx_packet(packet); + return NULL; + } + } + return packet; +} + +/** + * @brief Convert probe packet to announce + */ +static mdns_tx_packet_t *_mdns_create_announce_from_probe(mdns_tx_packet_t *probe) +{ + mdns_tx_packet_t *packet = _mdns_alloc_packet_default(probe->tcpip_if, probe->ip_protocol); + if (!packet) { + return NULL; + } + packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE; + + mdns_out_answer_t *s = probe->servers; + while (s) { + if (s->type == MDNS_TYPE_SRV) { + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SDPTR, s->service, NULL, false, false) + || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, s->service, NULL, false, false) + || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_SRV, s->service, NULL, true, false) + || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_TXT, s->service, NULL, true, false)) { + _mdns_free_tx_packet(packet); + return NULL; + } + mdns_host_item_t *host = mdns_get_host_item(s->service->hostname); + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_A, NULL, host, true, false) + || !_mdns_alloc_answer(&packet->answers, MDNS_TYPE_AAAA, NULL, host, true, false)) { + _mdns_free_tx_packet(packet); + return NULL; + } + + } else if (s->type == MDNS_TYPE_A || s->type == MDNS_TYPE_AAAA) { + if (!_mdns_alloc_answer(&packet->answers, s->type, NULL, s->host, true, false)) { + _mdns_free_tx_packet(packet); + return NULL; + } + } + + s = s->next; + } + return packet; +} + +/** + * @brief Send by for particular services on particular PCB + */ +static void _mdns_pcb_send_bye(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t **services, size_t len, bool include_ip) +{ + mdns_tx_packet_t *packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); + if (!packet) { + return; + } + packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE; + size_t i; + for (i = 0; i < len; i++) { + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, services[i]->service, NULL, true, true)) { + _mdns_free_tx_packet(packet); + return; + } + } + if (include_ip) { + _mdns_append_host_list_in_services(&packet->answers, services, len, true, true); + } + _mdns_dispatch_tx_packet(packet); + _mdns_free_tx_packet(packet); +} + +/** + * @brief Send probe for additional services on particular PCB + */ +static void _mdns_init_pcb_probe_new_service(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t **services, size_t len, bool probe_ip) +{ + mdns_pcb_t *pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol]; + size_t services_final_len = len; + + if (PCB_STATE_IS_PROBING(pcb)) { + services_final_len += pcb->probe_services_len; + } + mdns_srv_item_t **_services = NULL; + if (services_final_len) { + _services = (mdns_srv_item_t **)mdns_mem_malloc(sizeof(mdns_srv_item_t *) * services_final_len); + if (!_services) { + HOOK_MALLOC_FAILED; + return; + } + + size_t i; + for (i = 0; i < len; i++) { + _services[i] = services[i]; + } + if (pcb->probe_services) { + for (i = 0; i < pcb->probe_services_len; i++) { + _services[len + i] = pcb->probe_services[i]; + } + mdns_mem_free(pcb->probe_services); + } + } + + probe_ip = pcb->probe_ip || probe_ip; + + pcb->probe_ip = false; + pcb->probe_services = NULL; + pcb->probe_services_len = 0; + pcb->probe_running = false; + + mdns_tx_packet_t *packet = _mdns_create_probe_packet(tcpip_if, ip_protocol, _services, services_final_len, true, probe_ip); + if (!packet) { + mdns_mem_free(_services); + return; + } + + pcb->probe_ip = probe_ip; + pcb->probe_services = _services; + pcb->probe_services_len = services_final_len; + pcb->probe_running = true; + _mdns_schedule_tx_packet(packet, ((pcb->failed_probes > 5) ? 1000 : 120) + (esp_random() & 0x7F)); + pcb->state = PCB_PROBE_1; +} + +/** + * @brief Send probe for particular services on particular PCB + * + * Tests possible duplication on probing service structure and probes only for new entries. + * - If pcb probing then add only non-probing services and restarts probing + * - If pcb not probing, run probing for all specified services + */ +static void _mdns_init_pcb_probe(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t **services, size_t len, bool probe_ip) +{ + mdns_pcb_t *pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol]; + + _mdns_clear_pcb_tx_queue_head(tcpip_if, ip_protocol); + + if (_str_null_or_empty(_mdns_server->hostname)) { + pcb->state = PCB_RUNNING; + return; + } + + if (PCB_STATE_IS_PROBING(pcb)) { + // Looking for already probing services to resolve duplications + mdns_srv_item_t *new_probe_services[len]; + int new_probe_service_len = 0; + bool found; + for (size_t j = 0; j < len; ++j) { + found = false; + for (int i = 0; i < pcb->probe_services_len; ++i) { + if (pcb->probe_services[i] == services[j]) { + found = true; + break; + } + } + if (!found) { + new_probe_services[new_probe_service_len++] = services[j]; + } + } + // init probing for newly added services + _mdns_init_pcb_probe_new_service(tcpip_if, ip_protocol, + new_probe_service_len ? new_probe_services : NULL, new_probe_service_len, probe_ip); + } else { + // not probing, so init for all services + _mdns_init_pcb_probe_new_service(tcpip_if, ip_protocol, services, len, probe_ip); + } +} + +/** + * @brief Restart the responder on particular PCB + */ +static void _mdns_restart_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + size_t srv_count = 0; + mdns_srv_item_t *a = _mdns_server->services; + while (a) { + srv_count++; + a = a->next; + } + if (srv_count == 0) { + // proble only IP + _mdns_init_pcb_probe(tcpip_if, ip_protocol, NULL, 0, true); + return; + } + mdns_srv_item_t *services[srv_count]; + size_t i = 0; + a = _mdns_server->services; + while (a) { + services[i++] = a; + a = a->next; + } + _mdns_init_pcb_probe(tcpip_if, ip_protocol, services, srv_count, true); +} + +/** + * @brief Send by for particular services + */ +static void _mdns_send_bye(mdns_srv_item_t **services, size_t len, bool include_ip) +{ + uint8_t i, j; + if (_str_null_or_empty(_mdns_server->hostname)) { + return; + } + + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { + for (j = 0; j < MDNS_IP_PROTOCOL_MAX; j++) { + if (mdns_is_netif_ready(i, j) && _mdns_server->interfaces[i].pcbs[j].state == PCB_RUNNING) { + _mdns_pcb_send_bye((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, include_ip); + } + } + } +} + +/** + * @brief Send bye for particular subtypes + */ +static void _mdns_send_bye_subtype(mdns_srv_item_t *service, const char *instance_name, mdns_subtype_t *remove_subtypes) +{ + uint8_t i, j; + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { + for (j = 0; j < MDNS_IP_PROTOCOL_MAX; j++) { + if (mdns_is_netif_ready(i, j)) { + mdns_tx_packet_t *packet = _mdns_alloc_packet_default((mdns_if_t)i, (mdns_ip_protocol_t)j); + if (packet == NULL) { + return; + } + packet->flags = MDNS_FLAGS_QR_AUTHORITATIVE; + if (!_mdns_alloc_answer(&packet->answers, MDNS_TYPE_PTR, service->service, NULL, true, true)) { + _mdns_free_tx_packet(packet); + return; + } + + static uint8_t pkt[MDNS_MAX_PACKET_SIZE]; + uint16_t index = MDNS_HEAD_LEN; + memset(pkt, 0, MDNS_HEAD_LEN); + mdns_out_answer_t *a; + uint8_t count; + + _mdns_set_u16(pkt, MDNS_HEAD_FLAGS_OFFSET, packet->flags); + _mdns_set_u16(pkt, MDNS_HEAD_ID_OFFSET, packet->id); + + count = 0; + a = packet->answers; + while (a) { + if (a->type == MDNS_TYPE_PTR && a->service) { + const mdns_subtype_t *current_subtype = remove_subtypes; + while (current_subtype) { + count += (_mdns_append_subtype_ptr_record(pkt, &index, instance_name, current_subtype->subtype, a->service->service, a->service->proto, a->flush, a->bye) > 0); + current_subtype = current_subtype->next; + } + } + a = a->next; + } + _mdns_set_u16(pkt, MDNS_HEAD_ANSWERS_OFFSET, count); + + _mdns_udp_pcb_write(packet->tcpip_if, packet->ip_protocol, &packet->dst, packet->port, pkt, index); + + _mdns_free_tx_packet(packet); + } + } + } +} + +/** + * @brief Send announcement on particular PCB + */ +static void _mdns_announce_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, mdns_srv_item_t **services, size_t len, bool include_ip) +{ + mdns_pcb_t *_pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_protocol]; + size_t i; + if (mdns_is_netif_ready(tcpip_if, ip_protocol)) { + if (PCB_STATE_IS_PROBING(_pcb)) { + _mdns_init_pcb_probe(tcpip_if, ip_protocol, services, len, include_ip); + } else if (PCB_STATE_IS_ANNOUNCING(_pcb)) { + mdns_tx_packet_t *p = _mdns_get_next_pcb_packet(tcpip_if, ip_protocol); + if (p) { + for (i = 0; i < len; i++) { + if (!_mdns_alloc_answer(&p->answers, MDNS_TYPE_SDPTR, services[i]->service, NULL, false, false) + || !_mdns_alloc_answer(&p->answers, MDNS_TYPE_PTR, services[i]->service, NULL, false, false) + || !_mdns_alloc_answer(&p->answers, MDNS_TYPE_SRV, services[i]->service, NULL, true, false) + || !_mdns_alloc_answer(&p->answers, MDNS_TYPE_TXT, services[i]->service, NULL, true, false)) { + break; + } + } + if (include_ip) { + _mdns_dealloc_answer(&p->additional, MDNS_TYPE_A, NULL); + _mdns_dealloc_answer(&p->additional, MDNS_TYPE_AAAA, NULL); + _mdns_append_host_list_in_services(&p->answers, services, len, true, false); + } + _pcb->state = PCB_ANNOUNCE_1; + } + } else if (_pcb->state == PCB_RUNNING) { + + if (_str_null_or_empty(_mdns_server->hostname)) { + return; + } + + _pcb->state = PCB_ANNOUNCE_1; + mdns_tx_packet_t *p = _mdns_create_announce_packet(tcpip_if, ip_protocol, services, len, include_ip); + if (p) { + _mdns_schedule_tx_packet(p, 0); + } + } + } +} + +/** + * @brief Send probe on all active PCBs + */ +static void _mdns_probe_all_pcbs(mdns_srv_item_t **services, size_t len, bool probe_ip, bool clear_old_probe) +{ + uint8_t i, j; + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { + for (j = 0; j < MDNS_IP_PROTOCOL_MAX; j++) { + if (mdns_is_netif_ready(i, j)) { + mdns_pcb_t *_pcb = &_mdns_server->interfaces[i].pcbs[j]; + if (clear_old_probe) { + mdns_mem_free(_pcb->probe_services); + _pcb->probe_services = NULL; + _pcb->probe_services_len = 0; + _pcb->probe_running = false; + } + _mdns_init_pcb_probe((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, probe_ip); + } + } + } +} + +/** + * @brief Send announcement on all active PCBs + */ +static void _mdns_announce_all_pcbs(mdns_srv_item_t **services, size_t len, bool include_ip) +{ + uint8_t i, j; + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { + for (j = 0; j < MDNS_IP_PROTOCOL_MAX; j++) { + _mdns_announce_pcb((mdns_if_t)i, (mdns_ip_protocol_t)j, services, len, include_ip); + } + } +} + +/** + * @brief Restart the responder on all active PCBs + */ +static void _mdns_send_final_bye(bool include_ip) +{ + //collect all services and start probe + size_t srv_count = 0; + mdns_srv_item_t *a = _mdns_server->services; + while (a) { + srv_count++; + a = a->next; + } + if (!srv_count) { + return; + } + mdns_srv_item_t *services[srv_count]; + size_t i = 0; + a = _mdns_server->services; + while (a) { + services[i++] = a; + a = a->next; + } + _mdns_send_bye(services, srv_count, include_ip); +} + +/** + * @brief Stop the responder on all services without instance + */ +static void _mdns_send_bye_all_pcbs_no_instance(bool include_ip) +{ + size_t srv_count = 0; + mdns_srv_item_t *a = _mdns_server->services; + while (a) { + if (!a->service->instance) { + srv_count++; + } + a = a->next; + } + if (!srv_count) { + return; + } + mdns_srv_item_t *services[srv_count]; + size_t i = 0; + a = _mdns_server->services; + while (a) { + if (!a->service->instance) { + services[i++] = a; + } + a = a->next; + } + _mdns_send_bye(services, srv_count, include_ip); +} + +/** + * @brief Restart the responder on all services without instance + */ +static void _mdns_restart_all_pcbs_no_instance(void) +{ + size_t srv_count = 0; + mdns_srv_item_t *a = _mdns_server->services; + while (a) { + if (!a->service->instance) { + srv_count++; + } + a = a->next; + } + if (!srv_count) { + return; + } + mdns_srv_item_t *services[srv_count]; + size_t i = 0; + a = _mdns_server->services; + while (a) { + if (!a->service->instance) { + services[i++] = a; + } + a = a->next; + } + _mdns_probe_all_pcbs(services, srv_count, false, true); +} + +/** + * @brief Restart the responder on all active PCBs + */ +static void _mdns_restart_all_pcbs(void) +{ + _mdns_clear_tx_queue_head(); + size_t srv_count = 0; + mdns_srv_item_t *a = _mdns_server->services; + while (a) { + srv_count++; + a = a->next; + } + if (srv_count == 0) { + _mdns_probe_all_pcbs(NULL, 0, true, true); + return; + } + mdns_srv_item_t *services[srv_count]; + size_t l = 0; + a = _mdns_server->services; + while (a) { + services[l++] = a; + a = a->next; + } + + _mdns_probe_all_pcbs(services, srv_count, true, true); +} + + + +/** + * @brief creates/allocates new text item list + * @param num_items service number of txt items or 0 + * @param txt service txt items array or NULL + * + * @return pointer to the linked txt item list or NULL + */ +static mdns_txt_linked_item_t *_mdns_allocate_txt(size_t num_items, mdns_txt_item_t txt[]) +{ + mdns_txt_linked_item_t *new_txt = NULL; + size_t i = 0; + if (num_items) { + for (i = 0; i < num_items; i++) { + mdns_txt_linked_item_t *new_item = (mdns_txt_linked_item_t *)mdns_mem_malloc(sizeof(mdns_txt_linked_item_t)); + if (!new_item) { + HOOK_MALLOC_FAILED; + break; + } + new_item->key = mdns_mem_strdup(txt[i].key); + if (!new_item->key) { + mdns_mem_free(new_item); + break; + } + if (txt[i].value) { + new_item->value = mdns_mem_strdup(txt[i].value); + if (!new_item->value) { + mdns_mem_free((char *)new_item->key); + mdns_mem_free(new_item); + break; + } + new_item->value_len = strlen(new_item->value); + } else { + new_item->value = NULL; + new_item->value_len = 0; + } + new_item->next = new_txt; + new_txt = new_item; + } + } + return new_txt; +} + +/** + * @brief Deallocate the txt linked list + * @param txt pointer to the txt pointer to free, noop if txt==NULL + */ +static void _mdns_free_linked_txt(mdns_txt_linked_item_t *txt) +{ + mdns_txt_linked_item_t *t; + while (txt) { + t = txt; + txt = txt->next; + mdns_mem_free((char *)t->value); + mdns_mem_free((char *)t->key); + mdns_mem_free(t); + } +} + +/** + * @brief creates/allocates new service + * @param service service type + * @param proto service proto + * @param hostname service hostname + * @param port service port + * @param instance service instance + * @param num_items service number of txt items or 0 + * @param txt service txt items array or NULL + * + * @return pointer to the service or NULL on error + */ +static mdns_service_t *_mdns_create_service(const char *service, const char *proto, const char *hostname, + uint16_t port, const char *instance, size_t num_items, + mdns_txt_item_t txt[]) +{ + mdns_service_t *s = (mdns_service_t *)mdns_mem_calloc(1, sizeof(mdns_service_t)); + if (!s) { + HOOK_MALLOC_FAILED; + return NULL; + } + + mdns_txt_linked_item_t *new_txt = _mdns_allocate_txt(num_items, txt); + if (num_items && new_txt == NULL) { + goto fail; + } + + s->priority = 0; + s->weight = 0; + s->instance = instance ? mdns_mem_strndup(instance, MDNS_NAME_BUF_LEN - 1) : NULL; + s->txt = new_txt; + s->port = port; + s->subtype = NULL; + + if (hostname) { + s->hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); + if (!s->hostname) { + goto fail; + } + } else { + s->hostname = NULL; + } + + s->service = mdns_mem_strndup(service, MDNS_NAME_BUF_LEN - 1); + if (!s->service) { + goto fail; + } + + s->proto = mdns_mem_strndup(proto, MDNS_NAME_BUF_LEN - 1); + if (!s->proto) { + goto fail; + } + return s; + +fail: + _mdns_free_linked_txt(s->txt); + mdns_mem_free((char *)s->instance); + mdns_mem_free((char *)s->service); + mdns_mem_free((char *)s->proto); + mdns_mem_free((char *)s->hostname); + mdns_mem_free(s); + + return NULL; +} + +/** + * @brief Remove and free service answer from answer list (destination) + */ +static void _mdns_dealloc_scheduled_service_answers(mdns_out_answer_t **destination, mdns_service_t *service) +{ + mdns_out_answer_t *d = *destination; + if (!d) { + return; + } + while (d && d->service == service) { + *destination = d->next; + mdns_mem_free(d); + d = *destination; + } + while (d && d->next) { + mdns_out_answer_t *a = d->next; + if (a->service == service) { + d->next = a->next; + mdns_mem_free(a); + } else { + d = d->next; + } + } +} + +/** + * @brief Find, remove and free answers and scheduled packets for service + */ +static void _mdns_remove_scheduled_service_packets(mdns_service_t *service) +{ + if (!service) { + return; + } + mdns_tx_packet_t *p = NULL; + mdns_tx_packet_t *q = _mdns_server->tx_queue_head; + while (q) { + bool had_answers = (q->answers != NULL); + + _mdns_dealloc_scheduled_service_answers(&(q->answers), service); + _mdns_dealloc_scheduled_service_answers(&(q->additional), service); + _mdns_dealloc_scheduled_service_answers(&(q->servers), service); + + + mdns_pcb_t *_pcb = &_mdns_server->interfaces[q->tcpip_if].pcbs[q->ip_protocol]; + if (mdns_is_netif_ready(q->tcpip_if, q->ip_protocol)) { + if (PCB_STATE_IS_PROBING(_pcb)) { + uint8_t i; + //check if we are probing this service + for (i = 0; i < _pcb->probe_services_len; i++) { + mdns_srv_item_t *s = _pcb->probe_services[i]; + if (s->service == service) { + break; + } + } + if (i < _pcb->probe_services_len) { + if (_pcb->probe_services_len > 1) { + uint8_t n; + for (n = (i + 1); n < _pcb->probe_services_len; n++) { + _pcb->probe_services[n - 1] = _pcb->probe_services[n]; + } + _pcb->probe_services_len--; + } else { + _pcb->probe_services_len = 0; + mdns_mem_free(_pcb->probe_services); + _pcb->probe_services = NULL; + if (!_pcb->probe_ip) { + _pcb->probe_running = false; + _pcb->state = PCB_RUNNING; + } + } + + if (q->questions) { + mdns_out_question_t *qsn = NULL; + mdns_out_question_t *qs = q->questions; + if (qs->type == MDNS_TYPE_ANY + && qs->service && strcmp(qs->service, service->service) == 0 + && qs->proto && strcmp(qs->proto, service->proto) == 0) { + q->questions = q->questions->next; + mdns_mem_free(qs); + } else while (qs->next) { + qsn = qs->next; + if (qsn->type == MDNS_TYPE_ANY + && qsn->service && strcmp(qsn->service, service->service) == 0 + && qsn->proto && strcmp(qsn->proto, service->proto) == 0) { + qs->next = qsn->next; + mdns_mem_free(qsn); + break; + } + qs = qs->next; + } + } + } + } else if (PCB_STATE_IS_ANNOUNCING(_pcb)) { + //if answers were cleared, set to running + if (had_answers && q->answers == NULL) { + _pcb->state = PCB_RUNNING; + } + } + } + + p = q; + q = q->next; + if (!p->questions && !p->answers && !p->additional && !p->servers) { + queueDetach(mdns_tx_packet_t, _mdns_server->tx_queue_head, p); + _mdns_free_tx_packet(p); + } + } +} + +static void _mdns_free_subtype(mdns_subtype_t *subtype) +{ + while (subtype) { + mdns_subtype_t *next = subtype->next; + mdns_mem_free((char *)subtype->subtype); + mdns_mem_free(subtype); + subtype = next; + } +} + +static void _mdns_free_service_subtype(mdns_service_t *service) +{ + _mdns_free_subtype(service->subtype); + service->subtype = NULL; +} + +/** + * @brief free service memory + * + * @param service the service + */ +static void _mdns_free_service(mdns_service_t *service) +{ + if (!service) { + return; + } + mdns_mem_free((char *)service->instance); + mdns_mem_free((char *)service->service); + mdns_mem_free((char *)service->proto); + mdns_mem_free((char *)service->hostname); + while (service->txt) { + mdns_txt_linked_item_t *s = service->txt; + service->txt = service->txt->next; + mdns_mem_free((char *)s->key); + mdns_mem_free((char *)s->value); + mdns_mem_free(s); + } + _mdns_free_service_subtype(service); + mdns_mem_free(service); +} + + +/* + * Received Packet Handling + * */ + +/** + * @brief Detect SRV collision + */ +static int _mdns_check_srv_collision(mdns_service_t *service, uint16_t priority, uint16_t weight, uint16_t port, const char *host, const char *domain) +{ + if (_str_null_or_empty(_mdns_server->hostname)) { + return 0; + } + + size_t our_host_len = strlen(_mdns_server->hostname); + size_t our_len = 14 + our_host_len; + + size_t their_host_len = strlen(host); + size_t their_domain_len = strlen(domain); + size_t their_len = 9 + their_host_len + their_domain_len; + + if (their_len > our_len) { + return 1;//they win + } else if (their_len < our_len) { + return -1;//we win + } + + uint16_t our_index = 0; + uint8_t our_data[our_len]; + _mdns_append_u16(our_data, &our_index, service->priority); + _mdns_append_u16(our_data, &our_index, service->weight); + _mdns_append_u16(our_data, &our_index, service->port); + our_data[our_index++] = our_host_len; + memcpy(our_data + our_index, _mdns_server->hostname, our_host_len); + our_index += our_host_len; + our_data[our_index++] = 5; + memcpy(our_data + our_index, MDNS_DEFAULT_DOMAIN, 5); + our_index += 5; + our_data[our_index++] = 0; + + uint16_t their_index = 0; + uint8_t their_data[their_len]; + _mdns_append_u16(their_data, &their_index, priority); + _mdns_append_u16(their_data, &their_index, weight); + _mdns_append_u16(their_data, &their_index, port); + their_data[their_index++] = their_host_len; + memcpy(their_data + their_index, host, their_host_len); + their_index += their_host_len; + their_data[their_index++] = their_domain_len; + memcpy(their_data + their_index, domain, their_domain_len); + their_index += their_domain_len; + their_data[their_index++] = 0; + + int ret = memcmp(our_data, their_data, our_len); + if (ret > 0) { + return -1;//we win + } else if (ret < 0) { + return 1;//they win + } + return 0;//same +} + +/** + * @brief Detect TXT collision + */ +static int _mdns_check_txt_collision(mdns_service_t *service, const uint8_t *data, size_t len) +{ + size_t data_len = 0; + if (len <= 1 && service->txt) { // len==0 means incorrect packet (and handled by the packet parser) + // but handled here again to fix clang-tidy warning on VLA "uint8_t our[0];" + return -1;//we win + } else if (len > 1 && !service->txt) { + return 1;//they win + } else if (len <= 1 && !service->txt) { + return 0;//same + } + + mdns_txt_linked_item_t *txt = service->txt; + while (txt) { + data_len += 1 /* record-len */ + strlen(txt->key) + txt->value_len + (txt->value ? 1 : 0 /* "=" */); + txt = txt->next; + } + + if (len > data_len) { + return 1;//they win + } else if (len < data_len) { + return -1;//we win + } + + uint8_t ours[len]; + uint16_t index = 0; + + txt = service->txt; + while (txt) { + append_one_txt_record_entry(ours, &index, txt); + txt = txt->next; + } + + int ret = memcmp(ours, data, len); + if (ret > 0) { + return -1;//we win + } else if (ret < 0) { + return 1;//they win + } + return 0;//same +} + +static esp_err_t mdns_pcb_deinit_local(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_proto) +{ + esp_err_t err = _mdns_pcb_deinit(tcpip_if, ip_proto); + mdns_pcb_t *_pcb = &_mdns_server->interfaces[tcpip_if].pcbs[ip_proto]; + if (_pcb == NULL || err != ESP_OK) { + return err; + } + mdns_mem_free(_pcb->probe_services); + _pcb->state = PCB_OFF; + _pcb->probe_ip = false; + _pcb->probe_services = NULL; + _pcb->probe_services_len = 0; + _pcb->probe_running = false; + _pcb->failed_probes = 0; + return ESP_OK; +} +/** + * @brief Set interface as duplicate if another is found on the same subnet + */ +static void _mdns_dup_interface(mdns_if_t tcpip_if) +{ + uint8_t i; + mdns_if_t other_if = _mdns_get_other_if(tcpip_if); + if (other_if == MDNS_MAX_INTERFACES) { + return; // no other interface found + } + for (i = 0; i < MDNS_IP_PROTOCOL_MAX; i++) { + if (mdns_is_netif_ready(other_if, i)) { + //stop this interface and mark as dup + if (mdns_is_netif_ready(tcpip_if, i)) { + _mdns_clear_pcb_tx_queue_head(tcpip_if, i); + mdns_pcb_deinit_local(tcpip_if, i); + } + _mdns_server->interfaces[tcpip_if].pcbs[i].state = PCB_DUP; + _mdns_announce_pcb(other_if, i, NULL, 0, true); + } + } +} + +#ifdef CONFIG_LWIP_IPV4 +/** + * @brief Detect IPv4 address collision + */ +static int _mdns_check_a_collision(esp_ip4_addr_t *ip, mdns_if_t tcpip_if) +{ + esp_netif_ip_info_t if_ip_info; + esp_netif_ip_info_t other_ip_info; + if (!ip->addr) { + return 1;//denial! they win + } + if (esp_netif_get_ip_info(_mdns_get_esp_netif(tcpip_if), &if_ip_info)) { + return 1;//they win + } + int ret = memcmp((uint8_t *)&if_ip_info.ip.addr, (uint8_t *)&ip->addr, sizeof(esp_ip4_addr_t)); + if (ret > 0) { + return -1;//we win + } else if (ret < 0) { + //is it the other interface? + mdns_if_t other_if = _mdns_get_other_if(tcpip_if); + if (other_if == MDNS_MAX_INTERFACES) { + return 1;//AP interface! They win + } + if (esp_netif_get_ip_info(_mdns_get_esp_netif(other_if), &other_ip_info)) { + return 1;//IPv4 not active! They win + } + if (ip->addr != other_ip_info.ip.addr) { + return 1;//IPv4 not ours! They win + } + _mdns_dup_interface(tcpip_if); + return 2;//they win + } + return 0;//same +} +#endif /* CONFIG_LWIP_IPV4 */ + +#ifdef CONFIG_LWIP_IPV6 +/** + * @brief Detect IPv6 address collision + */ +static int _mdns_check_aaaa_collision(esp_ip6_addr_t *ip, mdns_if_t tcpip_if) +{ + struct esp_ip6_addr if_ip6; + struct esp_ip6_addr other_ip6; + if (_ipv6_address_is_zero(*ip)) { + return 1;//denial! they win + } + if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(tcpip_if), &if_ip6)) { + return 1;//they win + } + int ret = memcmp((uint8_t *)&if_ip6.addr, (uint8_t *)ip->addr, _MDNS_SIZEOF_IP6_ADDR); + if (ret > 0) { + return -1;//we win + } else if (ret < 0) { + //is it the other interface? + mdns_if_t other_if = _mdns_get_other_if(tcpip_if); + if (other_if == MDNS_MAX_INTERFACES) { + return 1;//AP interface! They win + } + if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(other_if), &other_ip6)) { + return 1;//IPv6 not active! They win + } + if (memcmp((uint8_t *)&other_ip6.addr, (uint8_t *)ip->addr, _MDNS_SIZEOF_IP6_ADDR)) { + return 1;//IPv6 not ours! They win + } + _mdns_dup_interface(tcpip_if); + return 2;//they win + } + return 0;//same +} +#endif /* CONFIG_LWIP_IPV6 */ + +static bool _hostname_is_ours(const char *hostname) +{ + if (!_str_null_or_empty(_mdns_server->hostname) && + strcasecmp(hostname, _mdns_server->hostname) == 0) { + return true; + } + mdns_host_item_t *host = _mdns_host_list; + while (host != NULL) { + if (strcasecmp(hostname, host->hostname) == 0) { + return true; + } + host = host->next; + } + return false; +} + +/** + * @brief Adds a delegated hostname to the linked list + * @param hostname Host name pointer + * @param address_list Address list + * @return true on success + * false if the host wasn't attached (this is our hostname, or alloc failure) so we have to free the structs + */ +static bool _mdns_delegate_hostname_add(const char *hostname, mdns_ip_addr_t *address_list) +{ + if (_hostname_is_ours(hostname)) { + return false; + } + + mdns_host_item_t *host = (mdns_host_item_t *)mdns_mem_malloc(sizeof(mdns_host_item_t)); + + if (host == NULL) { + return false; + } + host->address_list = address_list; + host->hostname = hostname; + host->next = _mdns_host_list; + _mdns_host_list = host; + return true; +} + +static void free_address_list(mdns_ip_addr_t *address_list) +{ + while (address_list != NULL) { + mdns_ip_addr_t *next = address_list->next; + mdns_mem_free(address_list); + address_list = next; + } +} + + +static bool _mdns_delegate_hostname_set_address(const char *hostname, mdns_ip_addr_t *address_list) +{ + if (!_str_null_or_empty(_mdns_server->hostname) && + strcasecmp(hostname, _mdns_server->hostname) == 0) { + return false; + } + mdns_host_item_t *host = _mdns_host_list; + while (host != NULL) { + if (strcasecmp(hostname, host->hostname) == 0) { + // free previous address list + free_address_list(host->address_list); + // set current address list to the host + host->address_list = address_list; + return true; + } + host = host->next; + } + return false; +} + +static mdns_ip_addr_t *copy_address_list(const mdns_ip_addr_t *address_list) +{ + mdns_ip_addr_t *head = NULL; + mdns_ip_addr_t *tail = NULL; + while (address_list != NULL) { + mdns_ip_addr_t *addr = (mdns_ip_addr_t *)mdns_mem_malloc(sizeof(mdns_ip_addr_t)); + if (addr == NULL) { + free_address_list(head); + return NULL; + } + addr->addr = address_list->addr; + addr->next = NULL; + if (head == NULL) { + head = addr; + tail = addr; + } else { + tail->next = addr; + tail = tail->next; + } + address_list = address_list->next; + } + return head; +} + +static void free_delegated_hostnames(void) +{ + mdns_host_item_t *host = _mdns_host_list; + while (host != NULL) { + free_address_list(host->address_list); + mdns_mem_free((char *)host->hostname); + mdns_host_item_t *item = host; + host = host->next; + mdns_mem_free(item); + } + _mdns_host_list = NULL; +} + +static bool _mdns_delegate_hostname_remove(const char *hostname) +{ + mdns_srv_item_t *srv = _mdns_server->services; + mdns_srv_item_t *prev_srv = NULL; + while (srv) { + if (strcasecmp(srv->service->hostname, hostname) == 0) { + mdns_srv_item_t *to_free = srv; + _mdns_send_bye(&srv, 1, false); + _mdns_remove_scheduled_service_packets(srv->service); + if (prev_srv == NULL) { + _mdns_server->services = srv->next; + srv = srv->next; + } else { + prev_srv->next = srv->next; + srv = srv->next; + } + _mdns_free_service(to_free->service); + mdns_mem_free(to_free); + } else { + prev_srv = srv; + srv = srv->next; + } + } + mdns_host_item_t *host = _mdns_host_list; + mdns_host_item_t *prev_host = NULL; + while (host != NULL) { + if (strcasecmp(hostname, host->hostname) == 0) { + if (prev_host == NULL) { + _mdns_host_list = host->next; + } else { + prev_host->next = host->next; + } + free_address_list(host->address_list); + mdns_mem_free((char *)host->hostname); + mdns_mem_free(host); + break; + } else { + prev_host = host; + host = host->next; + } + } + return true; +} + +/** + * @brief Check if parsed name is discovery + */ +static bool _mdns_name_is_discovery(mdns_name_t *name, uint16_t type) +{ + return ( + (name->host[0] && !strcasecmp(name->host, "_services")) + && (name->service[0] && !strcasecmp(name->service, "_dns-sd")) + && (name->proto[0] && !strcasecmp(name->proto, "_udp")) + && (name->domain[0] && !strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN)) + && type == MDNS_TYPE_PTR + ); +} + +/** + * @brief Check if the parsed name is self-hosted, i.e. we should resolve conflicts + */ +static bool _mdns_name_is_selfhosted(mdns_name_t *name) +{ + if (_str_null_or_empty(_mdns_server->hostname)) { // self-hostname needs to be defined + return false; + } + + // hostname only -- check if selfhosted name + if (_str_null_or_empty(name->service) && _str_null_or_empty(name->proto) && + strcasecmp(name->host, _mdns_server->hostname) == 0) { + return true; + } + + // service -- check if selfhosted service + mdns_srv_item_t *srv = _mdns_get_service_item(name->service, name->proto, NULL); + if (srv && strcasecmp(_mdns_server->hostname, srv->service->hostname) == 0) { + return true; + } + return false; +} + +/** + * @brief Check if the parsed name is ours (matches service or host name) + */ +static bool _mdns_name_is_ours(mdns_name_t *name) +{ + //domain have to be "local" + if (_str_null_or_empty(name->domain) || (strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN) +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES + && strcasecmp(name->domain, "arpa") +#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ + )) { + return false; + } + + //if service and proto are empty, host must match out hostname + if (_str_null_or_empty(name->service) && _str_null_or_empty(name->proto)) { + if (!_str_null_or_empty(name->host) + && !_str_null_or_empty(_mdns_server->hostname) + && _hostname_is_ours(name->host)) { + return true; + } + return false; + } + + //if service or proto is empty, name is invalid + if (_str_null_or_empty(name->service) || _str_null_or_empty(name->proto)) { + return false; + } + + + //find the service + mdns_srv_item_t *service; + if (name->sub) { + service = _mdns_get_service_item_subtype(name->host, name->service, name->proto); + } else if (_str_null_or_empty(name->host)) { + service = _mdns_get_service_item(name->service, name->proto, NULL); + } else { + service = _mdns_get_service_item_instance(name->host, name->service, name->proto, NULL); + } + if (!service) { + return false; + } + + //if query is PTR query and we have service, we have success + if (name->sub || _str_null_or_empty(name->host)) { + return true; + } + + //OK we have host in the name. find what is the instance of the service + const char *instance = _mdns_get_service_instance_name(service->service); + if (instance == NULL) { + return false; + } + + //compare the instance against the name + if (strcasecmp(name->host, instance) == 0) { + return true; + } + + return false; +} + +/** + * @brief read uint16_t from a packet + * @param packet the packet + * @param index index in the packet where the value starts + * + * @return the value + */ +static inline uint16_t _mdns_read_u16(const uint8_t *packet, uint16_t index) +{ + return (uint16_t)(packet[index]) << 8 | packet[index + 1]; +} + +/** + * @brief read uint32_t from a packet + * @param packet the packet + * @param index index in the packet where the value starts + * + * @return the value + */ +static inline uint32_t _mdns_read_u32(const uint8_t *packet, uint16_t index) +{ + return (uint32_t)(packet[index]) << 24 | (uint32_t)(packet[index + 1]) << 16 | (uint32_t)(packet[index + 2]) << 8 | packet[index + 3]; +} + +/** + * @brief reads and formats MDNS FQDN into mdns_name_t structure + * + * @param packet MDNS packet + * @param start Starting point of FQDN + * @param name mdns_name_t structure to populate + * + * @return the address after the parsed FQDN in the packet or NULL on error + */ +static const uint8_t *_mdns_parse_fqdn(const uint8_t *packet, const uint8_t *start, mdns_name_t *name, size_t packet_len) +{ + name->parts = 0; + name->sub = 0; + name->host[0] = 0; + name->service[0] = 0; + name->proto[0] = 0; + name->domain[0] = 0; + name->invalid = false; + + static char buf[MDNS_NAME_BUF_LEN]; + + const uint8_t *next_data = (uint8_t *)_mdns_read_fqdn(packet, start, name, buf, packet_len); + if (!next_data) { + return 0; + } + if (!name->parts || name->invalid) { + return next_data; + } + if (name->parts == 3) { + memmove((uint8_t *)name + (MDNS_NAME_BUF_LEN), (uint8_t *)name, 3 * (MDNS_NAME_BUF_LEN)); + name->host[0] = 0; + } else if (name->parts == 2) { + memmove((uint8_t *)(name->domain), (uint8_t *)(name->service), (MDNS_NAME_BUF_LEN)); + name->service[0] = 0; + name->proto[0] = 0; + } + if (strcasecmp(name->domain, MDNS_DEFAULT_DOMAIN) == 0 || strcasecmp(name->domain, "arpa") == 0) { + return next_data; + } + name->invalid = true; // mark the current name invalid, but continue with other question + return next_data; +} + +/** + * @brief Called from parser to check if question matches particular service + */ +static bool _mdns_question_matches(mdns_parsed_question_t *question, uint16_t type, mdns_srv_item_t *service) +{ + if (question->type != type) { + return false; + } + if (type == MDNS_TYPE_A || type == MDNS_TYPE_AAAA) { + return true; + } else if (type == MDNS_TYPE_PTR || type == MDNS_TYPE_SDPTR) { + if (question->service && question->proto && question->domain + && !strcasecmp(service->service->service, question->service) + && !strcasecmp(service->service->proto, question->proto) + && !strcasecmp(MDNS_DEFAULT_DOMAIN, question->domain)) { + if (!service->service->instance) { + return true; + } else if (service->service->instance && question->host && !strcasecmp(service->service->instance, question->host)) { + return true; + } + } + } else if (service && (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT)) { + const char *name = _mdns_get_service_instance_name(service->service); + if (name && question->host && question->service && question->proto && question->domain + && !strcasecmp(name, question->host) + && !strcasecmp(service->service->service, question->service) + && !strcasecmp(service->service->proto, question->proto) + && !strcasecmp(MDNS_DEFAULT_DOMAIN, question->domain)) { + return true; + } + } + + return false; +} + +/** + * @brief Removes saved question from parsed data + */ +static void _mdns_remove_parsed_question(mdns_parsed_packet_t *parsed_packet, uint16_t type, mdns_srv_item_t *service) +{ + mdns_parsed_question_t *q = parsed_packet->questions; + + if (_mdns_question_matches(q, type, service)) { + parsed_packet->questions = q->next; + mdns_mem_free(q->host); + mdns_mem_free(q->service); + mdns_mem_free(q->proto); + mdns_mem_free(q->domain); + mdns_mem_free(q); + return; + } + + while (q->next) { + mdns_parsed_question_t *p = q->next; + if (_mdns_question_matches(p, type, service)) { + q->next = p->next; + mdns_mem_free(p->host); + mdns_mem_free(p->service); + mdns_mem_free(p->proto); + mdns_mem_free(p->domain); + mdns_mem_free(p); + return; + } + q = q->next; + } +} + +/** + * @brief Get number of items in TXT parsed data + */ +static int _mdns_txt_items_count_get(const uint8_t *data, size_t len) +{ + if (len == 1) { + return 0; + } + + int num_items = 0; + uint16_t i = 0; + size_t partLen = 0; + + while (i < len) { + partLen = data[i++]; + if (!partLen) { + break; + } + if ((i + partLen) > len) { + return -1;//error + } + i += partLen; + num_items++; + } + return num_items; +} + +/** + * @brief Get the length of TXT item's key name + */ +static int _mdns_txt_item_name_get_len(const uint8_t *data, size_t len) +{ + if (*data == '=') { + return -1; + } + for (size_t i = 0; i < len; i++) { + if (data[i] == '=') { + return i; + } + } + return len; +} + +/** + * @brief Create TXT result array from parsed TXT data + */ +static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_item_t **out_txt, uint8_t **out_value_len, + size_t *out_count) +{ + *out_txt = NULL; + *out_count = 0; + uint16_t i = 0, y; + size_t partLen = 0; + int num_items = _mdns_txt_items_count_get(data, len); + if (num_items < 0 || num_items > SIZE_MAX / sizeof(mdns_txt_item_t)) { + // Error: num_items is incorrect (or too large to allocate) + return; + } + + if (!num_items) { + return; + } + + mdns_txt_item_t *txt = (mdns_txt_item_t *)mdns_mem_malloc(sizeof(mdns_txt_item_t) * num_items); + if (!txt) { + HOOK_MALLOC_FAILED; + return; + } + uint8_t *txt_value_len = (uint8_t *)mdns_mem_malloc(num_items); + if (!txt_value_len) { + mdns_mem_free(txt); + HOOK_MALLOC_FAILED; + return; + } + memset(txt, 0, sizeof(mdns_txt_item_t) * num_items); + memset(txt_value_len, 0, num_items); + size_t txt_num = 0; + + while (i < len) { + partLen = data[i++]; + if (!partLen) { + break; + } + + if ((i + partLen) > len) { + goto handle_error;//error + } + + int name_len = _mdns_txt_item_name_get_len(data + i, partLen); + if (name_len < 0 || txt_num >= num_items) {//invalid item (no name or more items than expected) + i += partLen; + continue; + } + char *key = (char *)mdns_mem_malloc(name_len + 1); + if (!key) { + HOOK_MALLOC_FAILED; + goto handle_error;//error + } + mdns_txt_item_t *t = &txt[txt_num]; + uint8_t *value_len = &txt_value_len[txt_num]; + txt_num++; + + memcpy(key, data + i, name_len); + key[name_len] = 0; + i += name_len + 1; + t->key = key; + + int new_value_len = partLen - name_len - 1; + if (new_value_len > 0) { + char *value = (char *)mdns_mem_malloc(new_value_len + 1); + if (!value) { + HOOK_MALLOC_FAILED; + goto handle_error;//error + } + memcpy(value, data + i, new_value_len); + value[new_value_len] = 0; + *value_len = new_value_len; + i += new_value_len; + t->value = value; + } else { + t->value = NULL; + } + } + + *out_txt = txt; + *out_count = txt_num; + *out_value_len = txt_value_len; + return; + +handle_error : + for (y = 0; y < txt_num; y++) { + mdns_txt_item_t *t = &txt[y]; + mdns_mem_free((char *)t->key); + mdns_mem_free((char *)t->value); + } + mdns_mem_free(txt_value_len); + mdns_mem_free(txt); +} + +/** + * @brief Duplicate string or return error + */ +static esp_err_t _mdns_strdup_check(char **out, char *in) +{ + if (in && in[0]) { + *out = mdns_mem_strdup(in); + if (!*out) { + return ESP_FAIL; + } + return ESP_OK; + } + *out = NULL; + return ESP_OK; +} + +/** + * @brief main packet parser + * + * @param packet the packet + */ +void mdns_parse_packet(mdns_rx_packet_t *packet) +{ + static mdns_name_t n; + mdns_header_t header; + const uint8_t *data = _mdns_get_packet_data(packet); + size_t len = _mdns_get_packet_len(packet); + const uint8_t *content = data + MDNS_HEAD_LEN; + bool do_not_reply = false; + mdns_search_once_t *search_result = NULL; + mdns_browse_t *browse_result = NULL; + char *browse_result_instance = NULL; + char *browse_result_service = NULL; + char *browse_result_proto = NULL; + mdns_browse_sync_t *out_sync_browse = NULL; + +#ifdef MDNS_ENABLE_DEBUG + _mdns_dbg_printf("\nRX[%lu][%lu]: ", (unsigned long)packet->tcpip_if, (unsigned long)packet->ip_protocol); +#ifdef CONFIG_LWIP_IPV4 + if (packet->src.type == ESP_IPADDR_TYPE_V4) { + _mdns_dbg_printf("From: " IPSTR ":%u, To: " IPSTR ", ", IP2STR(&packet->src.u_addr.ip4), packet->src_port, IP2STR(&packet->dest.u_addr.ip4)); + } +#endif +#ifdef CONFIG_LWIP_IPV6 + if (packet->src.type == ESP_IPADDR_TYPE_V6) { + _mdns_dbg_printf("From: " IPV6STR ":%u, To: " IPV6STR ", ", IPV62STR(packet->src.u_addr.ip6), packet->src_port, IPV62STR(packet->dest.u_addr.ip6)); + } +#endif + mdns_debug_packet(data, len); +#endif + +#ifndef CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES + // Check if the packet wasn't sent by us +#ifdef CONFIG_LWIP_IPV4 + if (packet->ip_protocol == MDNS_IP_PROTOCOL_V4) { + esp_netif_ip_info_t if_ip_info; + if (esp_netif_get_ip_info(_mdns_get_esp_netif(packet->tcpip_if), &if_ip_info) == ESP_OK && + memcmp(&if_ip_info.ip.addr, &packet->src.u_addr.ip4.addr, sizeof(esp_ip4_addr_t)) == 0) { + return; + } + } +#endif /* CONFIG_LWIP_IPV4 */ +#ifdef CONFIG_LWIP_IPV6 + if (packet->ip_protocol == MDNS_IP_PROTOCOL_V6) { + struct esp_ip6_addr if_ip6; + if (esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(packet->tcpip_if), &if_ip6) == ESP_OK && + memcmp(&if_ip6, &packet->src.u_addr.ip6, sizeof(esp_ip6_addr_t)) == 0) { + return; + } + } +#endif /* CONFIG_LWIP_IPV6 */ +#endif // CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES + + // Check for the minimum size of mdns packet + if (len <= MDNS_HEAD_ADDITIONAL_OFFSET) { + return; + } + + mdns_parsed_packet_t *parsed_packet = (mdns_parsed_packet_t *)mdns_mem_malloc(sizeof(mdns_parsed_packet_t)); + if (!parsed_packet) { + HOOK_MALLOC_FAILED; + return; + } + memset(parsed_packet, 0, sizeof(mdns_parsed_packet_t)); + + mdns_name_t *name = &n; + memset(name, 0, sizeof(mdns_name_t)); + + header.id = _mdns_read_u16(data, MDNS_HEAD_ID_OFFSET); + header.flags = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET); + header.questions = _mdns_read_u16(data, MDNS_HEAD_QUESTIONS_OFFSET); + header.answers = _mdns_read_u16(data, MDNS_HEAD_ANSWERS_OFFSET); + header.servers = _mdns_read_u16(data, MDNS_HEAD_SERVERS_OFFSET); + header.additional = _mdns_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET); + + if (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE && packet->src_port != MDNS_SERVICE_PORT) { + mdns_mem_free(parsed_packet); + return; + } + + //if we have not set the hostname, we can not answer questions + if (header.questions && !header.answers && _str_null_or_empty(_mdns_server->hostname)) { + mdns_mem_free(parsed_packet); + return; + } + + parsed_packet->tcpip_if = packet->tcpip_if; + parsed_packet->ip_protocol = packet->ip_protocol; + parsed_packet->multicast = packet->multicast; + parsed_packet->authoritative = (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE); + parsed_packet->distributed = header.flags == MDNS_FLAGS_DISTRIBUTED; + parsed_packet->id = header.id; + esp_netif_ip_addr_copy(&parsed_packet->src, &packet->src); + parsed_packet->src_port = packet->src_port; + parsed_packet->records = NULL; + + if (header.questions) { + uint8_t qs = header.questions; + + while (qs--) { + content = _mdns_parse_fqdn(data, content, name, len); + if (!content) { + header.answers = 0; + header.additional = 0; + header.servers = 0; + goto clear_rx_packet;//error + } + + if (content + MDNS_CLASS_OFFSET + 1 >= data + len) { + goto clear_rx_packet; // malformed packet, won't read behind it + } + uint16_t type = _mdns_read_u16(content, MDNS_TYPE_OFFSET); + uint16_t mdns_class = _mdns_read_u16(content, MDNS_CLASS_OFFSET); + bool unicast = !!(mdns_class & 0x8000); + mdns_class &= 0x7FFF; + content = content + 4; + + if (mdns_class != 0x0001 || name->invalid) {//bad class or invalid name for this question entry + continue; + } + + if (_mdns_name_is_discovery(name, type)) { + //service discovery + parsed_packet->discovery = true; + mdns_srv_item_t *a = _mdns_server->services; + while (a) { + mdns_parsed_question_t *question = (mdns_parsed_question_t *)mdns_mem_calloc(1, sizeof(mdns_parsed_question_t)); + if (!question) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + question->next = parsed_packet->questions; + parsed_packet->questions = question; + + question->unicast = unicast; + question->type = MDNS_TYPE_SDPTR; + question->host = NULL; + question->service = mdns_mem_strdup(a->service->service); + question->proto = mdns_mem_strdup(a->service->proto); + question->domain = mdns_mem_strdup(MDNS_DEFAULT_DOMAIN); + if (!question->service || !question->proto || !question->domain) { + goto clear_rx_packet; + } + a = a->next; + } + continue; + } + if (!_mdns_name_is_ours(name)) { + continue; + } + + if (type == MDNS_TYPE_ANY && !_str_null_or_empty(name->host)) { + parsed_packet->probe = true; + } + + mdns_parsed_question_t *question = (mdns_parsed_question_t *)mdns_mem_calloc(1, sizeof(mdns_parsed_question_t)); + if (!question) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + question->next = parsed_packet->questions; + parsed_packet->questions = question; + + question->unicast = unicast; + question->type = type; + question->sub = name->sub; + if (_mdns_strdup_check(&(question->host), name->host) + || _mdns_strdup_check(&(question->service), name->service) + || _mdns_strdup_check(&(question->proto), name->proto) + || _mdns_strdup_check(&(question->domain), name->domain)) { + goto clear_rx_packet; + } + } + } + + if (header.questions && !parsed_packet->questions && !parsed_packet->discovery && !header.answers) { + goto clear_rx_packet; + } else if (header.answers || header.servers || header.additional) { + uint16_t recordIndex = 0; + + while (content < (data + len)) { + + content = _mdns_parse_fqdn(data, content, name, len); + if (!content) { + goto clear_rx_packet;//error + } + + if (content + MDNS_LEN_OFFSET + 1 >= data + len) { + goto clear_rx_packet; // malformed packet, won't read behind it + } + uint16_t type = _mdns_read_u16(content, MDNS_TYPE_OFFSET); + uint16_t mdns_class = _mdns_read_u16(content, MDNS_CLASS_OFFSET); + uint32_t ttl = _mdns_read_u32(content, MDNS_TTL_OFFSET); + uint16_t data_len = _mdns_read_u16(content, MDNS_LEN_OFFSET); + const uint8_t *data_ptr = content + MDNS_DATA_OFFSET; + mdns_class &= 0x7FFF; + + content = data_ptr + data_len; + if (content > (data + len) || data_len == 0) { + goto clear_rx_packet; + } + + bool discovery = false; + bool ours = false; + mdns_srv_item_t *service = NULL; + mdns_parsed_record_type_t record_type = MDNS_ANSWER; + + if (recordIndex >= (header.answers + header.servers)) { + record_type = MDNS_EXTRA; + } else if (recordIndex >= (header.answers)) { + record_type = MDNS_NS; + } + recordIndex++; + + if (type == MDNS_TYPE_NSEC || type == MDNS_TYPE_OPT) { + //skip NSEC and OPT + continue; + } + + if (parsed_packet->discovery && _mdns_name_is_discovery(name, type)) { + discovery = true; + } else if (!name->sub && _mdns_name_is_ours(name)) { + ours = true; + if (name->service[0] && name->proto[0]) { + service = _mdns_get_service_item(name->service, name->proto, NULL); + } + } else { + if ((header.flags & MDNS_FLAGS_QUERY_REPSONSE) == 0 || record_type == MDNS_NS) { + //skip this record + continue; + } + search_result = _mdns_search_find_from(_mdns_server->search_once, name, type, packet->tcpip_if, packet->ip_protocol); + browse_result = _mdns_browse_find_from(_mdns_server->browse, name, type, packet->tcpip_if, packet->ip_protocol); + if (browse_result) { + if (!out_sync_browse) { + // will be freed in function `_mdns_browse_sync` + out_sync_browse = (mdns_browse_sync_t *)mdns_mem_malloc(sizeof(mdns_browse_sync_t)); + if (!out_sync_browse) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + out_sync_browse->browse = browse_result; + out_sync_browse->sync_result = NULL; + } + if (!browse_result_service) { + browse_result_service = (char *)mdns_mem_malloc(MDNS_NAME_BUF_LEN); + if (!browse_result_service) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + } + memcpy(browse_result_service, browse_result->service, MDNS_NAME_BUF_LEN); + if (!browse_result_proto) { + browse_result_proto = (char *)mdns_mem_malloc(MDNS_NAME_BUF_LEN); + if (!browse_result_proto) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + } + memcpy(browse_result_proto, browse_result->proto, MDNS_NAME_BUF_LEN); + if (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT) { + if (!browse_result_instance) { + browse_result_instance = (char *)mdns_mem_malloc(MDNS_NAME_BUF_LEN); + if (!browse_result_instance) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + } + memcpy(browse_result_instance, name->host, MDNS_NAME_BUF_LEN); + } + } + } + + if (type == MDNS_TYPE_PTR) { + if (!_mdns_parse_fqdn(data, data_ptr, name, len)) { + continue;//error + } + if (search_result) { + _mdns_search_result_add_ptr(search_result, name->host, name->service, name->proto, + packet->tcpip_if, packet->ip_protocol, ttl); + } else if ((discovery || ours) && !name->sub && _mdns_name_is_ours(name)) { + if (name->host[0]) { + service = _mdns_get_service_item_instance(name->host, name->service, name->proto, NULL); + } else { + service = _mdns_get_service_item(name->service, name->proto, NULL); + } + if (discovery && service) { + _mdns_remove_parsed_question(parsed_packet, MDNS_TYPE_SDPTR, service); + } else if (service && parsed_packet->questions && !parsed_packet->probe) { + _mdns_remove_parsed_question(parsed_packet, type, service); + } else if (service) { + //check if TTL is more than half of the full TTL value (4500) + if (ttl > (MDNS_ANSWER_PTR_TTL / 2)) { + _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service); + } + } + if (service) { + mdns_parsed_record_t *record = mdns_mem_malloc(sizeof(mdns_parsed_record_t)); + if (!record) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + record->next = parsed_packet->records; + parsed_packet->records = record; + record->type = MDNS_TYPE_PTR; + record->record_type = MDNS_ANSWER; + record->ttl = ttl; + record->host = NULL; + record->service = NULL; + record->proto = NULL; + if (name->host[0]) { + record->host = mdns_mem_malloc(MDNS_NAME_BUF_LEN); + if (!record->host) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + memcpy(record->host, name->host, MDNS_NAME_BUF_LEN); + } + if (name->service[0]) { + record->service = mdns_mem_malloc(MDNS_NAME_BUF_LEN); + if (!record->service) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + memcpy(record->service, name->service, MDNS_NAME_BUF_LEN); + } + if (name->proto[0]) { + record->proto = mdns_mem_malloc(MDNS_NAME_BUF_LEN); + if (!record->proto) { + HOOK_MALLOC_FAILED; + goto clear_rx_packet; + } + memcpy(record->proto, name->proto, MDNS_NAME_BUF_LEN); + } + } + } + } else if (type == MDNS_TYPE_SRV) { + mdns_result_t *result = NULL; + if (search_result && search_result->type == MDNS_TYPE_PTR) { + result = search_result->result; + while (result) { + if (_mdns_get_esp_netif(packet->tcpip_if) == result->esp_netif + && packet->ip_protocol == result->ip_protocol + && result->instance_name && !strcmp(name->host, result->instance_name)) { + break; + } + result = result->next; + } + if (!result) { + result = _mdns_search_result_add_ptr(search_result, name->host, name->service, name->proto, + packet->tcpip_if, packet->ip_protocol, ttl); + if (!result) { + continue;//error + } + } + } + bool is_selfhosted = _mdns_name_is_selfhosted(name); + if (!_mdns_parse_fqdn(data, data_ptr + MDNS_SRV_FQDN_OFFSET, name, len)) { + continue;//error + } + if (data_ptr + MDNS_SRV_PORT_OFFSET + 1 >= data + len) { + goto clear_rx_packet; // malformed packet, won't read behind it + } + uint16_t priority = _mdns_read_u16(data_ptr, MDNS_SRV_PRIORITY_OFFSET); + uint16_t weight = _mdns_read_u16(data_ptr, MDNS_SRV_WEIGHT_OFFSET); + uint16_t port = _mdns_read_u16(data_ptr, MDNS_SRV_PORT_OFFSET); + + if (browse_result) { + _mdns_browse_result_add_srv(browse_result, name->host, browse_result_instance, browse_result_service, + browse_result_proto, port, packet->tcpip_if, packet->ip_protocol, ttl, out_sync_browse); + } + if (search_result) { + if (search_result->type == MDNS_TYPE_PTR) { + if (!result->hostname) { // assign host/port for this entry only if not previously set + result->port = port; + result->hostname = mdns_mem_strdup(name->host); + } + } else { + _mdns_search_result_add_srv(search_result, name->host, port, packet->tcpip_if, packet->ip_protocol, ttl); + } + } else if (ours) { + if (parsed_packet->questions && !parsed_packet->probe) { + _mdns_remove_parsed_question(parsed_packet, type, service); + continue; + } else if (parsed_packet->distributed) { + _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service); + continue; + } + if (!is_selfhosted) { + continue; + } + //detect collision (-1=won, 0=none, 1=lost) + int col = 0; + if (mdns_class > 1) { + col = 1; + } else if (!mdns_class) { + col = -1; + } else if (service) { // only detect srv collision if service existed + col = _mdns_check_srv_collision(service->service, priority, weight, port, name->host, name->domain); + } + if (service && col && (parsed_packet->probe || parsed_packet->authoritative)) { + if (col > 0 || !port) { + do_not_reply = true; + if (_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { + _mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].failed_probes++; + if (!_str_null_or_empty(service->service->instance)) { + char *new_instance = _mdns_mangle_name((char *)service->service->instance); + if (new_instance) { + mdns_mem_free((char *)service->service->instance); + service->service->instance = new_instance; + } + _mdns_probe_all_pcbs(&service, 1, false, false); + } else if (!_str_null_or_empty(_mdns_server->instance)) { + char *new_instance = _mdns_mangle_name((char *)_mdns_server->instance); + if (new_instance) { + mdns_mem_free((char *)_mdns_server->instance); + _mdns_server->instance = new_instance; + } + _mdns_restart_all_pcbs_no_instance(); + } else { + char *new_host = _mdns_mangle_name((char *)_mdns_server->hostname); + if (new_host) { + _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); + mdns_mem_free((char *)_mdns_server->hostname); + _mdns_server->hostname = new_host; + _mdns_self_host.hostname = new_host; + } + _mdns_restart_all_pcbs(); + } + } else if (service) { + _mdns_pcb_send_bye(packet->tcpip_if, packet->ip_protocol, &service, 1, false); + _mdns_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, &service, 1, false); + } + } + } else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions) { + _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service); + } + } + } else if (type == MDNS_TYPE_TXT) { + mdns_txt_item_t *txt = NULL; + uint8_t *txt_value_len = NULL; + size_t txt_count = 0; + + mdns_result_t *result = NULL; + if (browse_result) { + _mdns_result_txt_create(data_ptr, data_len, &txt, &txt_value_len, &txt_count); + _mdns_browse_result_add_txt(browse_result, browse_result_instance, browse_result_service, browse_result_proto, + txt, txt_value_len, txt_count, packet->tcpip_if, packet->ip_protocol, ttl, out_sync_browse); + } + if (search_result) { + if (search_result->type == MDNS_TYPE_PTR) { + result = search_result->result; + while (result) { + if (_mdns_get_esp_netif(packet->tcpip_if) == result->esp_netif + && packet->ip_protocol == result->ip_protocol + && result->instance_name && !strcmp(name->host, result->instance_name)) { + break; + } + result = result->next; + } + if (!result) { + result = _mdns_search_result_add_ptr(search_result, name->host, name->service, name->proto, + packet->tcpip_if, packet->ip_protocol, ttl); + if (!result) { + continue;//error + } + } + if (!result->txt) { + _mdns_result_txt_create(data_ptr, data_len, &txt, &txt_value_len, &txt_count); + if (txt_count) { + result->txt = txt; + result->txt_count = txt_count; + result->txt_value_len = txt_value_len; + } + } + } else { + _mdns_result_txt_create(data_ptr, data_len, &txt, &txt_value_len, &txt_count); + if (txt_count) { + _mdns_search_result_add_txt(search_result, txt, txt_value_len, txt_count, packet->tcpip_if, packet->ip_protocol, ttl); + } + } + } else if (ours) { + if (parsed_packet->questions && !parsed_packet->probe && service) { + _mdns_remove_parsed_question(parsed_packet, type, service); + continue; + } + if (!_mdns_name_is_selfhosted(name)) { + continue; + } + //detect collision (-1=won, 0=none, 1=lost) + int col = 0; + if (mdns_class > 1) { + col = 1; + } else if (!mdns_class) { + col = -1; + } else if (service) { // only detect txt collision if service existed + col = _mdns_check_txt_collision(service->service, data_ptr, data_len); + } + if (col && !_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running && service) { + do_not_reply = true; + _mdns_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, &service, 1, true); + } else if (ttl > (MDNS_ANSWER_TXT_TTL / 2) && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { + _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, service); + } + } + + } +#ifdef CONFIG_LWIP_IPV6 + else if (type == MDNS_TYPE_AAAA) {//ipv6 + esp_ip_addr_t ip6; + ip6.type = ESP_IPADDR_TYPE_V6; + memcpy(ip6.u_addr.ip6.addr, data_ptr, MDNS_ANSWER_AAAA_SIZE); + if (browse_result) { + _mdns_browse_result_add_ip(browse_result, name->host, &ip6, packet->tcpip_if, packet->ip_protocol, ttl, out_sync_browse); + } + if (search_result) { + //check for more applicable searches (PTR & A/AAAA at the same time) + while (search_result) { + _mdns_search_result_add_ip(search_result, name->host, &ip6, packet->tcpip_if, packet->ip_protocol, ttl); + search_result = _mdns_search_find_from(search_result->next, name, type, packet->tcpip_if, packet->ip_protocol); + } + } else if (ours) { + if (parsed_packet->questions && !parsed_packet->probe) { + _mdns_remove_parsed_question(parsed_packet, type, NULL); + continue; + } + if (!_mdns_name_is_selfhosted(name)) { + continue; + } + //detect collision (-1=won, 0=none, 1=lost) + int col = 0; + if (mdns_class > 1) { + col = 1; + } else if (!mdns_class) { + col = -1; + } else { + col = _mdns_check_aaaa_collision(&(ip6.u_addr.ip6), packet->tcpip_if); + } + if (col == 2) { + goto clear_rx_packet; + } else if (col == 1) { + do_not_reply = true; + if (_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { + if (col && (parsed_packet->probe || parsed_packet->authoritative)) { + _mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].failed_probes++; + char *new_host = _mdns_mangle_name((char *)_mdns_server->hostname); + if (new_host) { + _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); + mdns_mem_free((char *)_mdns_server->hostname); + _mdns_server->hostname = new_host; + _mdns_self_host.hostname = new_host; + } + _mdns_restart_all_pcbs(); + } + } else { + _mdns_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, NULL, 0, true); + } + } else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { + _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, NULL); + } + } + + } +#endif /* CONFIG_LWIP_IPV6 */ +#ifdef CONFIG_LWIP_IPV4 + else if (type == MDNS_TYPE_A) { + esp_ip_addr_t ip; + ip.type = ESP_IPADDR_TYPE_V4; + memcpy(&(ip.u_addr.ip4.addr), data_ptr, 4); + if (browse_result) { + _mdns_browse_result_add_ip(browse_result, name->host, &ip, packet->tcpip_if, packet->ip_protocol, ttl, out_sync_browse); + } + if (search_result) { + //check for more applicable searches (PTR & A/AAAA at the same time) + while (search_result) { + _mdns_search_result_add_ip(search_result, name->host, &ip, packet->tcpip_if, packet->ip_protocol, ttl); + search_result = _mdns_search_find_from(search_result->next, name, type, packet->tcpip_if, packet->ip_protocol); + } + } else if (ours) { + if (parsed_packet->questions && !parsed_packet->probe) { + _mdns_remove_parsed_question(parsed_packet, type, NULL); + continue; + } + if (!_mdns_name_is_selfhosted(name)) { + continue; + } + //detect collision (-1=won, 0=none, 1=lost) + int col = 0; + if (mdns_class > 1) { + col = 1; + } else if (!mdns_class) { + col = -1; + } else { + col = _mdns_check_a_collision(&(ip.u_addr.ip4), packet->tcpip_if); + } + if (col == 2) { + goto clear_rx_packet; + } else if (col == 1) { + do_not_reply = true; + if (_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { + if (col && (parsed_packet->probe || parsed_packet->authoritative)) { + _mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].failed_probes++; + char *new_host = _mdns_mangle_name((char *)_mdns_server->hostname); + if (new_host) { + _mdns_remap_self_service_hostname(_mdns_server->hostname, new_host); + mdns_mem_free((char *)_mdns_server->hostname); + _mdns_server->hostname = new_host; + _mdns_self_host.hostname = new_host; + } + _mdns_restart_all_pcbs(); + } + } else { + _mdns_init_pcb_probe(packet->tcpip_if, packet->ip_protocol, NULL, 0, true); + } + } else if (ttl > 60 && !col && !parsed_packet->authoritative && !parsed_packet->probe && !parsed_packet->questions && !_mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].probe_running) { + _mdns_remove_scheduled_answer(packet->tcpip_if, packet->ip_protocol, type, NULL); + } + } + + } +#endif /* CONFIG_LWIP_IPV4 */ + } + //end while + if (parsed_packet->authoritative) { + _mdns_search_finish_done(); + } + } + + if (!do_not_reply && _mdns_server->interfaces[packet->tcpip_if].pcbs[packet->ip_protocol].state > PCB_PROBE_3 && (parsed_packet->questions || parsed_packet->discovery)) { + _mdns_create_answer_from_parsed_packet(parsed_packet); + } + if (out_sync_browse) { +#ifdef MDNS_ENABLE_DEBUG + _mdns_dbg_printf("Browse %s%s total result:", out_sync_browse->browse->service, out_sync_browse->browse->proto); + debug_printf_browse_result_all(out_sync_browse->browse->result); +#endif // MDNS_ENABLE_DEBUG + if (out_sync_browse->sync_result) { +#ifdef MDNS_ENABLE_DEBUG + _mdns_dbg_printf("Changed result:"); + debug_printf_browse_result_all(out_sync_browse->sync_result->result); +#endif // MDNS_ENABLE_DEBUG + _mdns_sync_browse_action(ACTION_BROWSE_SYNC, out_sync_browse); + } else { + mdns_mem_free(out_sync_browse); + } + out_sync_browse = NULL; + } + +clear_rx_packet: + while (parsed_packet->questions) { + mdns_parsed_question_t *question = parsed_packet->questions; + parsed_packet->questions = parsed_packet->questions->next; + if (question->host) { + mdns_mem_free(question->host); + } + if (question->service) { + mdns_mem_free(question->service); + } + if (question->proto) { + mdns_mem_free(question->proto); + } + if (question->domain) { + mdns_mem_free(question->domain); + } + mdns_mem_free(question); + } + while (parsed_packet->records) { + mdns_parsed_record_t *record = parsed_packet->records; + parsed_packet->records = parsed_packet->records->next; + if (record->host) { + mdns_mem_free(record->host); + } + if (record->service) { + mdns_mem_free(record->service); + } + if (record->proto) { + mdns_mem_free(record->proto); + } + record->next = NULL; + mdns_mem_free(record); + } + mdns_mem_free(parsed_packet); + mdns_mem_free(browse_result_instance); + mdns_mem_free(browse_result_service); + mdns_mem_free(browse_result_proto); + mdns_mem_free(out_sync_browse); +} + +/** + * @brief Enable mDNS interface + */ +void _mdns_enable_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + if (!mdns_is_netif_ready(tcpip_if, ip_protocol)) { + if (_mdns_pcb_init(tcpip_if, ip_protocol)) { + _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].failed_probes = 0; + return; + } + } + _mdns_restart_pcb(tcpip_if, ip_protocol); +} + +/** + * @brief Disable mDNS interface + */ +void _mdns_disable_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + _mdns_clean_netif_ptr(tcpip_if); + + if (mdns_is_netif_ready(tcpip_if, ip_protocol)) { + _mdns_clear_pcb_tx_queue_head(tcpip_if, ip_protocol); + mdns_pcb_deinit_local(tcpip_if, ip_protocol); + mdns_if_t other_if = _mdns_get_other_if(tcpip_if); + if (other_if != MDNS_MAX_INTERFACES && _mdns_server->interfaces[other_if].pcbs[ip_protocol].state == PCB_DUP) { + _mdns_server->interfaces[other_if].pcbs[ip_protocol].state = PCB_OFF; + _mdns_enable_pcb(other_if, ip_protocol); + } + } + _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].state = PCB_OFF; +} + +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES +static inline char nibble_to_hex(int var) +{ + return var > 9 ? var - 10 + 'a' : var + '0'; +} +#endif + +/** + * @brief Performs interface changes based on system events or custom commands + */ +static void perform_event_action(mdns_if_t mdns_if, mdns_event_actions_t action) +{ + if (!_mdns_server || mdns_if >= MDNS_MAX_INTERFACES) { + return; + } + if (action & MDNS_EVENT_ENABLE_IP4) { + _mdns_enable_pcb(mdns_if, MDNS_IP_PROTOCOL_V4); + } + if (action & MDNS_EVENT_ENABLE_IP6) { + _mdns_enable_pcb(mdns_if, MDNS_IP_PROTOCOL_V6); + } + if (action & MDNS_EVENT_DISABLE_IP4) { + _mdns_disable_pcb(mdns_if, MDNS_IP_PROTOCOL_V4); + } + if (action & MDNS_EVENT_DISABLE_IP6) { + _mdns_disable_pcb(mdns_if, MDNS_IP_PROTOCOL_V6); + } + if (action & MDNS_EVENT_ANNOUNCE_IP4) { + _mdns_announce_pcb(mdns_if, MDNS_IP_PROTOCOL_V4, NULL, 0, true); + } + if (action & MDNS_EVENT_ANNOUNCE_IP6) { + _mdns_announce_pcb(mdns_if, MDNS_IP_PROTOCOL_V6, NULL, 0, true); + } + +#ifdef CONFIG_MDNS_RESPOND_REVERSE_QUERIES +#ifdef CONFIG_LWIP_IPV4 + if (action & MDNS_EVENT_IP4_REVERSE_LOOKUP) { + esp_netif_ip_info_t if_ip_info; + if (esp_netif_get_ip_info(_mdns_get_esp_netif(mdns_if), &if_ip_info) == ESP_OK) { + esp_ip4_addr_t *ip = &if_ip_info.ip; + char *reverse_query_name = NULL; + if (asprintf(&reverse_query_name, "%d.%d.%d.%d.in-addr", + esp_ip4_addr4_16(ip), esp_ip4_addr3_16(ip), + esp_ip4_addr2_16(ip), esp_ip4_addr1_16(ip)) > 0 && reverse_query_name) { + ESP_LOGD(TAG, "Registered reverse query: %s.arpa", reverse_query_name); + _mdns_delegate_hostname_add(reverse_query_name, NULL); + } + } + } +#endif /* CONFIG_LWIP_IPV4 */ +#ifdef CONFIG_LWIP_IPV6 + if (action & MDNS_EVENT_IP6_REVERSE_LOOKUP) { + esp_ip6_addr_t addr6; + if (!esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(mdns_if), &addr6) && !_ipv6_address_is_zero(addr6)) { + uint8_t *paddr = (uint8_t *)&addr6.addr; + const char sub[] = "ip6"; + const size_t query_name_size = 4 * sizeof(addr6.addr) /* (2 nibbles + 2 dots)/per byte of IP address */ + sizeof(sub); + char *reverse_query_name = mdns_mem_malloc(query_name_size); + if (reverse_query_name) { + char *ptr = &reverse_query_name[query_name_size]; // point to the end + memcpy(ptr - sizeof(sub), sub, sizeof(sub)); // copy the IP sub-domain + ptr -= sizeof(sub) + 1; // move before the sub-domain + while (reverse_query_name < ptr) { // continue populating reverse query from the end + *ptr-- = '.'; // nibble by nibble, until we reach the beginning + *ptr-- = nibble_to_hex(((*paddr) >> 4) & 0x0F); + *ptr-- = '.'; + *ptr-- = nibble_to_hex((*paddr) & 0x0F); + paddr++; + } + ESP_LOGD(TAG, "Registered reverse query: %s.arpa", reverse_query_name); + _mdns_delegate_hostname_add(reverse_query_name, NULL); + } + } + } +#endif /* CONFIG_LWIP_IPV6 */ +#endif /* CONFIG_MDNS_RESPOND_REVERSE_QUERIES */ +} + +/** + * @brief Dispatch interface changes based on system events + */ +static inline void post_mdns_disable_pcb(mdns_predef_if_t preset_if, mdns_ip_protocol_t protocol) +{ + mdns_post_custom_action_tcpip_if(mdns_if_from_preset_if(preset_if), protocol == MDNS_IP_PROTOCOL_V4 ? MDNS_EVENT_DISABLE_IP4 : MDNS_EVENT_DISABLE_IP6); +} + +static inline void post_mdns_enable_pcb(mdns_predef_if_t preset_if, mdns_ip_protocol_t protocol) +{ + mdns_post_custom_action_tcpip_if(mdns_if_from_preset_if(preset_if), protocol == MDNS_IP_PROTOCOL_V4 ? MDNS_EVENT_ENABLE_IP4 : MDNS_EVENT_ENABLE_IP6); +} + +static inline void post_mdns_announce_pcb(mdns_predef_if_t preset_if, mdns_ip_protocol_t protocol) +{ + mdns_post_custom_action_tcpip_if(mdns_if_from_preset_if(preset_if), protocol == MDNS_IP_PROTOCOL_V4 ? MDNS_EVENT_ANNOUNCE_IP4 : MDNS_EVENT_ANNOUNCE_IP6); +} + +#if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH +void mdns_preset_if_handle_system_event(void *arg, esp_event_base_t event_base, + int32_t event_id, void *event_data) +{ + if (!_mdns_server) { + return; + } + +#if MDNS_ESP_WIFI_ENABLED && (CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP) + if (event_base == WIFI_EVENT) { + esp_netif_dhcp_status_t dcst; + switch (event_id) { + case WIFI_EVENT_STA_CONNECTED: + if (!esp_netif_dhcpc_get_status(esp_netif_from_preset_if(MDNS_IF_STA), &dcst)) { + if (dcst == ESP_NETIF_DHCP_STOPPED) { + post_mdns_enable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4); + } + } + break; + case WIFI_EVENT_STA_DISCONNECTED: + post_mdns_disable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4); + post_mdns_disable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V6); + break; + case WIFI_EVENT_AP_START: + post_mdns_enable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V4); + break; + case WIFI_EVENT_AP_STOP: + post_mdns_disable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V4); + post_mdns_disable_pcb(MDNS_IF_AP, MDNS_IP_PROTOCOL_V6); + break; + default: + break; + } + } else +#endif +#if CONFIG_ETH_ENABLED && CONFIG_MDNS_PREDEF_NETIF_ETH + if (event_base == ETH_EVENT) { + esp_netif_dhcp_status_t dcst; + switch (event_id) { + case ETHERNET_EVENT_CONNECTED: + if (!esp_netif_dhcpc_get_status(esp_netif_from_preset_if(MDNS_IF_ETH), &dcst)) { + if (dcst == ESP_NETIF_DHCP_STOPPED) { + post_mdns_enable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4); + } + } + break; + case ETHERNET_EVENT_DISCONNECTED: + post_mdns_disable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4); + post_mdns_disable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V6); + break; + default: + break; + } + } else +#endif + if (event_base == IP_EVENT) { + switch (event_id) { + case IP_EVENT_STA_GOT_IP: + post_mdns_enable_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V4); + post_mdns_announce_pcb(MDNS_IF_STA, MDNS_IP_PROTOCOL_V6); + break; +#if CONFIG_ETH_ENABLED && CONFIG_MDNS_PREDEF_NETIF_ETH + case IP_EVENT_ETH_GOT_IP: + post_mdns_enable_pcb(MDNS_IF_ETH, MDNS_IP_PROTOCOL_V4); + break; +#endif + case IP_EVENT_GOT_IP6: { + ip_event_got_ip6_t *event = (ip_event_got_ip6_t *) event_data; + mdns_if_t mdns_if = _mdns_get_if_from_esp_netif(event->esp_netif); + if (mdns_if >= MDNS_MAX_INTERFACES) { + return; + } + post_mdns_enable_pcb(mdns_if, MDNS_IP_PROTOCOL_V6); + post_mdns_announce_pcb(mdns_if, MDNS_IP_PROTOCOL_V4); + mdns_browse_t *browse = _mdns_server->browse; + while (browse) { + _mdns_browse_send(browse, mdns_if); + browse = browse->next; + } + } + break; + default: + break; + } + } +} +#endif /* CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH */ + +/* + * MDNS Search + * */ + +/** + * @brief Free search structure (except the results) + */ +static void _mdns_search_free(mdns_search_once_t *search) +{ + mdns_mem_free(search->instance); + mdns_mem_free(search->service); + mdns_mem_free(search->proto); + vSemaphoreDelete(search->done_semaphore); + mdns_mem_free(search); +} + +/** + * @brief Allocate new search structure + */ +static mdns_search_once_t *_mdns_search_init(const char *name, const char *service, const char *proto, uint16_t type, bool unicast, + uint32_t timeout, uint8_t max_results, mdns_query_notify_t notifier) +{ + mdns_search_once_t *search = (mdns_search_once_t *)mdns_mem_malloc(sizeof(mdns_search_once_t)); + if (!search) { + HOOK_MALLOC_FAILED; + return NULL; + } + memset(search, 0, sizeof(mdns_search_once_t)); + + search->done_semaphore = xSemaphoreCreateBinary(); + if (!search->done_semaphore) { + mdns_mem_free(search); + return NULL; + } + + if (!_str_null_or_empty(name)) { + search->instance = mdns_mem_strndup(name, MDNS_NAME_BUF_LEN - 1); + if (!search->instance) { + _mdns_search_free(search); + return NULL; + } + } + + if (!_str_null_or_empty(service)) { + search->service = mdns_mem_strndup(service, MDNS_NAME_BUF_LEN - 1); + if (!search->service) { + _mdns_search_free(search); + return NULL; + } + } + + if (!_str_null_or_empty(proto)) { + search->proto = mdns_mem_strndup(proto, MDNS_NAME_BUF_LEN - 1); + if (!search->proto) { + _mdns_search_free(search); + return NULL; + } + } + + search->type = type; + search->unicast = unicast; + search->timeout = timeout; + search->num_results = 0; + search->max_results = max_results; + search->result = NULL; + search->state = SEARCH_INIT; + search->sent_at = 0; + search->started_at = xTaskGetTickCount() * portTICK_PERIOD_MS; + search->notifier = notifier; + search->next = NULL; + + return search; +} + +/** + * @brief Mark search as finished and remove it from search chain + */ +static void _mdns_search_finish(mdns_search_once_t *search) +{ + search->state = SEARCH_OFF; + queueDetach(mdns_search_once_t, _mdns_server->search_once, search); + if (search->notifier) { + search->notifier(search); + } + xSemaphoreGive(search->done_semaphore); +} + +/** + * @brief Add new search to the search chain + */ +static void _mdns_search_add(mdns_search_once_t *search) +{ + search->next = _mdns_server->search_once; + _mdns_server->search_once = search; +} + +/** + * @brief Called from parser to finish any searches that have reached maximum results + */ +static void _mdns_search_finish_done(void) +{ + mdns_search_once_t *search = _mdns_server->search_once; + mdns_search_once_t *s = NULL; + while (search) { + s = search; + search = search->next; + if (s->max_results && s->num_results >= s->max_results) { + _mdns_search_finish(s); + } + } +} + +/** + * @brief Create linked IP (copy) from parsed one + */ +static mdns_ip_addr_t *_mdns_result_addr_create_ip(esp_ip_addr_t *ip) +{ + mdns_ip_addr_t *a = (mdns_ip_addr_t *)mdns_mem_malloc(sizeof(mdns_ip_addr_t)); + if (!a) { + HOOK_MALLOC_FAILED; + return NULL; + } + memset(a, 0, sizeof(mdns_ip_addr_t)); + a->addr.type = ip->type; + if (ip->type == ESP_IPADDR_TYPE_V6) { + memcpy(a->addr.u_addr.ip6.addr, ip->u_addr.ip6.addr, 16); + } else { + a->addr.u_addr.ip4.addr = ip->u_addr.ip4.addr; + } + return a; +} + +static inline void _mdns_result_update_ttl(mdns_result_t *r, uint32_t ttl) +{ + r->ttl = r->ttl < ttl ? r->ttl : ttl; +} + +/** + * @brief Chain new IP to search result + */ +static void _mdns_result_add_ip(mdns_result_t *r, esp_ip_addr_t *ip) +{ + mdns_ip_addr_t *a = r->addr; + while (a) { + if (a->addr.type == ip->type) { +#ifdef CONFIG_LWIP_IPV4 + if (a->addr.type == ESP_IPADDR_TYPE_V4 && a->addr.u_addr.ip4.addr == ip->u_addr.ip4.addr) { + return; + } +#endif +#ifdef CONFIG_LWIP_IPV6 + if (a->addr.type == ESP_IPADDR_TYPE_V6 && !memcmp(a->addr.u_addr.ip6.addr, ip->u_addr.ip6.addr, 16)) { + return; + } +#endif + } + a = a->next; + } + a = _mdns_result_addr_create_ip(ip); + if (!a) { + return; + } + a->next = r->addr; + r->addr = a; +} + +/** + * @brief Called from parser to add A/AAAA data to search result + */ +static void _mdns_search_result_add_ip(mdns_search_once_t *search, const char *hostname, esp_ip_addr_t *ip, + mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl) +{ + mdns_result_t *r = NULL; + mdns_ip_addr_t *a = NULL; + + if ((search->type == MDNS_TYPE_A && ip->type == ESP_IPADDR_TYPE_V4) + || (search->type == MDNS_TYPE_AAAA && ip->type == ESP_IPADDR_TYPE_V6) + || search->type == MDNS_TYPE_ANY) { + r = search->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol) { + _mdns_result_add_ip(r, ip); + _mdns_result_update_ttl(r, ttl); + return; + } + r = r->next; + } + if (!search->max_results || search->num_results < search->max_results) { + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); + if (!r) { + HOOK_MALLOC_FAILED; + return; + } + + memset(r, 0, sizeof(mdns_result_t)); + + a = _mdns_result_addr_create_ip(ip); + if (!a) { + mdns_mem_free(r); + return; + } + a->next = r->addr; + r->hostname = mdns_mem_strdup(hostname); + r->addr = a; + r->esp_netif = _mdns_get_esp_netif(tcpip_if); + r->ip_protocol = ip_protocol; + r->next = search->result; + r->ttl = ttl; + search->result = r; + search->num_results++; + } + } else if (search->type == MDNS_TYPE_PTR || search->type == MDNS_TYPE_SRV) { + r = search->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) { + _mdns_result_add_ip(r, ip); + _mdns_result_update_ttl(r, ttl); + break; + } + r = r->next; + } + } +} + +/** + * @brief Called from parser to add PTR data to search result + */ +static mdns_result_t *_mdns_search_result_add_ptr(mdns_search_once_t *search, const char *instance, + const char *service_type, const char *proto, mdns_if_t tcpip_if, + mdns_ip_protocol_t ip_protocol, uint32_t ttl) +{ + mdns_result_t *r = search->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->instance_name) && !strcasecmp(instance, r->instance_name)) { + _mdns_result_update_ttl(r, ttl); + return r; + } + r = r->next; + } + if (!search->max_results || search->num_results < search->max_results) { + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); + if (!r) { + HOOK_MALLOC_FAILED; + return NULL; + } + + memset(r, 0, sizeof(mdns_result_t)); + r->instance_name = mdns_mem_strdup(instance); + r->service_type = mdns_mem_strdup(service_type); + r->proto = mdns_mem_strdup(proto); + if (!r->instance_name) { + mdns_mem_free(r); + return NULL; + } + + r->esp_netif = _mdns_get_esp_netif(tcpip_if); + r->ip_protocol = ip_protocol; + r->ttl = ttl; + r->next = search->result; + search->result = r; + search->num_results++; + return r; + } + return NULL; +} + +/** + * @brief Called from parser to add SRV data to search result + */ +static void _mdns_search_result_add_srv(mdns_search_once_t *search, const char *hostname, uint16_t port, + mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl) +{ + mdns_result_t *r = search->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) { + _mdns_result_update_ttl(r, ttl); + return; + } + r = r->next; + } + if (!search->max_results || search->num_results < search->max_results) { + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); + if (!r) { + HOOK_MALLOC_FAILED; + return; + } + + memset(r, 0, sizeof(mdns_result_t)); + r->hostname = mdns_mem_strdup(hostname); + if (!r->hostname) { + mdns_mem_free(r); + return; + } + if (search->instance) { + r->instance_name = mdns_mem_strdup(search->instance); + } + r->service_type = mdns_mem_strdup(search->service); + r->proto = mdns_mem_strdup(search->proto); + r->port = port; + r->esp_netif = _mdns_get_esp_netif(tcpip_if); + r->ip_protocol = ip_protocol; + r->ttl = ttl; + r->next = search->result; + search->result = r; + search->num_results++; + } +} + +/** + * @brief Called from parser to add TXT data to search result + */ +static void _mdns_search_result_add_txt(mdns_search_once_t *search, mdns_txt_item_t *txt, uint8_t *txt_value_len, + size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, + uint32_t ttl) +{ + mdns_result_t *r = search->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol) { + if (r->txt) { + goto free_txt; + } + r->txt = txt; + r->txt_value_len = txt_value_len; + r->txt_count = txt_count; + _mdns_result_update_ttl(r, ttl); + return; + } + r = r->next; + } + if (!search->max_results || search->num_results < search->max_results) { + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); + if (!r) { + HOOK_MALLOC_FAILED; + goto free_txt; + } + + memset(r, 0, sizeof(mdns_result_t)); + r->txt = txt; + r->txt_value_len = txt_value_len; + r->txt_count = txt_count; + r->esp_netif = _mdns_get_esp_netif(tcpip_if); + r->ip_protocol = ip_protocol; + r->ttl = ttl; + r->next = search->result; + search->result = r; + search->num_results++; + } + return; + +free_txt: + for (size_t i = 0; i < txt_count; i++) { + mdns_mem_free((char *)(txt[i].key)); + mdns_mem_free((char *)(txt[i].value)); + } + mdns_mem_free(txt); + mdns_mem_free(txt_value_len); +} + +/** + * @brief Called from packet parser to find matching running search + */ +static mdns_search_once_t *_mdns_search_find_from(mdns_search_once_t *s, mdns_name_t *name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + mdns_result_t *r = NULL; + while (s) { + if (s->state == SEARCH_OFF) { + s = s->next; + continue; + } + + if (type == MDNS_TYPE_A || type == MDNS_TYPE_AAAA) { + if ((s->type == MDNS_TYPE_ANY && s->service != NULL) + || (s->type != MDNS_TYPE_ANY && s->type != type && s->type != MDNS_TYPE_PTR && s->type != MDNS_TYPE_SRV)) { + s = s->next; + continue; + } + if (s->type != MDNS_TYPE_PTR && s->type != MDNS_TYPE_SRV) { + if (!strcasecmp(name->host, s->instance)) { + return s; + } + s = s->next; + continue; + } + r = s->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->hostname) && !strcasecmp(name->host, r->hostname)) { + return s; + } + r = r->next; + } + s = s->next; + continue; + } + + if (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT) { + if ((s->type == MDNS_TYPE_ANY && s->service == NULL) + || (s->type != MDNS_TYPE_ANY && s->type != type && s->type != MDNS_TYPE_PTR)) { + s = s->next; + continue; + } + if (strcasecmp(name->service, s->service) + || strcasecmp(name->proto, s->proto)) { + s = s->next; + continue; + } + if (s->type != MDNS_TYPE_PTR) { + if (s->instance && strcasecmp(name->host, s->instance) == 0) { + return s; + } + s = s->next; + continue; + } + return s; + } + + if (type == MDNS_TYPE_PTR && type == s->type && !strcasecmp(name->service, s->service) && !strcasecmp(name->proto, s->proto)) { + return s; + } + + s = s->next; + } + + return NULL; +} + +/** + * @brief Create search packet for particular interface + */ +static mdns_tx_packet_t *_mdns_create_search_packet(mdns_search_once_t *search, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + mdns_result_t *r = NULL; + mdns_tx_packet_t *packet = _mdns_alloc_packet_default(tcpip_if, ip_protocol); + if (!packet) { + return NULL; + } + + mdns_out_question_t *q = (mdns_out_question_t *)mdns_mem_malloc(sizeof(mdns_out_question_t)); + if (!q) { + HOOK_MALLOC_FAILED; + _mdns_free_tx_packet(packet); + return NULL; + } + q->next = NULL; + q->unicast = search->unicast; + q->type = search->type; + q->host = search->instance; + q->service = search->service; + q->proto = search->proto; + q->domain = MDNS_DEFAULT_DOMAIN; + q->own_dynamic_memory = false; + queueToEnd(mdns_out_question_t, packet->questions, q); + + if (search->type == MDNS_TYPE_PTR) { + r = search->result; + while (r) { + //full record on the same interface is available + if (r->esp_netif != _mdns_get_esp_netif(tcpip_if) || r->ip_protocol != ip_protocol || r->instance_name == NULL || r->hostname == NULL || r->addr == NULL) { + r = r->next; + continue; + } + mdns_out_answer_t *a = (mdns_out_answer_t *)mdns_mem_malloc(sizeof(mdns_out_answer_t)); + if (!a) { + HOOK_MALLOC_FAILED; + _mdns_free_tx_packet(packet); + return NULL; + } + a->type = MDNS_TYPE_PTR; + a->service = NULL; + a->custom_instance = r->instance_name; + a->custom_service = search->service; + a->custom_proto = search->proto; + a->bye = false; + a->flush = false; + a->next = NULL; + queueToEnd(mdns_out_answer_t, packet->answers, a); + r = r->next; + } + } + + return packet; +} + +/** + * @brief Send search packet to particular interface + */ +static void _mdns_search_send_pcb(mdns_search_once_t *search, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + mdns_tx_packet_t *packet = NULL; + if (mdns_is_netif_ready(tcpip_if, ip_protocol) && _mdns_server->interfaces[tcpip_if].pcbs[ip_protocol].state > PCB_INIT) { + packet = _mdns_create_search_packet(search, tcpip_if, ip_protocol); + if (!packet) { + return; + } + _mdns_dispatch_tx_packet(packet); + _mdns_free_tx_packet(packet); + } +} + +/** + * @brief Send search packet to all available interfaces + */ +static void _mdns_search_send(mdns_search_once_t *search) +{ + mdns_search_once_t *queue = _mdns_server->search_once; + bool found = false; + // looking for this search in active searches + while (queue) { + if (queue == search) { + found = true; + break; + } + queue = queue->next; + } + + if (!found) { + // no longer active -> skip sending this search + return; + } + + uint8_t i, j; + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { + for (j = 0; j < MDNS_IP_PROTOCOL_MAX; j++) { + _mdns_search_send_pcb(search, (mdns_if_t)i, (mdns_ip_protocol_t)j); + } + } +} + +static void _mdns_tx_handle_packet(mdns_tx_packet_t *p) +{ + mdns_tx_packet_t *a = NULL; + mdns_out_question_t *q = NULL; + mdns_pcb_t *pcb = &_mdns_server->interfaces[p->tcpip_if].pcbs[p->ip_protocol]; + uint32_t send_after = 1000; + + if (pcb->state == PCB_OFF) { + _mdns_free_tx_packet(p); + return; + } + _mdns_dispatch_tx_packet(p); + + switch (pcb->state) { + case PCB_PROBE_1: + q = p->questions; + while (q) { + q->unicast = false; + q = q->next; + } + //fallthrough + case PCB_PROBE_2: + _mdns_schedule_tx_packet(p, 250); + pcb->state = (mdns_pcb_state_t)((uint8_t)(pcb->state) + 1); + break; + case PCB_PROBE_3: + a = _mdns_create_announce_from_probe(p); + if (!a) { + _mdns_schedule_tx_packet(p, 250); + break; + } + pcb->probe_running = false; + pcb->probe_ip = false; + pcb->probe_services_len = 0; + pcb->failed_probes = 0; + mdns_mem_free(pcb->probe_services); + pcb->probe_services = NULL; + _mdns_free_tx_packet(p); + p = a; + send_after = 250; + //fallthrough + case PCB_ANNOUNCE_1: + //fallthrough + case PCB_ANNOUNCE_2: + _mdns_schedule_tx_packet(p, send_after); + pcb->state = (mdns_pcb_state_t)((uint8_t)(pcb->state) + 1); + break; + case PCB_ANNOUNCE_3: + pcb->state = PCB_RUNNING; + _mdns_free_tx_packet(p); + break; + default: + _mdns_free_tx_packet(p); + break; + } +} + +static void _mdns_remap_self_service_hostname(const char *old_hostname, const char *new_hostname) +{ + mdns_srv_item_t *service = _mdns_server->services; + + while (service) { + if (service->service->hostname && + strcmp(service->service->hostname, old_hostname) == 0) { + mdns_mem_free((char *)service->service->hostname); + service->service->hostname = mdns_mem_strdup(new_hostname); + } + service = service->next; + } +} + +static void _mdns_sync_browse_result_link_free(mdns_browse_sync_t *browse_sync) +{ + mdns_browse_result_sync_t *current = browse_sync->sync_result; + mdns_browse_result_sync_t *need_free; + while (current) { + need_free = current; + current = current->next; + mdns_mem_free(need_free); + } + mdns_mem_free(browse_sync); +} + +/** + * @brief Free action data + */ +static void _mdns_free_action(mdns_action_t *action) +{ + switch (action->type) { + case ACTION_HOSTNAME_SET: + mdns_mem_free(action->data.hostname_set.hostname); + break; + case ACTION_INSTANCE_SET: + mdns_mem_free(action->data.instance); + break; + case ACTION_SEARCH_ADD: + //fallthrough + case ACTION_SEARCH_SEND: + //fallthrough + case ACTION_SEARCH_END: + _mdns_search_free(action->data.search_add.search); + break; + case ACTION_BROWSE_ADD: + //fallthrough + case ACTION_BROWSE_END: + _mdns_browse_item_free(action->data.browse_add.browse); + break; + case ACTION_BROWSE_SYNC: + _mdns_sync_browse_result_link_free(action->data.browse_sync.browse_sync); + break; + case ACTION_TX_HANDLE: + _mdns_free_tx_packet(action->data.tx_handle.packet); + break; + case ACTION_RX_HANDLE: + _mdns_packet_free(action->data.rx_handle.packet); + break; + case ACTION_DELEGATE_HOSTNAME_SET_ADDR: + case ACTION_DELEGATE_HOSTNAME_ADD: + mdns_mem_free((char *)action->data.delegate_hostname.hostname); + free_address_list(action->data.delegate_hostname.address_list); + break; + case ACTION_DELEGATE_HOSTNAME_REMOVE: + mdns_mem_free((char *)action->data.delegate_hostname.hostname); + break; + default: + break; + } + mdns_mem_free(action); +} + +/** + * @brief Called from service thread to execute given action + */ +static void _mdns_execute_action(mdns_action_t *action) +{ + switch (action->type) { + case ACTION_SYSTEM_EVENT: + perform_event_action(action->data.sys_event.interface, action->data.sys_event.event_action); + break; + case ACTION_HOSTNAME_SET: + _mdns_send_bye_all_pcbs_no_instance(true); + _mdns_remap_self_service_hostname(_mdns_server->hostname, action->data.hostname_set.hostname); + mdns_mem_free((char *)_mdns_server->hostname); + _mdns_server->hostname = action->data.hostname_set.hostname; + _mdns_self_host.hostname = action->data.hostname_set.hostname; + _mdns_restart_all_pcbs(); + xSemaphoreGive(_mdns_server->action_sema); + break; + case ACTION_INSTANCE_SET: + _mdns_send_bye_all_pcbs_no_instance(false); + mdns_mem_free((char *)_mdns_server->instance); + _mdns_server->instance = action->data.instance; + _mdns_restart_all_pcbs_no_instance(); + + break; + case ACTION_SEARCH_ADD: + _mdns_search_add(action->data.search_add.search); + break; + case ACTION_SEARCH_SEND: + _mdns_search_send(action->data.search_add.search); + break; + case ACTION_SEARCH_END: + _mdns_search_finish(action->data.search_add.search); + break; + + case ACTION_BROWSE_ADD: + _mdns_browse_add(action->data.browse_add.browse); + break; + case ACTION_BROWSE_SYNC: + _mdns_browse_sync(action->data.browse_sync.browse_sync); + _mdns_sync_browse_result_link_free(action->data.browse_sync.browse_sync); + break; + case ACTION_BROWSE_END: + _mdns_browse_finish(action->data.browse_add.browse); + break; + + case ACTION_TX_HANDLE: { + mdns_tx_packet_t *p = _mdns_server->tx_queue_head; + // packet to be handled should be at tx head, but must be consistent with the one pushed to action queue + if (p && p == action->data.tx_handle.packet && p->queued) { + p->queued = false; // clearing, as the packet might be reused (pushed and transmitted again) + _mdns_server->tx_queue_head = p->next; + _mdns_tx_handle_packet(p); + } else { + ESP_LOGD(TAG, "Skipping transmit of an unexpected packet!"); + } + } + break; + case ACTION_RX_HANDLE: + mdns_parse_packet(action->data.rx_handle.packet); + _mdns_packet_free(action->data.rx_handle.packet); + break; + case ACTION_DELEGATE_HOSTNAME_ADD: + if (!_mdns_delegate_hostname_add(action->data.delegate_hostname.hostname, + action->data.delegate_hostname.address_list)) { + mdns_mem_free((char *)action->data.delegate_hostname.hostname); + free_address_list(action->data.delegate_hostname.address_list); + } + xSemaphoreGive(_mdns_server->action_sema); + break; + case ACTION_DELEGATE_HOSTNAME_SET_ADDR: + if (!_mdns_delegate_hostname_set_address(action->data.delegate_hostname.hostname, + action->data.delegate_hostname.address_list)) { + free_address_list(action->data.delegate_hostname.address_list); + } + mdns_mem_free((char *)action->data.delegate_hostname.hostname); + break; + case ACTION_DELEGATE_HOSTNAME_REMOVE: + _mdns_delegate_hostname_remove(action->data.delegate_hostname.hostname); + mdns_mem_free((char *)action->data.delegate_hostname.hostname); + break; + default: + break; + } + mdns_mem_free(action); +} + +/** + * @brief Queue search action + */ +static esp_err_t _mdns_send_search_action(mdns_action_type_t type, mdns_search_once_t *search) +{ + mdns_action_t *action = NULL; + + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + return ESP_ERR_NO_MEM; + } + + action->type = type; + action->data.search_add.search = search; + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + return ESP_OK; +} + +/** + * @brief Called from timer task to run mDNS responder + * + * periodically checks first unqueued packet (from tx head). + * if it is scheduled to be transmitted, then pushes the packet to action queue to be handled. + * + */ +static void _mdns_scheduler_run(void) +{ + MDNS_SERVICE_LOCK(); + mdns_tx_packet_t *p = _mdns_server->tx_queue_head; + mdns_action_t *action = NULL; + + // find first unqueued packet + while (p && p->queued) { + p = p->next; + } + if (!p) { + MDNS_SERVICE_UNLOCK(); + return; + } + while (p && (int32_t)(p->send_at - (xTaskGetTickCount() * portTICK_PERIOD_MS)) < 0) { + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (action) { + action->type = ACTION_TX_HANDLE; + action->data.tx_handle.packet = p; + p->queued = true; + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(action); + p->queued = false; + } + } else { + HOOK_MALLOC_FAILED; + break; + } + //Find the next unqued packet + p = p->next; + } + MDNS_SERVICE_UNLOCK(); +} + +/** + * @brief Called from timer task to run active searches + */ +static void _mdns_search_run(void) +{ + MDNS_SERVICE_LOCK(); + mdns_search_once_t *s = _mdns_server->search_once; + uint32_t now = xTaskGetTickCount() * portTICK_PERIOD_MS; + if (!s) { + MDNS_SERVICE_UNLOCK(); + return; + } + while (s) { + if (s->state != SEARCH_OFF) { + if (now > (s->started_at + s->timeout)) { + s->state = SEARCH_OFF; + if (_mdns_send_search_action(ACTION_SEARCH_END, s) != ESP_OK) { + s->state = SEARCH_RUNNING; + } + } else if (s->state == SEARCH_INIT || (now - s->sent_at) > 1000) { + s->state = SEARCH_RUNNING; + s->sent_at = now; + if (_mdns_send_search_action(ACTION_SEARCH_SEND, s) != ESP_OK) { + s->sent_at -= 1000; + } + } + } + s = s->next; + } + MDNS_SERVICE_UNLOCK(); +} + +/** + * @brief the main MDNS service task. Packets are received and parsed here + */ +static void _mdns_service_task(void *pvParameters) +{ + mdns_action_t *a = NULL; + for (;;) { + if (_mdns_server && _mdns_server->action_queue) { + if (xQueueReceive(_mdns_server->action_queue, &a, portMAX_DELAY) == pdTRUE) { + assert(a); + if (a->type == ACTION_TASK_STOP) { + break; + } + MDNS_SERVICE_LOCK(); + _mdns_execute_action(a); + MDNS_SERVICE_UNLOCK(); + } + } else { + vTaskDelay(500 * portTICK_PERIOD_MS); + } + } + _mdns_service_task_handle = NULL; + vTaskDelay(portMAX_DELAY); +} + +static void _mdns_timer_cb(void *arg) +{ + _mdns_scheduler_run(); + _mdns_search_run(); +} + +static esp_err_t _mdns_start_timer(void) +{ + esp_timer_create_args_t timer_conf = { + .callback = _mdns_timer_cb, + .arg = NULL, + .dispatch_method = ESP_TIMER_TASK, + .name = "mdns_timer" + }; + esp_err_t err = esp_timer_create(&timer_conf, &(_mdns_server->timer_handle)); + if (err) { + return err; + } + return esp_timer_start_periodic(_mdns_server->timer_handle, MDNS_TIMER_PERIOD_US); +} + +static esp_err_t _mdns_stop_timer(void) +{ + esp_err_t err = ESP_OK; + if (_mdns_server->timer_handle) { + err = esp_timer_stop(_mdns_server->timer_handle); + if (err) { + return err; + } + err = esp_timer_delete(_mdns_server->timer_handle); + } + return err; +} + +static esp_err_t _mdns_task_create_with_caps(void) +{ + esp_err_t ret = ESP_OK; + static StaticTask_t mdns_task_buffer; + + _mdns_stack_buffer = mdns_mem_task_malloc(MDNS_SERVICE_STACK_DEPTH); + ESP_GOTO_ON_FALSE(_mdns_stack_buffer != NULL, ESP_FAIL, err, TAG, "failed to allocate memory for the mDNS task's stack"); + + _mdns_service_task_handle = xTaskCreateStaticPinnedToCore(_mdns_service_task, "mdns", MDNS_SERVICE_STACK_DEPTH, NULL, MDNS_TASK_PRIORITY, _mdns_stack_buffer, &mdns_task_buffer, MDNS_TASK_AFFINITY); + ESP_GOTO_ON_FALSE(_mdns_service_task_handle != NULL, ESP_FAIL, err, TAG, "failed to create task for the mDNS"); + + return ret; + +err: + mdns_mem_task_free(_mdns_stack_buffer); + return ret; +} + +/** + * @brief Start the service thread if not running + * + * @return + * - ESP_OK on success + * - ESP_FAIL on error + */ +static esp_err_t _mdns_service_task_start(void) +{ + esp_err_t ret = ESP_OK; + if (!_mdns_service_semaphore) { + _mdns_service_semaphore = xSemaphoreCreateMutex(); + ESP_RETURN_ON_FALSE(_mdns_service_semaphore != NULL, ESP_FAIL, TAG, "Failed to create the mDNS service lock"); + } + MDNS_SERVICE_LOCK(); + ESP_GOTO_ON_ERROR(_mdns_start_timer(), err, TAG, "Failed to start the mDNS service timer"); + + if (!_mdns_service_task_handle) { + ESP_GOTO_ON_ERROR(_mdns_task_create_with_caps(), err_stop_timer, TAG, "Failed to start the mDNS service task"); +#ifdef MDNS_ENABLE_DEBUG +#if !CONFIG_IDF_TARGET_LINUX + StackType_t *mdns_debug_stack_buffer; + StaticTask_t *mdns_debug_task_buffer; + xTaskGetStaticBuffers(_mdns_service_task_handle, &mdns_debug_stack_buffer, &mdns_debug_task_buffer); + _mdns_dbg_printf("mdns_debug_stack_buffer:%p mdns_debug_task_buffer:%p\n", mdns_debug_stack_buffer, mdns_debug_task_buffer); +#endif // CONFIG_IDF_TARGET_LINUX +#endif // MDNS_ENABLE_DEBUG + } + MDNS_SERVICE_UNLOCK(); + return ret; + +err_stop_timer: + _mdns_stop_timer(); +err: + MDNS_SERVICE_UNLOCK(); + vSemaphoreDelete(_mdns_service_semaphore); + _mdns_service_semaphore = NULL; + return ret; +} + +/** + * @brief Stop the service thread + * + * @return + * - ESP_OK + */ +static esp_err_t _mdns_service_task_stop(void) +{ + _mdns_stop_timer(); + if (_mdns_service_task_handle) { + TaskHandle_t task_handle = _mdns_service_task_handle; + mdns_action_t action; + mdns_action_t *a = &action; + action.type = ACTION_TASK_STOP; + if (xQueueSend(_mdns_server->action_queue, &a, (TickType_t)0) != pdPASS) { + _mdns_service_task_handle = NULL; + } + while (_mdns_service_task_handle) { + vTaskDelay(10 / portTICK_PERIOD_MS); + } + vTaskDelete(task_handle); + } + vSemaphoreDelete(_mdns_service_semaphore); + _mdns_service_semaphore = NULL; + return ESP_OK; +} + +static esp_err_t mdns_post_custom_action_tcpip_if(mdns_if_t mdns_if, mdns_event_actions_t event_action) +{ + if (!_mdns_server || mdns_if >= MDNS_MAX_INTERFACES) { + return ESP_ERR_INVALID_STATE; + } + + mdns_action_t *action = (mdns_action_t *)mdns_mem_calloc(1, sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + return ESP_ERR_NO_MEM; + } + action->type = ACTION_SYSTEM_EVENT; + action->data.sys_event.event_action = event_action; + action->data.sys_event.interface = mdns_if; + + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(action); + } + return ESP_OK; +} + +static inline void set_default_duplicated_interfaces(void) +{ + mdns_if_t wifi_sta_if = MDNS_MAX_INTERFACES; + mdns_if_t eth_if = MDNS_MAX_INTERFACES; + for (mdns_if_t i = 0; i < MDNS_MAX_INTERFACES; i++) { + if (s_esp_netifs[i].predefined && s_esp_netifs[i].predef_if == MDNS_IF_STA) { + wifi_sta_if = i; + } + if (s_esp_netifs[i].predefined && s_esp_netifs[i].predef_if == MDNS_IF_ETH) { + eth_if = i; + } + } + if (wifi_sta_if != MDNS_MAX_INTERFACES && eth_if != MDNS_MAX_INTERFACES) { + s_esp_netifs[wifi_sta_if].duplicate = eth_if; + s_esp_netifs[eth_if].duplicate = wifi_sta_if; + } +} + +static inline void unregister_predefined_handlers(void) +{ +#if MDNS_ESP_WIFI_ENABLED && (CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP) + esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, mdns_preset_if_handle_system_event); +#endif +#if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH + esp_event_handler_unregister(IP_EVENT, ESP_EVENT_ANY_ID, mdns_preset_if_handle_system_event); +#endif +#if CONFIG_ETH_ENABLED && CONFIG_MDNS_PREDEF_NETIF_ETH + esp_event_handler_unregister(ETH_EVENT, ESP_EVENT_ANY_ID, mdns_preset_if_handle_system_event); +#endif +} + +/* + * Public Methods + * */ + +esp_err_t mdns_netif_action(esp_netif_t *esp_netif, mdns_event_actions_t event_action) +{ + return mdns_post_custom_action_tcpip_if(_mdns_get_if_from_esp_netif(esp_netif), event_action); +} + +esp_err_t mdns_register_netif(esp_netif_t *esp_netif) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + + esp_err_t err = ESP_ERR_NO_MEM; + MDNS_SERVICE_LOCK(); + for (mdns_if_t i = 0; i < MDNS_MAX_INTERFACES; ++i) { + if (s_esp_netifs[i].netif == esp_netif) { + MDNS_SERVICE_UNLOCK(); + return ESP_ERR_INVALID_STATE; + } + } + + for (mdns_if_t i = 0; i < MDNS_MAX_INTERFACES; ++i) { + if (!s_esp_netifs[i].predefined && s_esp_netifs[i].netif == NULL) { + s_esp_netifs[i].netif = esp_netif; + err = ESP_OK; + break; + } + } + MDNS_SERVICE_UNLOCK(); + return err; +} + +esp_err_t mdns_unregister_netif(esp_netif_t *esp_netif) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + + esp_err_t err = ESP_ERR_NOT_FOUND; + MDNS_SERVICE_LOCK(); + for (mdns_if_t i = 0; i < MDNS_MAX_INTERFACES; ++i) { + if (!s_esp_netifs[i].predefined && s_esp_netifs[i].netif == esp_netif) { + s_esp_netifs[i].netif = NULL; + err = ESP_OK; + break; + } + } + MDNS_SERVICE_UNLOCK(); + return err; +} + + +esp_err_t mdns_init(void) +{ + esp_err_t err = ESP_OK; + + if (_mdns_server) { + return err; + } + + _mdns_server = (mdns_server_t *)mdns_mem_malloc(sizeof(mdns_server_t)); + if (!_mdns_server) { + HOOK_MALLOC_FAILED; + return ESP_ERR_NO_MEM; + } + memset((uint8_t *)_mdns_server, 0, sizeof(mdns_server_t)); + // zero-out local copy of netifs to initiate a fresh search by interface key whenever a netif ptr is needed + for (mdns_if_t i = 0; i < MDNS_MAX_INTERFACES; ++i) { + s_esp_netifs[i].netif = NULL; + } + + _mdns_server->action_queue = xQueueCreate(MDNS_ACTION_QUEUE_LEN, sizeof(mdns_action_t *)); + if (!_mdns_server->action_queue) { + err = ESP_ERR_NO_MEM; + goto free_server; + } + + _mdns_server->action_sema = xSemaphoreCreateBinary(); + if (!_mdns_server->action_sema) { + err = ESP_ERR_NO_MEM; + goto free_queue; + } + +#if MDNS_ESP_WIFI_ENABLED && (CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP) + if ((err = esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, mdns_preset_if_handle_system_event, NULL)) != ESP_OK) { + goto free_event_handlers; + } +#endif +#if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH + if ((err = esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, mdns_preset_if_handle_system_event, NULL)) != ESP_OK) { + goto free_event_handlers; + } +#endif +#if CONFIG_ETH_ENABLED && CONFIG_MDNS_PREDEF_NETIF_ETH + if ((err = esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, mdns_preset_if_handle_system_event, NULL)) != ESP_OK) { + goto free_event_handlers; + } +#endif + +#if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH + set_default_duplicated_interfaces(); +#endif + + uint8_t i; +#ifdef CONFIG_LWIP_IPV6 + esp_ip6_addr_t tmp_addr6; +#endif +#ifdef CONFIG_LWIP_IPV4 + esp_netif_ip_info_t if_ip_info; +#endif + + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { +#ifdef CONFIG_LWIP_IPV6 + if (!esp_netif_get_ip6_linklocal(_mdns_get_esp_netif(i), &tmp_addr6) && !_ipv6_address_is_zero(tmp_addr6)) { + _mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V6); + } +#endif +#ifdef CONFIG_LWIP_IPV4 + if (!esp_netif_get_ip_info(_mdns_get_esp_netif(i), &if_ip_info) && if_ip_info.ip.addr) { + _mdns_enable_pcb(i, MDNS_IP_PROTOCOL_V4); + } +#endif + } + if (_mdns_service_task_start()) { + //service start failed! + err = ESP_FAIL; + goto free_all_and_disable_pcbs; + } + + return ESP_OK; + +free_all_and_disable_pcbs: + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { + _mdns_disable_pcb(i, MDNS_IP_PROTOCOL_V6); + _mdns_disable_pcb(i, MDNS_IP_PROTOCOL_V4); + s_esp_netifs[i].duplicate = MDNS_MAX_INTERFACES; + } +#if CONFIG_MDNS_PREDEF_NETIF_STA || CONFIG_MDNS_PREDEF_NETIF_AP || CONFIG_MDNS_PREDEF_NETIF_ETH +free_event_handlers: + unregister_predefined_handlers(); +#endif + vSemaphoreDelete(_mdns_server->action_sema); +free_queue: + vQueueDelete(_mdns_server->action_queue); +free_server: + mdns_mem_free(_mdns_server); + _mdns_server = NULL; + return err; +} + +void mdns_free(void) +{ + uint8_t i, j; + if (!_mdns_server) { + return; + } + + // Unregister handlers before destroying the mdns internals to avoid receiving async events while deinit + unregister_predefined_handlers(); + + mdns_service_remove_all(); + free_delegated_hostnames(); + _mdns_service_task_stop(); + // at this point, the service task is deleted, so we can destroy the stack size + mdns_mem_task_free(_mdns_stack_buffer); + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { + for (j = 0; j < MDNS_IP_PROTOCOL_MAX; j++) { + mdns_pcb_deinit_local(i, j); + } + } + mdns_mem_free((char *)_mdns_server->hostname); + mdns_mem_free((char *)_mdns_server->instance); + if (_mdns_server->action_queue) { + mdns_action_t *c; + while (xQueueReceive(_mdns_server->action_queue, &c, 0) == pdTRUE) { + _mdns_free_action(c); + } + vQueueDelete(_mdns_server->action_queue); + } + _mdns_clear_tx_queue_head(); + while (_mdns_server->search_once) { + mdns_search_once_t *h = _mdns_server->search_once; + _mdns_server->search_once = h->next; + mdns_mem_free(h->instance); + mdns_mem_free(h->service); + mdns_mem_free(h->proto); + vSemaphoreDelete(h->done_semaphore); + if (h->result) { + _mdns_query_results_free(h->result); + } + mdns_mem_free(h); + } + while (_mdns_server->browse) { + mdns_browse_t *b = _mdns_server->browse; + _mdns_server->browse = _mdns_server->browse->next; + _mdns_browse_item_free(b); + + } + vSemaphoreDelete(_mdns_server->action_sema); + mdns_mem_free(_mdns_server); + _mdns_server = NULL; +} + +esp_err_t mdns_hostname_set(const char *hostname) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_ARG; + } + if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { + return ESP_ERR_INVALID_ARG; + } + char *new_hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); + if (!new_hostname) { + return ESP_ERR_NO_MEM; + } + + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + mdns_mem_free(new_hostname); + return ESP_ERR_NO_MEM; + } + action->type = ACTION_HOSTNAME_SET; + action->data.hostname_set.hostname = new_hostname; + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(new_hostname); + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + xSemaphoreTake(_mdns_server->action_sema, portMAX_DELAY); + return ESP_OK; +} + +esp_err_t mdns_hostname_get(char *hostname) +{ + if (!hostname) { + return ESP_ERR_INVALID_ARG; + } + + if (!_mdns_server || !_mdns_server->hostname) { + return ESP_ERR_INVALID_STATE; + } + + MDNS_SERVICE_LOCK(); + size_t len = strnlen(_mdns_server->hostname, MDNS_NAME_BUF_LEN - 1); + strncpy(hostname, _mdns_server->hostname, len); + hostname[len] = 0; + MDNS_SERVICE_UNLOCK(); + return ESP_OK; +} + +esp_err_t mdns_delegate_hostname_add(const char *hostname, const mdns_ip_addr_t *address_list) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { + return ESP_ERR_INVALID_ARG; + } + char *new_hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); + if (!new_hostname) { + return ESP_ERR_NO_MEM; + } + + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + mdns_mem_free(new_hostname); + return ESP_ERR_NO_MEM; + } + action->type = ACTION_DELEGATE_HOSTNAME_ADD; + action->data.delegate_hostname.hostname = new_hostname; + action->data.delegate_hostname.address_list = copy_address_list(address_list); + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(new_hostname); + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + xSemaphoreTake(_mdns_server->action_sema, portMAX_DELAY); + return ESP_OK; +} + +esp_err_t mdns_delegate_hostname_remove(const char *hostname) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { + return ESP_ERR_INVALID_ARG; + } + char *new_hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); + if (!new_hostname) { + return ESP_ERR_NO_MEM; + } + + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + mdns_mem_free(new_hostname); + return ESP_ERR_NO_MEM; + } + action->type = ACTION_DELEGATE_HOSTNAME_REMOVE; + action->data.delegate_hostname.hostname = new_hostname; + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(new_hostname); + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + return ESP_OK; +} + +esp_err_t mdns_delegate_hostname_set_address(const char *hostname, const mdns_ip_addr_t *address_list) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + if (_str_null_or_empty(hostname) || strlen(hostname) > (MDNS_NAME_BUF_LEN - 1)) { + return ESP_ERR_INVALID_ARG; + } + char *new_hostname = mdns_mem_strndup(hostname, MDNS_NAME_BUF_LEN - 1); + if (!new_hostname) { + return ESP_ERR_NO_MEM; + } + + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + mdns_mem_free(new_hostname); + return ESP_ERR_NO_MEM; + } + action->type = ACTION_DELEGATE_HOSTNAME_SET_ADDR; + action->data.delegate_hostname.hostname = new_hostname; + action->data.delegate_hostname.address_list = copy_address_list(address_list); + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(new_hostname); + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + return ESP_OK; +} + +bool mdns_hostname_exists(const char *hostname) +{ + bool ret = false; + MDNS_SERVICE_LOCK(); + ret = _hostname_is_ours(hostname); + MDNS_SERVICE_UNLOCK(); + return ret; +} + +esp_err_t mdns_instance_name_set(const char *instance) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + if (_str_null_or_empty(instance) || _mdns_server->hostname == NULL || strlen(instance) > (MDNS_NAME_BUF_LEN - 1)) { + return ESP_ERR_INVALID_ARG; + } + char *new_instance = mdns_mem_strndup(instance, MDNS_NAME_BUF_LEN - 1); + if (!new_instance) { + return ESP_ERR_NO_MEM; + } + + mdns_action_t *action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + mdns_mem_free(new_instance); + return ESP_ERR_NO_MEM; + } + action->type = ACTION_INSTANCE_SET; + action->data.instance = new_instance; + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(new_instance); + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + return ESP_OK; +} + +/* + * MDNS SERVICES + * */ + +esp_err_t mdns_service_add_for_host(const char *instance, const char *service, const char *proto, const char *host, + uint16_t port, mdns_txt_item_t txt[], size_t num_items) +{ + if (!_mdns_server || _str_null_or_empty(service) || _str_null_or_empty(proto) || !_mdns_server->hostname) { + return ESP_ERR_INVALID_ARG; + } + + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + const char *hostname = host ? host : _mdns_server->hostname; + mdns_service_t *s = NULL; + + ESP_GOTO_ON_FALSE(_mdns_can_add_more_services(), ESP_ERR_NO_MEM, err, TAG, + "Cannot add more services, please increase CONFIG_MDNS_MAX_SERVICES (%d)", CONFIG_MDNS_MAX_SERVICES); + + mdns_srv_item_t *item = _mdns_get_service_item_instance(instance, service, proto, hostname); + ESP_GOTO_ON_FALSE(!item, ESP_ERR_INVALID_ARG, err, TAG, "Service already exists"); + + s = _mdns_create_service(service, proto, hostname, port, instance, num_items, txt); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NO_MEM, err, TAG, "Cannot create service: Out of memory"); + + item = (mdns_srv_item_t *)mdns_mem_malloc(sizeof(mdns_srv_item_t)); + ESP_GOTO_ON_FALSE(item, ESP_ERR_NO_MEM, err, TAG, "Cannot create service: Out of memory"); + + item->service = s; + item->next = NULL; + + item->next = _mdns_server->services; + _mdns_server->services = item; + _mdns_probe_all_pcbs(&item, 1, false, false); + MDNS_SERVICE_UNLOCK(); + return ESP_OK; + +err: + MDNS_SERVICE_UNLOCK(); + _mdns_free_service(s); + if (ret == ESP_ERR_NO_MEM) { + HOOK_MALLOC_FAILED; + } + return ret; +} + +esp_err_t mdns_service_add(const char *instance, const char *service, const char *proto, uint16_t port, + mdns_txt_item_t txt[], size_t num_items) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + return mdns_service_add_for_host(instance, service, proto, NULL, port, txt, num_items); +} + +bool mdns_service_exists(const char *service_type, const char *proto, const char *hostname) +{ + bool ret = false; + MDNS_SERVICE_LOCK(); + ret = _mdns_get_service_item(service_type, proto, hostname) != NULL; + MDNS_SERVICE_UNLOCK(); + return ret; +} + +bool mdns_service_exists_with_instance(const char *instance, const char *service_type, const char *proto, + const char *hostname) +{ + bool ret = false; + MDNS_SERVICE_LOCK(); + ret = _mdns_get_service_item_instance(instance, service_type, proto, hostname) != NULL; + MDNS_SERVICE_UNLOCK(); + return ret; +} + +static mdns_txt_item_t *_copy_mdns_txt_items(mdns_txt_linked_item_t *items, uint8_t **txt_value_len, size_t *txt_count) +{ + mdns_txt_item_t *ret = NULL; + size_t ret_index = 0; + for (mdns_txt_linked_item_t *tmp = items; tmp != NULL; tmp = tmp->next) { + ret_index++; + } + *txt_count = ret_index; + if (ret_index == 0) { // handle empty TXT + *txt_value_len = NULL; + return NULL; + } + ret = (mdns_txt_item_t *)mdns_mem_calloc(ret_index, sizeof(mdns_txt_item_t)); + *txt_value_len = (uint8_t *)mdns_mem_calloc(ret_index, sizeof(uint8_t)); + if (!ret || !(*txt_value_len)) { + HOOK_MALLOC_FAILED; + goto handle_error; + } + ret_index = 0; + for (mdns_txt_linked_item_t *tmp = items; tmp != NULL; tmp = tmp->next) { + size_t key_len = strlen(tmp->key); + char *key = (char *)mdns_mem_malloc(key_len + 1); + if (!key) { + HOOK_MALLOC_FAILED; + goto handle_error; + } + memcpy(key, tmp->key, key_len); + key[key_len] = 0; + ret[ret_index].key = key; + char *value = (char *)mdns_mem_malloc(tmp->value_len + 1); + if (!value) { + HOOK_MALLOC_FAILED; + goto handle_error; + } + memcpy(value, tmp->value, tmp->value_len); + value[tmp->value_len] = 0; + ret[ret_index].value = value; + (*txt_value_len)[ret_index] = tmp->value_len; + ret_index++; + } + return ret; + +handle_error: + for (size_t y = 0; y < ret_index + 1 && ret != NULL; y++) { + mdns_txt_item_t *t = &ret[y]; + mdns_mem_free((char *)t->key); + mdns_mem_free((char *)t->value); + } + mdns_mem_free(*txt_value_len); + mdns_mem_free(ret); + return NULL; +} + +static mdns_ip_addr_t *_copy_delegated_host_address_list(char *hostname) +{ + mdns_host_item_t *host = _mdns_host_list; + while (host) { + if (strcasecmp(host->hostname, hostname) == 0) { + return copy_address_list(host->address_list); + } + host = host->next; + } + return NULL; +} + +static mdns_result_t *_mdns_lookup_service(const char *instance, const char *service, const char *proto, size_t max_results, bool selfhost) +{ + if (_str_null_or_empty(service) || _str_null_or_empty(proto)) { + return NULL; + } + mdns_result_t *results = NULL; + size_t num_results = 0; + mdns_srv_item_t *s = _mdns_server->services; + while (s) { + mdns_service_t *srv = s->service; + if (!srv || !srv->hostname) { + s = s->next; + continue; + } + bool is_service_selfhosted = !_str_null_or_empty(_mdns_server->hostname) && !strcasecmp(_mdns_server->hostname, srv->hostname); + bool is_service_delegated = _str_null_or_empty(_mdns_server->hostname) || strcasecmp(_mdns_server->hostname, srv->hostname); + if ((selfhost && is_service_selfhosted) || (!selfhost && is_service_delegated)) { + if (!strcasecmp(srv->service, service) && !strcasecmp(srv->proto, proto) && + (_str_null_or_empty(instance) || _mdns_instance_name_match(srv->instance, instance))) { + mdns_result_t *item = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); + if (!item) { + HOOK_MALLOC_FAILED; + goto handle_error; + } + item->next = results; + results = item; + item->esp_netif = NULL; + item->ttl = _str_null_or_empty(instance) ? MDNS_ANSWER_PTR_TTL : MDNS_ANSWER_SRV_TTL; + item->ip_protocol = MDNS_IP_PROTOCOL_MAX; + if (srv->instance) { + item->instance_name = mdns_mem_strndup(srv->instance, MDNS_NAME_BUF_LEN - 1); + if (!item->instance_name) { + HOOK_MALLOC_FAILED; + goto handle_error; + } + } else { + item->instance_name = NULL; + } + item->service_type = mdns_mem_strndup(srv->service, MDNS_NAME_BUF_LEN - 1); + if (!item->service_type) { + HOOK_MALLOC_FAILED; + goto handle_error; + } + item->proto = mdns_mem_strndup(srv->proto, MDNS_NAME_BUF_LEN - 1); + if (!item->proto) { + HOOK_MALLOC_FAILED; + goto handle_error; + } + item->hostname = mdns_mem_strndup(srv->hostname, MDNS_NAME_BUF_LEN - 1); + if (!item->hostname) { + HOOK_MALLOC_FAILED; + goto handle_error; + } + item->port = srv->port; + item->txt = _copy_mdns_txt_items(srv->txt, &(item->txt_value_len), &(item->txt_count)); + // We should not append addresses for selfhost lookup result as we don't know which interface's address to append. + if (selfhost) { + item->addr = NULL; + } else { + item->addr = _copy_delegated_host_address_list(item->hostname); + if (!item->addr) { + goto handle_error; + } + } + if (num_results < max_results) { + num_results++; + } + if (num_results >= max_results) { + break; + } + } + } + s = s->next; + } + return results; +handle_error: + _mdns_query_results_free(results); + return NULL; +} + +esp_err_t mdns_service_port_set_for_host(const char *instance, const char *service, const char *proto, const char *host, uint16_t port) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + const char *hostname = host ? host : _mdns_server->hostname; + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service) && !_str_null_or_empty(proto) && port, + ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + s->service->port = port; + _mdns_announce_all_pcbs(&s, 1, true); + +err: + MDNS_SERVICE_UNLOCK(); + return ret; +} + +esp_err_t mdns_service_port_set(const char *service, const char *proto, uint16_t port) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + return mdns_service_port_set_for_host(NULL, service, proto, NULL, port); +} + +esp_err_t mdns_service_txt_set_for_host(const char *instance, const char *service, const char *proto, const char *host, + mdns_txt_item_t txt_items[], uint8_t num_items) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + const char *hostname = host ? host : _mdns_server->hostname; + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service) && !_str_null_or_empty(proto) && !(num_items && txt_items == NULL), + ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + mdns_txt_linked_item_t *new_txt = NULL; + if (num_items) { + new_txt = _mdns_allocate_txt(num_items, txt_items); + if (!new_txt) { + return ESP_ERR_NO_MEM; + } + } + mdns_service_t *srv = s->service; + mdns_txt_linked_item_t *txt = srv->txt; + srv->txt = NULL; + _mdns_free_linked_txt(txt); + srv->txt = new_txt; + _mdns_announce_all_pcbs(&s, 1, false); + +err: + MDNS_SERVICE_UNLOCK(); + return ret; +} + +esp_err_t mdns_service_txt_set(const char *service, const char *proto, mdns_txt_item_t txt[], uint8_t num_items) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + return mdns_service_txt_set_for_host(NULL, service, proto, NULL, txt, num_items); +} + +esp_err_t mdns_service_txt_item_set_for_host_with_explicit_value_len(const char *instance, const char *service, const char *proto, + const char *host, const char *key, const char *value_arg, uint8_t value_len) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + char *value = NULL; + mdns_txt_linked_item_t *new_txt = NULL; + const char *hostname = host ? host : _mdns_server->hostname; + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service) && !_str_null_or_empty(proto) && !_str_null_or_empty(key) && + !((!value_arg && value_len)), ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + mdns_service_t *srv = s->service; + if (value_len > 0) { + value = (char *) mdns_mem_malloc(value_len); + ESP_GOTO_ON_FALSE(value, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); + memcpy(value, value_arg, value_len); + } else { + value_len = 0; + } + mdns_txt_linked_item_t *txt = srv->txt; + while (txt) { + if (strcmp(txt->key, key) == 0) { + mdns_mem_free((char *)txt->value); + txt->value = value; + txt->value_len = value_len; + break; + } + txt = txt->next; + } + if (!txt) { + new_txt = (mdns_txt_linked_item_t *)mdns_mem_malloc(sizeof(mdns_txt_linked_item_t)); + ESP_GOTO_ON_FALSE(new_txt, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); + new_txt->key = mdns_mem_strdup(key); + ESP_GOTO_ON_FALSE(new_txt->key, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); + new_txt->value = value; + new_txt->value_len = value_len; + new_txt->next = srv->txt; + srv->txt = new_txt; + } + + _mdns_announce_all_pcbs(&s, 1, false); + +err: + MDNS_SERVICE_UNLOCK(); + return ret; +out_of_mem: + MDNS_SERVICE_UNLOCK(); + HOOK_MALLOC_FAILED; + mdns_mem_free(value); + mdns_mem_free(new_txt); + return ret; +} + +esp_err_t mdns_service_txt_item_set_for_host(const char *instance, const char *service, const char *proto, const char *hostname, + const char *key, const char *value) +{ + return mdns_service_txt_item_set_for_host_with_explicit_value_len(instance, service, proto, hostname, key, value, + strlen(value)); +} + + +esp_err_t mdns_service_txt_item_set(const char *service, const char *proto, const char *key, const char *value) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + return mdns_service_txt_item_set_for_host_with_explicit_value_len(NULL, service, proto, NULL, key, + value, strlen(value)); +} + +esp_err_t mdns_service_txt_item_set_with_explicit_value_len(const char *service, const char *proto, const char *key, + const char *value, uint8_t value_len) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + return mdns_service_txt_item_set_for_host_with_explicit_value_len(NULL, service, proto, NULL, key, value, value_len); +} + +esp_err_t mdns_service_txt_item_remove_for_host(const char *instance, const char *service, const char *proto, const char *host, + const char *key) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + const char *hostname = host ? host : _mdns_server->hostname; + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service) && !_str_null_or_empty(proto) && !_str_null_or_empty(key), + ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + mdns_service_t *srv = s->service; + mdns_txt_linked_item_t *txt = srv->txt; + if (!txt) { + goto err; + } + if (strcmp(txt->key, key) == 0) { + srv->txt = txt->next; + mdns_mem_free((char *)txt->key); + mdns_mem_free((char *)txt->value); + mdns_mem_free(txt); + } else { + while (txt->next) { + if (strcmp(txt->next->key, key) == 0) { + mdns_txt_linked_item_t *t = txt->next; + txt->next = t->next; + mdns_mem_free((char *)t->key); + mdns_mem_free((char *)t->value); + mdns_mem_free(t); + break; + } else { + txt = txt->next; + } + } + } + + _mdns_announce_all_pcbs(&s, 1, false); + +err: + MDNS_SERVICE_UNLOCK(); + if (ret == ESP_ERR_NO_MEM) { + HOOK_MALLOC_FAILED; + } + return ret; +} + +esp_err_t mdns_service_txt_item_remove(const char *service, const char *proto, const char *key) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + return mdns_service_txt_item_remove_for_host(NULL, service, proto, NULL, key); +} + +static esp_err_t _mdns_service_subtype_remove_for_host(mdns_srv_item_t *service, const char *subtype) +{ + esp_err_t ret = ESP_ERR_NOT_FOUND; + mdns_subtype_t *srv_subtype = service->service->subtype; + mdns_subtype_t *pre = service->service->subtype; + while (srv_subtype) { + if (strcmp(srv_subtype->subtype, subtype) == 0) { + // Target subtype is found. + if (srv_subtype == service->service->subtype) { + // The first node needs to be removed + service->service->subtype = service->service->subtype->next; + } else { + pre->next = srv_subtype->next; + } + mdns_mem_free((char *)srv_subtype->subtype); + mdns_mem_free(srv_subtype); + ret = ESP_OK; + break; + } + pre = srv_subtype; + srv_subtype = srv_subtype->next; + } + if (ret == ESP_ERR_NOT_FOUND) { + ESP_LOGE(TAG, "Subtype : %s doesn't exist", subtype); + } + + return ret; +} + +esp_err_t mdns_service_subtype_remove_for_host(const char *instance_name, const char *service, const char *proto, + const char *hostname, const char *subtype) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service) && !_str_null_or_empty(proto) && + !_str_null_or_empty(subtype), ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance_name, service, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + ret = _mdns_service_subtype_remove_for_host(s, subtype); + ESP_GOTO_ON_ERROR(ret, err, TAG, "Failed to remove the subtype: %s", subtype); + + // Transmit a sendbye message for the removed subtype. + mdns_subtype_t *remove_subtypes = (mdns_subtype_t *)mdns_mem_malloc(sizeof(mdns_subtype_t)); + ESP_GOTO_ON_FALSE(remove_subtypes, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); + remove_subtypes->subtype = mdns_mem_strdup(subtype); + ESP_GOTO_ON_FALSE(remove_subtypes->subtype, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); + remove_subtypes->next = NULL; + + _mdns_send_bye_subtype(s, instance_name, remove_subtypes); + _mdns_free_subtype(remove_subtypes); +err: + MDNS_SERVICE_UNLOCK(); + return ret; +out_of_mem: + HOOK_MALLOC_FAILED; + mdns_mem_free(remove_subtypes); + MDNS_SERVICE_UNLOCK(); + return ret; +} + +static esp_err_t _mdns_service_subtype_add_for_host(mdns_srv_item_t *service, const char *subtype) +{ + esp_err_t ret = ESP_OK; + mdns_subtype_t *srv_subtype = service->service->subtype; + while (srv_subtype) { + ESP_GOTO_ON_FALSE(strcmp(srv_subtype->subtype, subtype) != 0, ESP_ERR_INVALID_ARG, err, TAG, "Subtype: %s has already been added", subtype); + srv_subtype = srv_subtype->next; + } + + mdns_subtype_t *subtype_item = (mdns_subtype_t *)mdns_mem_malloc(sizeof(mdns_subtype_t)); + ESP_GOTO_ON_FALSE(subtype_item, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); + subtype_item->subtype = mdns_mem_strdup(subtype); + ESP_GOTO_ON_FALSE(subtype_item->subtype, ESP_ERR_NO_MEM, out_of_mem, TAG, "Out of memory"); + subtype_item->next = service->service->subtype; + service->service->subtype = subtype_item; + +err: + return ret; +out_of_mem: + HOOK_MALLOC_FAILED; + mdns_mem_free(subtype_item); + return ret; +} + +esp_err_t mdns_service_subtype_add_multiple_items_for_host(const char *instance_name, const char *service, const char *proto, + const char *hostname, mdns_subtype_item_t subtype[], uint8_t num_items) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + int cur_index = 0; + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service) && !_str_null_or_empty(proto) && + (num_items > 0), ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance_name, service, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + for (; cur_index < num_items; cur_index++) { + ret = _mdns_service_subtype_add_for_host(s, subtype[cur_index].subtype); + if (ret == ESP_OK) { + continue; + } else if (ret == ESP_ERR_NO_MEM) { + ESP_LOGE(TAG, "Out of memory"); + goto err; + } else { + ESP_LOGE(TAG, "Failed to add subtype: %s", subtype[cur_index].subtype); + goto exit; + } + } + + _mdns_announce_all_pcbs(&s, 1, false); +err: + if (ret == ESP_ERR_NO_MEM) { + for (int idx = 0; idx < cur_index; idx++) { + _mdns_service_subtype_remove_for_host(s, subtype[idx].subtype); + } + } +exit: + MDNS_SERVICE_UNLOCK(); + return ret; +} + +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) +{ + mdns_subtype_item_t _subtype[1]; + _subtype[0].subtype = subtype; + return mdns_service_subtype_add_multiple_items_for_host(instance_name, service_type, proto, hostname, _subtype, 1); +} + +static mdns_subtype_t *_mdns_service_find_subtype_needed_sendbye(mdns_service_t *service, mdns_subtype_item_t subtype[], + uint8_t num_items) +{ + if (!service) { + return NULL; + } + + mdns_subtype_t *current = service->subtype; + mdns_subtype_t *prev = NULL; + mdns_subtype_t *prev_goodbye = NULL; + mdns_subtype_t *out_goodbye_subtype = NULL; + + while (current) { + bool subtype_in_update = false; + + for (int i = 0; i < num_items; i++) { + if (strcmp(subtype[i].subtype, current->subtype) == 0) { + subtype_in_update = true; + break; + } + } + + if (!subtype_in_update) { + // Remove from original list + if (prev) { + prev->next = current->next; + } else { + service->subtype = current->next; + } + + mdns_subtype_t *to_move = current; + current = current->next; + + // Add to goodbye list + to_move->next = NULL; + if (prev_goodbye) { + prev_goodbye->next = to_move; + } else { + out_goodbye_subtype = to_move; + } + prev_goodbye = to_move; + } else { + prev = current; + current = current->next; + } + } + + return out_goodbye_subtype; +} + +esp_err_t mdns_service_subtype_update_multiple_items_for_host(const char *instance_name, const char *service_type, const char *proto, + const char *hostname, mdns_subtype_item_t subtype[], uint8_t num_items) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + int cur_index = 0; + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service_type) && !_str_null_or_empty(proto), + ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance_name, service_type, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + mdns_subtype_t *goodbye_subtype = _mdns_service_find_subtype_needed_sendbye(s->service, subtype, num_items); + + if (goodbye_subtype) { + _mdns_send_bye_subtype(s, instance_name, goodbye_subtype); + } + + _mdns_free_subtype(goodbye_subtype); + _mdns_free_service_subtype(s->service); + + for (; cur_index < num_items; cur_index++) { + ret = _mdns_service_subtype_add_for_host(s, subtype[cur_index].subtype); + if (ret == ESP_OK) { + continue; + } else if (ret == ESP_ERR_NO_MEM) { + ESP_LOGE(TAG, "Out of memory"); + goto err; + } else { + ESP_LOGE(TAG, "Failed to add subtype: %s", subtype[cur_index].subtype); + goto exit; + } + } + if (num_items) { + _mdns_announce_all_pcbs(&s, 1, false); + } +err: + if (ret == ESP_ERR_NO_MEM) { + for (int idx = 0; idx < cur_index; idx++) { + _mdns_service_subtype_remove_for_host(s, subtype[idx].subtype); + } + } +exit: + MDNS_SERVICE_UNLOCK(); + return ret; +} + +esp_err_t mdns_service_instance_name_set_for_host(const char *instance_old, const char *service, const char *proto, const char *host, + const char *instance) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + const char *hostname = host ? host : _mdns_server->hostname; + + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service) && !_str_null_or_empty(proto) && + !_str_null_or_empty(instance) && strlen(instance) <= (MDNS_NAME_BUF_LEN - 1), ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance_old, service, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + if (s->service->instance) { + _mdns_send_bye(&s, 1, false); + mdns_mem_free((char *)s->service->instance); + } + s->service->instance = mdns_mem_strndup(instance, MDNS_NAME_BUF_LEN - 1); + ESP_GOTO_ON_FALSE(s->service->instance, ESP_ERR_NO_MEM, err, TAG, "Out of memory"); + _mdns_probe_all_pcbs(&s, 1, false, false); + +err: + MDNS_SERVICE_UNLOCK(); + return ret; +} + +esp_err_t mdns_service_instance_name_set(const char *service, const char *proto, const char *instance) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + return mdns_service_instance_name_set_for_host(NULL, service, proto, NULL, instance); +} + +esp_err_t mdns_service_remove_for_host(const char *instance, const char *service, const char *proto, const char *host) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + const char *hostname = host ? host : _mdns_server->hostname; + ESP_GOTO_ON_FALSE(_mdns_server && _mdns_server->services && !_str_null_or_empty(service) && !_str_null_or_empty(proto), + ESP_ERR_INVALID_ARG, err, TAG, "Invalid state or arguments"); + mdns_srv_item_t *s = _mdns_get_service_item_instance(instance, service, proto, hostname); + ESP_GOTO_ON_FALSE(s, ESP_ERR_NOT_FOUND, err, TAG, "Service doesn't exist"); + + mdns_srv_item_t *a = _mdns_server->services; + mdns_srv_item_t *b = a; + if (instance) { + while (a) { + if (_mdns_service_match_instance(a->service, instance, service, proto, hostname)) { + if (_mdns_server->services != a) { + b->next = a->next; + } else { + _mdns_server->services = a->next; + } + _mdns_send_bye(&a, 1, false); + _mdns_remove_scheduled_service_packets(a->service); + _mdns_free_service(a->service); + mdns_mem_free(a); + break; + } + b = a; + a = a->next; + } + } else { + while (a) { + if (_mdns_service_match(a->service, service, proto, hostname)) { + if (_mdns_server->services != a) { + b->next = a->next; + } else { + _mdns_server->services = a->next; + } + _mdns_send_bye(&a, 1, false); + _mdns_remove_scheduled_service_packets(a->service); + _mdns_free_service(a->service); + mdns_mem_free(a); + break; + } + b = a; + a = a->next; + } + } + +err: + MDNS_SERVICE_UNLOCK(); + return ret; +} + +esp_err_t mdns_service_remove(const char *service_type, const char *proto) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + return mdns_service_remove_for_host(NULL, service_type, proto, NULL); +} + +esp_err_t mdns_service_remove_all(void) +{ + MDNS_SERVICE_LOCK(); + esp_err_t ret = ESP_OK; + ESP_GOTO_ON_FALSE(_mdns_server, ESP_ERR_INVALID_ARG, done, TAG, "Invalid state"); + if (!_mdns_server->services) { + goto done; + } + + _mdns_send_final_bye(false); + mdns_srv_item_t *services = _mdns_server->services; + _mdns_server->services = NULL; + while (services) { + mdns_srv_item_t *s = services; + services = services->next; + _mdns_remove_scheduled_service_packets(s->service); + _mdns_free_service(s->service); + mdns_mem_free(s); + } + +done: + MDNS_SERVICE_UNLOCK(); + return ret; +} + +/* + * MDNS QUERY + * */ +void mdns_query_results_free(mdns_result_t *results) +{ + MDNS_SERVICE_LOCK(); + _mdns_query_results_free(results); + MDNS_SERVICE_UNLOCK(); +} + +static void _mdns_query_results_free(mdns_result_t *results) +{ + mdns_result_t *r; + mdns_ip_addr_t *a; + + while (results) { + r = results; + + mdns_mem_free((char *)(r->hostname)); + mdns_mem_free((char *)(r->instance_name)); + mdns_mem_free((char *)(r->service_type)); + mdns_mem_free((char *)(r->proto)); + + for (size_t i = 0; i < r->txt_count; i++) { + mdns_mem_free((char *)(r->txt[i].key)); + mdns_mem_free((char *)(r->txt[i].value)); + } + mdns_mem_free(r->txt); + mdns_mem_free(r->txt_value_len); + + while (r->addr) { + a = r->addr; + r->addr = r->addr->next; + mdns_mem_free(a); + } + + results = results->next; + mdns_mem_free(r); + } +} + +esp_err_t mdns_query_async_delete(mdns_search_once_t *search) +{ + if (!search) { + return ESP_ERR_INVALID_ARG; + } + if (search->state != SEARCH_OFF) { + return ESP_ERR_INVALID_STATE; + } + + MDNS_SERVICE_LOCK(); + _mdns_search_free(search); + MDNS_SERVICE_UNLOCK(); + + return ESP_OK; +} + +bool mdns_query_async_get_results(mdns_search_once_t *search, uint32_t timeout, mdns_result_t **results, uint8_t *num_results) +{ + if (xSemaphoreTake(search->done_semaphore, pdMS_TO_TICKS(timeout)) == pdTRUE) { + if (results) { + *results = search->result; + } + if (num_results) { + *num_results = search->num_results; + } + return true; + } + return false; +} + +mdns_search_once_t *mdns_query_async_new(const char *name, const char *service, const char *proto, uint16_t type, + uint32_t timeout, size_t max_results, mdns_query_notify_t notifier) +{ + mdns_search_once_t *search = NULL; + + if (!_mdns_server || !timeout || _str_null_or_empty(service) != _str_null_or_empty(proto)) { + return NULL; + } + + search = _mdns_search_init(name, service, proto, type, type != MDNS_TYPE_PTR, timeout, max_results, notifier); + if (!search) { + return NULL; + } + + if (_mdns_send_search_action(ACTION_SEARCH_ADD, search)) { + _mdns_search_free(search); + return NULL; + } + + return search; +} + +esp_err_t mdns_query_generic(const char *name, const char *service, const char *proto, uint16_t type, mdns_query_transmission_type_t transmission_type, uint32_t timeout, size_t max_results, mdns_result_t **results) +{ + mdns_search_once_t *search = NULL; + + *results = NULL; + + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + + if (!timeout || _str_null_or_empty(service) != _str_null_or_empty(proto)) { + return ESP_ERR_INVALID_ARG; + } + + search = _mdns_search_init(name, service, proto, type, transmission_type == MDNS_QUERY_UNICAST, timeout, max_results, NULL); + if (!search) { + return ESP_ERR_NO_MEM; + } + + if (_mdns_send_search_action(ACTION_SEARCH_ADD, search)) { + _mdns_search_free(search); + return ESP_ERR_NO_MEM; + } + xSemaphoreTake(search->done_semaphore, portMAX_DELAY); + + *results = search->result; + _mdns_search_free(search); + + return ESP_OK; +} + +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) +{ + return mdns_query_generic(name, service_type, proto, type, type != MDNS_TYPE_PTR, timeout, max_results, results); +} + +esp_err_t mdns_query_ptr(const char *service, const char *proto, uint32_t timeout, size_t max_results, mdns_result_t **results) +{ + if (_str_null_or_empty(service) || _str_null_or_empty(proto)) { + return ESP_ERR_INVALID_ARG; + } + + return mdns_query(NULL, service, proto, MDNS_TYPE_PTR, timeout, max_results, results); +} + +esp_err_t mdns_query_srv(const char *instance, const char *service, const char *proto, uint32_t timeout, mdns_result_t **result) +{ + if (_str_null_or_empty(instance) || _str_null_or_empty(service) || _str_null_or_empty(proto)) { + return ESP_ERR_INVALID_ARG; + } + + return mdns_query(instance, service, proto, MDNS_TYPE_SRV, timeout, 1, result); +} + +esp_err_t mdns_query_txt(const char *instance, const char *service, const char *proto, uint32_t timeout, mdns_result_t **result) +{ + if (_str_null_or_empty(instance) || _str_null_or_empty(service) || _str_null_or_empty(proto)) { + return ESP_ERR_INVALID_ARG; + } + + return mdns_query(instance, service, proto, MDNS_TYPE_TXT, timeout, 1, result); +} + +esp_err_t mdns_lookup_delegated_service(const char *instance, const char *service, const char *proto, size_t max_results, + mdns_result_t **result) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + if (!result || _str_null_or_empty(service) || _str_null_or_empty(proto)) { + return ESP_ERR_INVALID_ARG; + } + MDNS_SERVICE_LOCK(); + *result = _mdns_lookup_service(instance, service, proto, max_results, false); + MDNS_SERVICE_UNLOCK(); + return ESP_OK; +} + +esp_err_t mdns_lookup_selfhosted_service(const char *instance, const char *service, const char *proto, size_t max_results, + mdns_result_t **result) +{ + if (!_mdns_server) { + return ESP_ERR_INVALID_STATE; + } + if (!result || _str_null_or_empty(service) || _str_null_or_empty(proto)) { + return ESP_ERR_INVALID_ARG; + } + MDNS_SERVICE_LOCK(); + *result = _mdns_lookup_service(instance, service, proto, max_results, true); + MDNS_SERVICE_UNLOCK(); + return ESP_OK; +} + +#ifdef CONFIG_LWIP_IPV4 +esp_err_t mdns_query_a(const char *name, uint32_t timeout, esp_ip4_addr_t *addr) +{ + mdns_result_t *result = NULL; + esp_err_t err; + + if (_str_null_or_empty(name)) { + return ESP_ERR_INVALID_ARG; + } + + if (strstr(name, ".local")) { + ESP_LOGW(TAG, "Please note that hostname must not contain domain name, as mDNS uses '.local' domain"); + } + + err = mdns_query(name, NULL, NULL, MDNS_TYPE_A, timeout, 1, &result); + + if (err) { + return err; + } + + if (!result) { + return ESP_ERR_NOT_FOUND; + } + + mdns_ip_addr_t *a = result->addr; + while (a) { + if (a->addr.type == ESP_IPADDR_TYPE_V4) { + addr->addr = a->addr.u_addr.ip4.addr; + mdns_query_results_free(result); + return ESP_OK; + } + a = a->next; + } + + mdns_query_results_free(result); + return ESP_ERR_NOT_FOUND; +} +#endif /* CONFIG_LWIP_IPV4 */ + +#ifdef CONFIG_LWIP_IPV6 +esp_err_t mdns_query_aaaa(const char *name, uint32_t timeout, esp_ip6_addr_t *addr) +{ + mdns_result_t *result = NULL; + esp_err_t err; + + if (_str_null_or_empty(name)) { + return ESP_ERR_INVALID_ARG; + } + + if (strstr(name, ".local")) { + ESP_LOGW(TAG, "Please note that hostname must not contain domain name, as mDNS uses '.local' domain"); + } + + err = mdns_query(name, NULL, NULL, MDNS_TYPE_AAAA, timeout, 1, &result); + + if (err) { + return err; + } + + if (!result) { + return ESP_ERR_NOT_FOUND; + } + + mdns_ip_addr_t *a = result->addr; + while (a) { + if (a->addr.type == ESP_IPADDR_TYPE_V6) { + memcpy(addr->addr, a->addr.u_addr.ip6.addr, 16); + mdns_query_results_free(result); + return ESP_OK; + } + a = a->next; + } + + mdns_query_results_free(result); + return ESP_ERR_NOT_FOUND; +} +#endif /* CONFIG_LWIP_IPV6 */ + +#ifdef MDNS_ENABLE_DEBUG + +void mdns_debug_packet(const uint8_t *data, size_t len) +{ + static mdns_name_t n; + mdns_header_t header; + const uint8_t *content = data + MDNS_HEAD_LEN; + uint32_t t = xTaskGetTickCount() * portTICK_PERIOD_MS; + mdns_name_t *name = &n; + memset(name, 0, sizeof(mdns_name_t)); + + _mdns_dbg_printf("Packet[%" PRIu32 "]: ", t); + + header.id = _mdns_read_u16(data, MDNS_HEAD_ID_OFFSET); + header.flags = _mdns_read_u16(data, MDNS_HEAD_FLAGS_OFFSET); + header.questions = _mdns_read_u16(data, MDNS_HEAD_QUESTIONS_OFFSET); + header.answers = _mdns_read_u16(data, MDNS_HEAD_ANSWERS_OFFSET); + header.servers = _mdns_read_u16(data, MDNS_HEAD_SERVERS_OFFSET); + header.additional = _mdns_read_u16(data, MDNS_HEAD_ADDITIONAL_OFFSET); + + _mdns_dbg_printf("%s", + (header.flags == MDNS_FLAGS_QR_AUTHORITATIVE) ? "AUTHORITATIVE\n" : + (header.flags == MDNS_FLAGS_DISTRIBUTED) ? "DISTRIBUTED\n" : + (header.flags == 0) ? "\n" : " " + ); + if (header.flags && header.flags != MDNS_FLAGS_QR_AUTHORITATIVE) { + _mdns_dbg_printf("0x%04X\n", header.flags); + } + + if (header.questions) { + uint8_t qs = header.questions; + + while (qs--) { + content = _mdns_parse_fqdn(data, content, name, len); + if (!content || content + MDNS_CLASS_OFFSET + 1 >= data + len) { + header.answers = 0; + header.additional = 0; + header.servers = 0; + _mdns_dbg_printf("ERROR: parse header questions\n"); + break; + } + + uint16_t type = _mdns_read_u16(content, MDNS_TYPE_OFFSET); + uint16_t mdns_class = _mdns_read_u16(content, MDNS_CLASS_OFFSET); + bool unicast = !!(mdns_class & 0x8000); + mdns_class &= 0x7FFF; + content = content + 4; + + _mdns_dbg_printf(" Q: "); + if (unicast) { + _mdns_dbg_printf("*U* "); + } + if (type == MDNS_TYPE_PTR) { + _mdns_dbg_printf("%s.%s%s.%s.%s. PTR ", name->host, name->sub ? "_sub." : "", name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_SRV) { + _mdns_dbg_printf("%s.%s%s.%s.%s. SRV ", name->host, name->sub ? "_sub." : "", name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_TXT) { + _mdns_dbg_printf("%s.%s%s.%s.%s. TXT ", name->host, name->sub ? "_sub." : "", name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_A) { + _mdns_dbg_printf("%s.%s. A ", name->host, name->domain); + } else if (type == MDNS_TYPE_AAAA) { + _mdns_dbg_printf("%s.%s. AAAA ", name->host, name->domain); + } else if (type == MDNS_TYPE_NSEC) { + _mdns_dbg_printf("%s.%s%s.%s.%s. NSEC ", name->host, name->sub ? "_sub." : "", name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_ANY) { + _mdns_dbg_printf("%s.%s%s.%s.%s. ANY ", name->host, name->sub ? "_sub." : "", name->service, name->proto, name->domain); + } else { + _mdns_dbg_printf("%s.%s%s.%s.%s. %04X ", name->host, name->sub ? "_sub." : "", name->service, name->proto, name->domain, type); + } + + if (mdns_class == 0x0001) { + _mdns_dbg_printf("IN"); + } else { + _mdns_dbg_printf("%04X", mdns_class); + } + _mdns_dbg_printf("\n"); + } + } + + if (header.answers || header.servers || header.additional) { + uint16_t recordIndex = 0; + + while (content < (data + len)) { + + content = _mdns_parse_fqdn(data, content, name, len); + if (!content) { + _mdns_dbg_printf("ERROR: parse mdns records\n"); + break; + } + + uint16_t type = _mdns_read_u16(content, MDNS_TYPE_OFFSET); + uint16_t mdns_class = _mdns_read_u16(content, MDNS_CLASS_OFFSET); + uint32_t ttl = _mdns_read_u32(content, MDNS_TTL_OFFSET); + uint16_t data_len = _mdns_read_u16(content, MDNS_LEN_OFFSET); + const uint8_t *data_ptr = content + MDNS_DATA_OFFSET; + bool flush = !!(mdns_class & 0x8000); + mdns_class &= 0x7FFF; + + content = data_ptr + data_len; + if (content > (data + len)) { + _mdns_dbg_printf("ERROR: content length overflow\n"); + break; + } + + mdns_parsed_record_type_t record_type = MDNS_ANSWER; + + if (recordIndex >= (header.answers + header.servers)) { + record_type = MDNS_EXTRA; + } else if (recordIndex >= (header.answers)) { + record_type = MDNS_NS; + } + recordIndex++; + + if (record_type == MDNS_EXTRA) { + _mdns_dbg_printf(" X"); + } else if (record_type == MDNS_NS) { + _mdns_dbg_printf(" S"); + } else { + _mdns_dbg_printf(" A"); + } + + if (type == MDNS_TYPE_PTR) { + _mdns_dbg_printf(": %s%s%s.%s.%s. PTR ", name->host, name->host[0] ? "." : "", name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_SRV) { + _mdns_dbg_printf(": %s.%s.%s.%s. SRV ", name->host, name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_TXT) { + _mdns_dbg_printf(": %s.%s.%s.%s. TXT ", name->host, name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_A) { + _mdns_dbg_printf(": %s.%s. A ", name->host, name->domain); + } else if (type == MDNS_TYPE_AAAA) { + _mdns_dbg_printf(": %s.%s. AAAA ", name->host, name->domain); + } else if (type == MDNS_TYPE_NSEC) { + _mdns_dbg_printf(": %s.%s.%s.%s. NSEC ", name->host, name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_ANY) { + _mdns_dbg_printf(": %s.%s.%s.%s. ANY ", name->host, name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_OPT) { + _mdns_dbg_printf(": . OPT "); + } else { + _mdns_dbg_printf(": %s.%s.%s.%s. %04X ", name->host, name->service, name->proto, name->domain, type); + } + + if (mdns_class == 0x0001) { + _mdns_dbg_printf("IN "); + } else { + _mdns_dbg_printf("%04X ", mdns_class); + } + if (flush) { + _mdns_dbg_printf("FLUSH "); + } + _mdns_dbg_printf("%" PRIu32, ttl); + _mdns_dbg_printf("[%u] ", data_len); + if (type == MDNS_TYPE_PTR) { + if (!_mdns_parse_fqdn(data, data_ptr, name, len)) { + _mdns_dbg_printf("ERROR: parse PTR\n"); + continue; + } + _mdns_dbg_printf("%s.%s.%s.%s.\n", name->host, name->service, name->proto, name->domain); + } else if (type == MDNS_TYPE_SRV) { + if (!_mdns_parse_fqdn(data, data_ptr + MDNS_SRV_FQDN_OFFSET, name, len)) { + _mdns_dbg_printf("ERROR: parse SRV\n"); + continue; + } + uint16_t priority = _mdns_read_u16(data_ptr, MDNS_SRV_PRIORITY_OFFSET); + uint16_t weight = _mdns_read_u16(data_ptr, MDNS_SRV_WEIGHT_OFFSET); + uint16_t port = _mdns_read_u16(data_ptr, MDNS_SRV_PORT_OFFSET); + _mdns_dbg_printf("%u %u %u %s.%s.\n", priority, weight, port, name->host, name->domain); + } else if (type == MDNS_TYPE_TXT) { + uint16_t i = 0, y; + while (i < data_len) { + uint8_t partLen = data_ptr[i++]; + if ((i + partLen) > data_len) { + _mdns_dbg_printf("ERROR: parse TXT\n"); + break; + } + char txt[partLen + 1]; + for (y = 0; y < partLen; y++) { + char d = data_ptr[i++]; + txt[y] = d; + } + txt[partLen] = 0; + _mdns_dbg_printf("%s", txt); + if (i < data_len) { + _mdns_dbg_printf("; "); + } + } + _mdns_dbg_printf("\n"); + } else if (type == MDNS_TYPE_AAAA) { + esp_ip6_addr_t ip6; + memcpy(&ip6, data_ptr, sizeof(esp_ip6_addr_t)); + _mdns_dbg_printf(IPV6STR "\n", IPV62STR(ip6)); + } else if (type == MDNS_TYPE_A) { + esp_ip4_addr_t ip; + memcpy(&ip, data_ptr, sizeof(esp_ip4_addr_t)); + _mdns_dbg_printf(IPSTR "\n", IP2STR(&ip)); + } else if (type == MDNS_TYPE_NSEC) { + const uint8_t *old_ptr = data_ptr; + const uint8_t *new_ptr = _mdns_parse_fqdn(data, data_ptr, name, len); + if (new_ptr) { + _mdns_dbg_printf("%s.%s.%s.%s. ", name->host, name->service, name->proto, name->domain); + size_t diff = new_ptr - old_ptr; + data_len -= diff; + data_ptr = new_ptr; + } + size_t i; + for (i = 0; i < data_len; i++) { + _mdns_dbg_printf(" %02x", data_ptr[i]); + } + _mdns_dbg_printf("\n"); + } else if (type == MDNS_TYPE_OPT) { + uint16_t opCode = _mdns_read_u16(data_ptr, 0); + uint16_t opLen = _mdns_read_u16(data_ptr, 2); + _mdns_dbg_printf(" Code: %04x Data[%u]:", opCode, opLen); + size_t i; + for (i = 4; i < data_len; i++) { + _mdns_dbg_printf(" %02x", data_ptr[i]); + } + _mdns_dbg_printf("\n"); + } else { + size_t i; + for (i = 0; i < data_len; i++) { + _mdns_dbg_printf(" %02x", data_ptr[i]); + } + _mdns_dbg_printf("\n"); + } + } + } +} +#endif /* MDNS_ENABLE_DEBUG */ + +/** + * @brief Browse sync result action + */ +static esp_err_t _mdns_sync_browse_action(mdns_action_type_t type, mdns_browse_sync_t *browse_sync) +{ + mdns_action_t *action = NULL; + + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + if (!action) { + HOOK_MALLOC_FAILED; + return ESP_ERR_NO_MEM; + } + + action->type = type; + action->data.browse_sync.browse_sync = browse_sync; + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + return ESP_OK; +} + +/** + * @brief Browse action + */ +static esp_err_t _mdns_send_browse_action(mdns_action_type_t type, mdns_browse_t *browse) +{ + mdns_action_t *action = NULL; + + action = (mdns_action_t *)mdns_mem_malloc(sizeof(mdns_action_t)); + + if (!action) { + HOOK_MALLOC_FAILED; + return ESP_ERR_NO_MEM; + } + + action->type = type; + action->data.browse_add.browse = browse; + if (xQueueSend(_mdns_server->action_queue, &action, (TickType_t)0) != pdPASS) { + mdns_mem_free(action); + return ESP_ERR_NO_MEM; + } + return ESP_OK; +} + +/** + * @brief Free a browse item (Not free the list). + */ +static void _mdns_browse_item_free(mdns_browse_t *browse) +{ + mdns_mem_free(browse->service); + mdns_mem_free(browse->proto); + if (browse->result) { + _mdns_query_results_free(browse->result); + } + mdns_mem_free(browse); +} + +/** + * @brief Allocate new browse structure + */ +static mdns_browse_t *_mdns_browse_init(const char *service, const char *proto, mdns_browse_notify_t notifier) +{ + mdns_browse_t *browse = (mdns_browse_t *)mdns_mem_malloc(sizeof(mdns_browse_t)); + + if (!browse) { + HOOK_MALLOC_FAILED; + return NULL; + } + memset(browse, 0, sizeof(mdns_browse_t)); + + browse->state = BROWSE_INIT; + if (!_str_null_or_empty(service)) { + browse->service = mdns_mem_strndup(service, MDNS_NAME_BUF_LEN - 1); + if (!browse->service) { + _mdns_browse_item_free(browse); + return NULL; + } + } + + if (!_str_null_or_empty(proto)) { + browse->proto = mdns_mem_strndup(proto, MDNS_NAME_BUF_LEN - 1); + if (!browse->proto) { + _mdns_browse_item_free(browse); + return NULL; + } + } + + browse->notifier = notifier; + return browse; +} + +mdns_browse_t *mdns_browse_new(const char *service, const char *proto, mdns_browse_notify_t notifier) +{ + mdns_browse_t *browse = NULL; + + if (!_mdns_server || _str_null_or_empty(service) || _str_null_or_empty(proto)) { + return NULL; + } + + browse = _mdns_browse_init(service, proto, notifier); + if (!browse) { + return NULL; + } + + if (_mdns_send_browse_action(ACTION_BROWSE_ADD, browse)) { + _mdns_browse_item_free(browse); + return NULL; + } + + return browse; +} + +esp_err_t mdns_browse_delete(const char *service, const char *proto) +{ + mdns_browse_t *browse = NULL; + + if (!_mdns_server || _str_null_or_empty(service) || _str_null_or_empty(proto)) { + return ESP_FAIL; + } + + browse = _mdns_browse_init(service, proto, NULL); + if (!browse) { + return ESP_ERR_NO_MEM; + } + + if (_mdns_send_browse_action(ACTION_BROWSE_END, browse)) { + _mdns_browse_item_free(browse); + return ESP_ERR_NO_MEM; + } + return ESP_OK; +} + +/** + * @brief Mark browse as finished, remove and free it from browse chain + */ +static void _mdns_browse_finish(mdns_browse_t *browse) +{ + browse->state = BROWSE_OFF; + mdns_browse_t *b = _mdns_server->browse; + mdns_browse_t *target_free = NULL; + while (b) { + if (strlen(b->service) == strlen(browse->service) && memcmp(b->service, browse->service, strlen(b->service)) == 0 && + strlen(b->proto) == strlen(browse->proto) && memcmp(b->proto, browse->proto, strlen(b->proto)) == 0) { + target_free = b; + b = b->next; + queueDetach(mdns_browse_t, _mdns_server->browse, target_free); + _mdns_browse_item_free(target_free); + } else { + b = b->next; + } + } + _mdns_browse_item_free(browse); +} + +/** + * @brief Add new browse to the browse chain + */ +static void _mdns_browse_add(mdns_browse_t *browse) +{ + browse->state = BROWSE_RUNNING; + mdns_browse_t *queue = _mdns_server->browse; + bool found = false; + // looking for this browse in active browses + while (queue) { + if (strlen(queue->service) == strlen(browse->service) && memcmp(queue->service, browse->service, strlen(queue->service)) == 0 && + strlen(queue->proto) == strlen(browse->proto) && memcmp(queue->proto, browse->proto, strlen(queue->proto)) == 0) { + found = true; + break; + } + queue = queue->next; + } + if (!found) { + browse->next = _mdns_server->browse; + _mdns_server->browse = browse; + } + for (uint8_t interface_idx = 0; interface_idx < MDNS_MAX_INTERFACES; interface_idx++) { + _mdns_browse_send(browse, (mdns_if_t)interface_idx); + } + if (found) { + _mdns_browse_item_free(browse); + } +} + +/** + * @brief Send PTR query packet to all available interfaces for browsing. + */ +static void _mdns_browse_send(mdns_browse_t *browse, mdns_if_t interface) +{ + // Using search once for sending the PTR query + mdns_search_once_t search = {0}; + + search.instance = NULL; + search.service = browse->service; + search.proto = browse->proto; + search.type = MDNS_TYPE_PTR; + search.unicast = false; + search.result = NULL; + search.next = NULL; + + for (uint8_t protocol_idx = 0; protocol_idx < MDNS_IP_PROTOCOL_MAX; protocol_idx++) { + _mdns_search_send_pcb(&search, interface, (mdns_ip_protocol_t)protocol_idx); + } +} + +/** + * @brief Add result to browse, only add when the result is a new one. + */ +static esp_err_t _mdns_add_browse_result(mdns_browse_sync_t *sync_browse, mdns_result_t *r) +{ + mdns_browse_result_sync_t *sync_r = sync_browse->sync_result; + while (sync_r) { + if (sync_r->result == r) { + break; + } + sync_r = sync_r->next; + } + if (!sync_r) { + // Do not find, need to add the result to the list + mdns_browse_result_sync_t *new = (mdns_browse_result_sync_t *)mdns_mem_malloc(sizeof(mdns_browse_result_sync_t)); + + if (!new) { + HOOK_MALLOC_FAILED; + return ESP_ERR_NO_MEM; + } + new->result = r; + new->next = sync_browse->sync_result; + sync_browse->sync_result = new; + } + return ESP_OK; +} + +/** + * @brief Called from parser to add A/AAAA data to search result + */ +static void _mdns_browse_result_add_ip(mdns_browse_t *browse, const char *hostname, esp_ip_addr_t *ip, + mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl, mdns_browse_sync_t *out_sync_browse) +{ + if (out_sync_browse->browse == NULL) { + return; + } else { + if (out_sync_browse->browse != browse) { + return; + } + } + mdns_result_t *r = NULL; + mdns_ip_addr_t *r_a = NULL; + if (browse) { + r = browse->result; + while (r) { + if (r->ip_protocol == ip_protocol) { + // Find the target result in browse result. + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && !_str_null_or_empty(r->hostname) && !strcasecmp(hostname, r->hostname)) { + r_a = r->addr; + // Check if the address has already added in result. + while (r_a) { +#ifdef CONFIG_LWIP_IPV4 + if (r_a->addr.type == ip->type && r_a->addr.type == ESP_IPADDR_TYPE_V4 && r_a->addr.u_addr.ip4.addr == ip->u_addr.ip4.addr) { + break; + } +#endif +#ifdef CONFIG_LWIP_IPV6 + if (r_a->addr.type == ip->type && r_a->addr.type == ESP_IPADDR_TYPE_V6 && !memcmp(r_a->addr.u_addr.ip6.addr, ip->u_addr.ip6.addr, 16)) { + break; + } +#endif + r_a = r_a->next; + } + if (!r_a) { + // The current IP is a new one, add it to the link list. + mdns_ip_addr_t *a = NULL; + a = _mdns_result_addr_create_ip(ip); + if (!a) { + return; + } + a->next = r->addr; + r->addr = a; + if (r->ttl != ttl) { + if (r->ttl == 0) { + r->ttl = ttl; + } else { + _mdns_result_update_ttl(r, ttl); + } + } + if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) { + return; + } + break; + } + } + } + r = r->next; + } + } + return; +} + +/** + * @brief Called from packet parser to find matching running search + */ +static mdns_browse_t *_mdns_browse_find_from(mdns_browse_t *b, mdns_name_t *name, uint16_t type, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + // For browse, we only care about the SRV, TXT, A and AAAA + if (type != MDNS_TYPE_SRV && type != MDNS_TYPE_A && type != MDNS_TYPE_AAAA && type != MDNS_TYPE_TXT) { + return NULL; + } + mdns_result_t *r = NULL; + while (b) { + if (type == MDNS_TYPE_SRV || type == MDNS_TYPE_TXT) { + if (strcasecmp(name->service, b->service) + || strcasecmp(name->proto, b->proto)) { + b = b->next; + continue; + } + return b; + } else if (type == MDNS_TYPE_A || type == MDNS_TYPE_AAAA) { + r = b->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && !_str_null_or_empty(r->hostname) && !strcasecmp(name->host, r->hostname)) { + return b; + } + r = r->next; + } + b = b->next; + continue; + } + } + return b; +} + +static bool is_txt_item_in_list(mdns_txt_item_t txt, uint8_t txt_value_len, mdns_txt_item_t *txt_list, uint8_t *txt_value_len_list, size_t txt_count) +{ + for (size_t i = 0; i < txt_count; i++) { + if (strcmp(txt.key, txt_list[i].key) == 0) { + if (txt_value_len == txt_value_len_list[i] && memcmp(txt.value, txt_list[i].value, txt_value_len) == 0) { + return true; + } else { + // The key value is unique, so there is no need to continue searching. + return false; + } + } + } + return false; +} + +/** + * @brief Called from parser to add TXT data to search result + */ +static void _mdns_browse_result_add_txt(mdns_browse_t *browse, const char *instance, const char *service, const char *proto, + mdns_txt_item_t *txt, uint8_t *txt_value_len, size_t txt_count, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, + uint32_t ttl, mdns_browse_sync_t *out_sync_browse) +{ + if (out_sync_browse->browse == NULL) { + return; + } else { + if (out_sync_browse->browse != browse) { + return; + } + } + mdns_result_t *r = browse->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && + !_str_null_or_empty(r->instance_name) && !strcasecmp(instance, r->instance_name) && + !_str_null_or_empty(r->service_type) && !strcasecmp(service, r->service_type) && + !_str_null_or_empty(r->proto) && !strcasecmp(proto, r->proto)) { + bool should_update = false; + if (r->txt) { + // Check if txt changed + if (txt_count != r->txt_count) { + should_update = true; + } else { + for (size_t txt_index = 0; txt_index < txt_count; txt_index++) { + if (!is_txt_item_in_list(txt[txt_index], txt_value_len[txt_index], r->txt, r->txt_value_len, r->txt_count)) { + should_update = true; + break; + } + } + } + // If the result has a previous txt entry, we delete it and re-add. + for (size_t i = 0; i < r->txt_count; i++) { + mdns_mem_free((char *)(r->txt[i].key)); + mdns_mem_free((char *)(r->txt[i].value)); + } + mdns_mem_free(r->txt); + mdns_mem_free(r->txt_value_len); + } + r->txt = txt; + r->txt_value_len = txt_value_len; + r->txt_count = txt_count; + if (r->ttl != ttl) { + uint32_t previous_ttl = r->ttl; + if (r->ttl == 0) { + r->ttl = ttl; + } else { + _mdns_result_update_ttl(r, ttl); + } + if (previous_ttl != r->ttl) { + should_update = true; + } + } + if (should_update) { + if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) { + return; + } + } + return; + } + r = r->next; + } + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); + if (!r) { + HOOK_MALLOC_FAILED; + goto free_txt; + } + memset(r, 0, sizeof(mdns_result_t)); + r->instance_name = mdns_mem_strdup(instance); + r->service_type = mdns_mem_strdup(service); + r->proto = mdns_mem_strdup(proto); + if (!r->instance_name || !r->service_type || !r->proto) { + mdns_mem_free(r->instance_name); + mdns_mem_free(r->service_type); + mdns_mem_free(r->proto); + mdns_mem_free(r); + return; + } + r->txt = txt; + r->txt_value_len = txt_value_len; + r->txt_count = txt_count; + r->esp_netif = _mdns_get_esp_netif(tcpip_if); + r->ip_protocol = ip_protocol; + r->ttl = ttl; + r->next = browse->result; + browse->result = r; + _mdns_add_browse_result(out_sync_browse, r); + return; + +free_txt: + for (size_t i = 0; i < txt_count; i++) { + mdns_mem_free((char *)(txt[i].key)); + mdns_mem_free((char *)(txt[i].value)); + } + mdns_mem_free(txt); + mdns_mem_free(txt_value_len); + return; +} + +static esp_err_t _mdns_copy_address_in_previous_result(mdns_result_t *result_list, mdns_result_t *r) +{ + while (result_list) { + if (!_str_null_or_empty(result_list->hostname) && !_str_null_or_empty(r->hostname) && !strcasecmp(result_list->hostname, r->hostname) && + result_list->ip_protocol == r->ip_protocol && result_list->addr && !r->addr) { + // If there is a same hostname in previous result, we need to copy the address here. + r->addr = copy_address_list(result_list->addr); + if (!r->addr) { + return ESP_ERR_NO_MEM; + } + break; + } else { + result_list = result_list->next; + } + } + return ESP_OK; +} + +/** + * @brief Called from parser to add SRV data to search result + */ +static void _mdns_browse_result_add_srv(mdns_browse_t *browse, const char *hostname, const char *instance, const char *service, const char *proto, + uint16_t port, mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol, uint32_t ttl, mdns_browse_sync_t *out_sync_browse) +{ + if (out_sync_browse->browse == NULL) { + return; + } else { + if (out_sync_browse->browse != browse) { + return; + } + } + mdns_result_t *r = browse->result; + while (r) { + if (r->esp_netif == _mdns_get_esp_netif(tcpip_if) && r->ip_protocol == ip_protocol && + !_str_null_or_empty(r->instance_name) && !strcasecmp(instance, r->instance_name) && + !_str_null_or_empty(r->service_type) && !strcasecmp(service, r->service_type) && + !_str_null_or_empty(r->proto) && !strcasecmp(proto, r->proto)) { + if (_str_null_or_empty(r->hostname) || strcasecmp(hostname, r->hostname)) { + r->hostname = mdns_mem_strdup(hostname); + r->port = port; + if (!r->hostname) { + HOOK_MALLOC_FAILED; + return; + } + if (!r->addr) { + esp_err_t err = _mdns_copy_address_in_previous_result(browse->result, r); + if (err == ESP_ERR_NO_MEM) { + return; + } + } + if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) { + return; + } + } + if (r->ttl != ttl) { + uint32_t previous_ttl = r->ttl; + if (r->ttl == 0) { + r->ttl = ttl; + } else { + _mdns_result_update_ttl(r, ttl); + } + if (previous_ttl != r->ttl) { + if (_mdns_add_browse_result(out_sync_browse, r) != ESP_OK) { + return; + } + } + } + return; + } + r = r->next; + } + r = (mdns_result_t *)mdns_mem_malloc(sizeof(mdns_result_t)); + if (!r) { + HOOK_MALLOC_FAILED; + return; + } + + memset(r, 0, sizeof(mdns_result_t)); + r->hostname = mdns_mem_strdup(hostname); + r->instance_name = mdns_mem_strdup(instance); + r->service_type = mdns_mem_strdup(service); + r->proto = mdns_mem_strdup(proto); + if (!r->hostname || !r->instance_name || !r->service_type || !r->proto) { + HOOK_MALLOC_FAILED; + mdns_mem_free(r->hostname); + mdns_mem_free(r->instance_name); + mdns_mem_free(r->service_type); + mdns_mem_free(r->proto); + mdns_mem_free(r); + return; + } + r->port = port; + r->esp_netif = _mdns_get_esp_netif(tcpip_if); + r->ip_protocol = ip_protocol; + r->ttl = ttl; + r->next = browse->result; + browse->result = r; + _mdns_add_browse_result(out_sync_browse, r); + return; +} + +static void _mdns_browse_sync(mdns_browse_sync_t *browse_sync) +{ + mdns_browse_t *browse = browse_sync->browse; + mdns_browse_result_sync_t *sync_result = browse_sync->sync_result; + while (sync_result) { + mdns_result_t *result = sync_result->result; +#ifdef MDNS_ENABLE_DEBUG + debug_printf_browse_result(result, browse_sync->browse); +#endif + browse->notifier(result); + if (result->ttl == 0) { + queueDetach(mdns_result_t, browse->result, result); + // Just free current result + result->next = NULL; + mdns_query_results_free(result); + } + sync_result = sync_result->next; + } +} + +#ifdef MDNS_ENABLE_DEBUG +void _debug_printf_result(mdns_result_t *r_t) +{ + mdns_ip_addr_t *r_a = NULL; + int addr_count = 0; + _mdns_dbg_printf("result esp_netif: %p\n", r_t->esp_netif); + _mdns_dbg_printf("result ip_protocol: %d\n", r_t->ip_protocol); + _mdns_dbg_printf("result hostname: %s\n", _str_null_or_empty(r_t->hostname) ? "NULL" : r_t->hostname); + _mdns_dbg_printf("result instance_name: %s\n", _str_null_or_empty(r_t->instance_name) ? "NULL" : r_t->instance_name); + _mdns_dbg_printf("result service_type: %s\n", _str_null_or_empty(r_t->service_type) ? "NULL" : r_t->service_type); + _mdns_dbg_printf("result proto: %s\n", _str_null_or_empty(r_t->proto) ? "NULL" : r_t->proto); + _mdns_dbg_printf("result port: %d\n", r_t->port); + _mdns_dbg_printf("result ttl: %" PRIu32 "\n", r_t->ttl); + for (int i = 0; i < r_t->txt_count; i++) { + _mdns_dbg_printf("result txt item%d, key: %s, value: %s\n", i, r_t->txt[i].key, r_t->txt[i].value); + } + r_a = r_t->addr; + while (r_a) { +#ifdef CONFIG_LWIP_IPV4 + if (r_a->addr.type == ESP_IPADDR_TYPE_V4) { + _mdns_dbg_printf("Addr%d: " IPSTR "\n", addr_count++, IP2STR(&r_a->addr.u_addr.ip4)); + } +#endif +#ifdef CONFIG_LWIP_IPV6 + if (r_a->addr.type == ESP_IPADDR_TYPE_V6) { + _mdns_dbg_printf("Addr%d: " IPV6STR "\n", addr_count++, IPV62STR(r_a->addr.u_addr.ip6)); + } +#endif + r_a = r_a->next; + } +} + +static void debug_printf_browse_result(mdns_result_t *r_t, mdns_browse_t *b_t) +{ + _mdns_dbg_printf("----------------sync browse %s.%s result---------------\n", b_t->service, b_t->proto); + _mdns_dbg_printf("browse pointer: %p\n", b_t); + _debug_printf_result(r_t); +} + +static void debug_printf_browse_result_all(mdns_result_t *r_t) +{ + int count = 0; + while (r_t) { + _mdns_dbg_printf("----------------result %d---------------\n", count++); + _debug_printf_result(r_t); + r_t = r_t->next; + } +} +#endif // MDNS_ENABLE_DEBUG diff --git a/managed_components/espressif__mdns/mdns_console.c b/managed_components/espressif__mdns/mdns_console.c new file mode 100644 index 0000000..b3448ff --- /dev/null +++ b/managed_components/espressif__mdns/mdns_console.c @@ -0,0 +1,1452 @@ +/* + * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#include +#include +#include "esp_console.h" +#include "argtable3/argtable3.h" +#include "mdns.h" +#include "mdns_private.h" +#include "inttypes.h" +#include "mdns_mem_caps.h" + +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; + while (r) { + if (r->esp_netif) { + printf("%d: Interface: %s, Type: %s, TTL: %" PRIu32 "\n", i++, esp_netif_get_ifkey(r->esp_netif), + ip_protocol_str[r->ip_protocol], r->ttl); + } + 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] ", (int)r->txt_count); + for (size_t 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 == 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 struct { + struct arg_str *hostname; + struct arg_int *timeout; + struct arg_end *end; +} mdns_query_a_args; + +#ifdef CONFIG_LWIP_IPV4 +static int cmd_mdns_query_a(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_query_a_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_query_a_args.end, argv[0]); + return 1; + } + + const char *hostname = mdns_query_a_args.hostname->sval[0]; + int timeout = mdns_query_a_args.timeout->ival[0]; + + if (!hostname || !hostname[0]) { + printf("ERROR: Hostname not supplied\n"); + return 1; + } + + if (timeout <= 0) { + timeout = 1000; + } + + printf("Query A: %s.local, Timeout: %d\n", hostname, timeout); + + struct esp_ip4_addr addr; + addr.addr = 0; + + esp_err_t err = mdns_query_a(hostname, timeout, &addr); + if (err) { + if (err == ESP_ERR_NOT_FOUND) { + printf("ERROR: Host was not found!\n"); + return 0; + } + printf("ERROR: Query Failed\n"); + return 1; + } + + printf(IPSTR "\n", IP2STR(&addr)); + + return 0; +} + +static void register_mdns_query_a(void) +{ + mdns_query_a_args.hostname = arg_str1(NULL, NULL, "", "Hostname that is searched for"); + mdns_query_a_args.timeout = arg_int0("t", "timeout", "", "Timeout for this query"); + mdns_query_a_args.end = arg_end(2); + + const esp_console_cmd_t cmd_init = { + .command = "mdns_query_a", + .help = "Query MDNS for IPv4", + .hint = NULL, + .func = &cmd_mdns_query_a, + .argtable = &mdns_query_a_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); +} +#endif /* CONFIG_LWIP_IPV4 */ + +#ifdef CONFIG_LWIP_IPV6 +static int cmd_mdns_query_aaaa(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_query_a_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_query_a_args.end, argv[0]); + return 1; + } + + const char *hostname = mdns_query_a_args.hostname->sval[0]; + int timeout = mdns_query_a_args.timeout->ival[0]; + + if (!hostname || !hostname[0]) { + printf("ERROR: Hostname not supplied\n"); + return 1; + } + + if (timeout <= 0) { + timeout = 1000; + } + + printf("Query AAAA: %s.local, Timeout: %d\n", hostname, timeout); + + struct esp_ip6_addr addr; + memset(addr.addr, 0, 16); + + esp_err_t err = mdns_query_aaaa(hostname, timeout, &addr); + if (err) { + if (err == ESP_ERR_NOT_FOUND) { + printf("Host was not found!\n"); + return 0; + } + printf("ERROR: Query Failed\n"); + return 1; + } + + printf(IPV6STR "\n", IPV62STR(addr)); + + return 0; +} + +static void register_mdns_query_aaaa(void) +{ + mdns_query_a_args.hostname = arg_str1(NULL, NULL, "", "Hostname that is searched for"); + mdns_query_a_args.timeout = arg_int0("t", "timeout", "", "Timeout for this query"); + mdns_query_a_args.end = arg_end(2); + + const esp_console_cmd_t cmd_init = { + .command = "mdns_query_aaaa", + .help = "Query MDNS for IPv6", + .hint = NULL, + .func = &cmd_mdns_query_aaaa, + .argtable = &mdns_query_a_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); +} +#endif /* CONFIG_LWIP_IPV6 */ + +static struct { + struct arg_str *instance; + struct arg_str *service; + struct arg_str *proto; + struct arg_int *timeout; + struct arg_end *end; +} mdns_query_srv_args; + +static int cmd_mdns_query_srv(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_query_srv_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_query_srv_args.end, argv[0]); + return 1; + } + + const char *instance = mdns_query_srv_args.instance->sval[0]; + const char *service = mdns_query_srv_args.service->sval[0]; + const char *proto = mdns_query_srv_args.proto->sval[0]; + int timeout = mdns_query_srv_args.timeout->ival[0]; + + if (timeout <= 0) { + timeout = 1000; + } + + printf("Query SRV: %s.%s.%s.local, Timeout: %d\n", instance, service, proto, timeout); + + mdns_result_t *results = NULL; + esp_err_t err = mdns_query_srv(instance, service, proto, timeout, &results); + if (err) { + printf("ERROR: Query Failed\n"); + return 1; + } + if (!results) { + printf("No results found!\n"); + return 0; + } + mdns_print_results(results); + mdns_query_results_free(results); + return 0; +} + +static void register_mdns_query_srv(void) +{ + mdns_query_srv_args.instance = arg_str1(NULL, NULL, "", "Instance to search for"); + mdns_query_srv_args.service = arg_str1(NULL, NULL, "", "Service to search for (ex. _http, _smb, etc.)"); + mdns_query_srv_args.proto = arg_str1(NULL, NULL, "", "Protocol to search for (_tcp, _udp, etc.)"); + mdns_query_srv_args.timeout = arg_int0("t", "timeout", "", "Timeout for this query"); + mdns_query_srv_args.end = arg_end(2); + + const esp_console_cmd_t cmd_init = { + .command = "mdns_query_srv", + .help = "Query MDNS for Service SRV", + .hint = NULL, + .func = &cmd_mdns_query_srv, + .argtable = &mdns_query_srv_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); +} + +static struct { + struct arg_str *instance; + struct arg_str *service; + struct arg_str *proto; + struct arg_int *timeout; + struct arg_end *end; +} mdns_query_txt_args; + +static int cmd_mdns_query_txt(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_query_txt_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_query_txt_args.end, argv[0]); + return 1; + } + + const char *instance = mdns_query_txt_args.instance->sval[0]; + const char *service = mdns_query_txt_args.service->sval[0]; + const char *proto = mdns_query_txt_args.proto->sval[0]; + int timeout = mdns_query_txt_args.timeout->ival[0]; + + printf("Query TXT: %s.%s.%s.local, Timeout: %d\n", instance, service, proto, timeout); + + if (timeout <= 0) { + timeout = 5000; + } + + mdns_result_t *results = NULL; + esp_err_t err = mdns_query_txt(instance, service, proto, timeout, &results); + if (err) { + printf("ERROR: Query Failed\n"); + return 1; + } + if (!results) { + printf("No results found!\n"); + return 0; + } + + mdns_print_results(results); + mdns_query_results_free(results); + return 0; +} + +static void register_mdns_query_txt(void) +{ + mdns_query_txt_args.instance = arg_str1(NULL, NULL, "", "Instance to search for"); + mdns_query_txt_args.service = arg_str1(NULL, NULL, "", "Service to search for (ex. _http, _smb, etc.)"); + mdns_query_txt_args.proto = arg_str1(NULL, NULL, "", "Protocol to search for (_tcp, _udp, etc.)"); + mdns_query_txt_args.timeout = arg_int0("t", "timeout", "", "Timeout for this query"); + mdns_query_txt_args.end = arg_end(2); + + const esp_console_cmd_t cmd_init = { + .command = "mdns_query_txt", + .help = "Query MDNS for Service TXT", + .hint = NULL, + .func = &cmd_mdns_query_txt, + .argtable = &mdns_query_txt_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_int *timeout; + struct arg_int *max_results; + struct arg_end *end; +} mdns_query_ptr_args; + +static int cmd_mdns_query_ptr(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_query_ptr_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_query_ptr_args.end, argv[0]); + return 1; + } + + const char *service = mdns_query_ptr_args.service->sval[0]; + const char *proto = mdns_query_ptr_args.proto->sval[0]; + int timeout = mdns_query_ptr_args.timeout->ival[0]; + int max_results = mdns_query_ptr_args.max_results->ival[0]; + + if (timeout <= 0) { + timeout = 5000; + } + + if (max_results <= 0 || max_results > 255) { + max_results = 255; + } + + printf("Query PTR: %s.%s.local, Timeout: %d, Max Results: %d\n", service, proto, timeout, max_results); + + mdns_result_t *results = NULL; + esp_err_t err = mdns_query_ptr(service, proto, timeout, max_results, &results); + if (err) { + printf("ERROR: Query Failed\n"); + return 1; + } + if (!results) { + printf("No results found!\n"); + return 0; + } + + mdns_print_results(results); + mdns_query_results_free(results); + return 0; +} + +static void register_mdns_query_ptr(void) +{ + mdns_query_ptr_args.service = arg_str1(NULL, NULL, "", "Service to search for (ex. _http, _smb, etc.)"); + mdns_query_ptr_args.proto = arg_str1(NULL, NULL, "", "Protocol to search for (_tcp, _udp, etc.)"); + mdns_query_ptr_args.timeout = arg_int0("t", "timeout", "", "Timeout for this query"); + mdns_query_ptr_args.max_results = arg_int0("m", "max_results", "", "Maximum results returned"); + mdns_query_ptr_args.end = arg_end(2); + + const esp_console_cmd_t cmd_init = { + .command = "mdns_query_ptr", + .help = "Query MDNS for Service", + .hint = NULL, + .func = &cmd_mdns_query_ptr, + .argtable = &mdns_query_ptr_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); +} + +static struct { + struct arg_str *hostname; + struct arg_int *timeout; + struct arg_int *max_results; + struct arg_end *end; +} mdns_query_ip_args; + +static int cmd_mdns_query_ip(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_query_ip_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_query_ip_args.end, argv[0]); + return 1; + } + + const char *hostname = mdns_query_ip_args.hostname->sval[0]; + int timeout = mdns_query_ip_args.timeout->ival[0]; + int max_results = mdns_query_ip_args.max_results->ival[0]; + + if (!hostname || !hostname[0]) { + printf("ERROR: Hostname not supplied\n"); + return 1; + } + + if (timeout <= 0) { + timeout = 1000; + } + + if (max_results < 0 || max_results > 255) { + max_results = 255; + } + + printf("Query IP: %s.local, Timeout: %d, Max Results: %d\n", hostname, timeout, max_results); + + mdns_result_t *results = NULL; + esp_err_t err = mdns_query(hostname, NULL, NULL, MDNS_TYPE_ANY, timeout, max_results, &results); + if (err) { + printf("ERROR: Query Failed\n"); + return 1; + } + if (!results) { + printf("No results found!\n"); + return 0; + } + mdns_print_results(results); + mdns_query_results_free(results); + + return 0; +} + +static void register_mdns_query_ip(void) +{ + mdns_query_ip_args.hostname = arg_str1(NULL, NULL, "", "Hostname that is searched for"); + mdns_query_ip_args.timeout = arg_int0("t", "timeout", "", "Timeout for this query"); + mdns_query_ip_args.max_results = arg_int0("m", "max_results", "", "Maximum results returned"); + mdns_query_ip_args.end = arg_end(2); + + const esp_console_cmd_t cmd_init = { + .command = "mdns_query_ip", + .help = "Query MDNS for IP", + .hint = NULL, + .func = &cmd_mdns_query_ip, + .argtable = &mdns_query_ip_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); +} + +static struct { + struct arg_str *instance; + struct arg_str *service; + struct arg_str *proto; + struct arg_int *timeout; + struct arg_int *max_results; + struct arg_end *end; +} mdns_query_svc_args; + +static int cmd_mdns_query_svc(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_query_svc_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_query_svc_args.end, argv[0]); + return 1; + } + + const char *instance = mdns_query_svc_args.instance->sval[0]; + const char *service = mdns_query_svc_args.service->sval[0]; + const char *proto = mdns_query_svc_args.proto->sval[0]; + int timeout = mdns_query_svc_args.timeout->ival[0]; + int max_results = mdns_query_svc_args.max_results->ival[0]; + + if (timeout <= 0) { + timeout = 5000; + } + + if (max_results < 0 || max_results > 255) { + max_results = 255; + } + + printf("Query SVC: %s.%s.%s.local, Timeout: %d, Max Results: %d\n", instance, service, proto, timeout, max_results); + + mdns_result_t *results = NULL; + esp_err_t err = mdns_query(instance, service, proto, MDNS_TYPE_ANY, timeout, max_results, &results); + if (err) { + printf("ERROR: Query Failed\n"); + return 1; + } + if (!results) { + printf("No results found!\n"); + return 0; + } + + mdns_print_results(results); + mdns_query_results_free(results); + return 0; +} + +static void register_mdns_query_svc(void) +{ + mdns_query_svc_args.instance = arg_str1(NULL, NULL, "", "Instance to search for"); + mdns_query_svc_args.service = arg_str1(NULL, NULL, "", "Service to search for (ex. _http, _smb, etc.)"); + mdns_query_svc_args.proto = arg_str1(NULL, NULL, "", "Protocol to search for (_tcp, _udp, etc.)"); + mdns_query_svc_args.timeout = arg_int0("t", "timeout", "", "Timeout for this query"); + mdns_query_svc_args.max_results = arg_int0("m", "max_results", "", "Maximum results returned"); + mdns_query_svc_args.end = arg_end(2); + + const esp_console_cmd_t cmd_init = { + .command = "mdns_query_svc", + .help = "Query MDNS for Service TXT & SRV", + .hint = NULL, + .func = &cmd_mdns_query_svc, + .argtable = &mdns_query_svc_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); +} + +static struct { + struct arg_str *hostname; + struct arg_str *instance; + struct arg_end *end; +} mdns_init_args; + +static int cmd_mdns_init(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_init_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_init_args.end, argv[0]); + return 1; + } + + ESP_ERROR_CHECK(mdns_init()); + + if (mdns_init_args.hostname->sval[0]) { + ESP_ERROR_CHECK(mdns_hostname_set(mdns_init_args.hostname->sval[0])); + printf("MDNS: Hostname: %s\n", mdns_init_args.hostname->sval[0]); + } + + if (mdns_init_args.instance->count) { + ESP_ERROR_CHECK(mdns_instance_name_set(mdns_init_args.instance->sval[0])); + printf("MDNS: Instance: %s\n", mdns_init_args.instance->sval[0]); + } + + return 0; +} + +static void register_mdns_init(void) +{ + mdns_init_args.hostname = arg_str0("h", "hostname", "", "Hostname that the server will advertise"); + mdns_init_args.instance = arg_str0("i", "instance", "", "Default instance name for services"); + mdns_init_args.end = arg_end(2); + + const esp_console_cmd_t cmd_init = { + .command = "mdns_init", + .help = "Start MDNS Server", + .hint = NULL, + .func = &cmd_mdns_init, + .argtable = &mdns_init_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_init)); +} + +static int cmd_mdns_free(int argc, char **argv) +{ + mdns_free(); + return 0; +} + +static void register_mdns_free(void) +{ + const esp_console_cmd_t cmd_free = { + .command = "mdns_free", + .help = "Stop MDNS Server", + .hint = NULL, + .func = &cmd_mdns_free, + .argtable = NULL + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_free)); +} + +static struct { + struct arg_str *hostname; + struct arg_end *end; +} mdns_set_hostname_args; + +static int cmd_mdns_set_hostname(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_set_hostname_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_set_hostname_args.end, argv[0]); + return 1; + } + + if (mdns_set_hostname_args.hostname->sval[0] == NULL) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + + ESP_ERROR_CHECK(mdns_hostname_set(mdns_set_hostname_args.hostname->sval[0])); + return 0; +} + +static void register_mdns_set_hostname(void) +{ + mdns_set_hostname_args.hostname = arg_str1(NULL, NULL, "", "Hostname that the server will advertise"); + mdns_set_hostname_args.end = arg_end(2); + + const esp_console_cmd_t cmd_set_hostname = { + .command = "mdns_set_hostname", + .help = "Set MDNS Server hostname", + .hint = NULL, + .func = &cmd_mdns_set_hostname, + .argtable = &mdns_set_hostname_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_set_hostname)); +} + +static struct { + struct arg_str *instance; + struct arg_end *end; +} mdns_set_instance_args; + +static int cmd_mdns_set_instance(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_set_instance_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_set_instance_args.end, argv[0]); + return 1; + } + + if (mdns_set_instance_args.instance->sval[0] == NULL) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + + ESP_ERROR_CHECK(mdns_instance_name_set(mdns_set_instance_args.instance->sval[0])); + return 0; +} + +static void register_mdns_set_instance(void) +{ + mdns_set_instance_args.instance = arg_str1(NULL, NULL, "", "Default instance name for services"); + mdns_set_instance_args.end = arg_end(2); + + const esp_console_cmd_t cmd_set_instance = { + .command = "mdns_set_instance", + .help = "Set MDNS Server Istance Name", + .hint = NULL, + .func = &cmd_mdns_set_instance, + .argtable = &mdns_set_instance_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_set_instance)); +} + +static mdns_txt_item_t *_convert_items(const char **values, int count) +{ + int i = 0, e; + const char *value = NULL; + mdns_txt_item_t *items = (mdns_txt_item_t *) mdns_mem_malloc(sizeof(mdns_txt_item_t) * count); + if (!items) { + printf("ERROR: No Memory!\n"); + goto fail; + + } + memset(items, 0, sizeof(mdns_txt_item_t) * count); + + for (i = 0; i < count; i++) { + value = values[i]; + char *esign = strchr(value, '='); + if (!esign) { + printf("ERROR: Equal sign not found in '%s'!\n", value); + goto fail; + } + int var_len = esign - value; + int val_len = strlen(value) - var_len - 1; + char *var = (char *)mdns_mem_malloc(var_len + 1); + if (var == NULL) { + printf("ERROR: No Memory!\n"); + goto fail; + } + char *val = (char *)mdns_mem_malloc(val_len + 1); + if (val == NULL) { + printf("ERROR: No Memory!\n"); + mdns_mem_free(var); + goto fail; + } + memcpy(var, value, var_len); + var[var_len] = 0; + memcpy(val, esign + 1, val_len); + val[val_len] = 0; + + items[i].key = var; + items[i].value = val; + } + + return items; + +fail: + for (e = 0; e < i; e++) { + mdns_mem_free((char *)items[e].key); + mdns_mem_free((char *)items[e].value); + } + mdns_mem_free(items); + return NULL; +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_int *port; + struct arg_str *instance; + struct arg_str *host; + struct arg_str *txt; + struct arg_end *end; +} mdns_add_args; + +static int cmd_mdns_service_add(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_add_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_add_args.end, argv[0]); + return 1; + } + + if (!mdns_add_args.service->sval[0] || !mdns_add_args.proto->sval[0] || !mdns_add_args.port->ival[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + const char *instance = NULL; + if (mdns_add_args.instance->sval[0] && mdns_add_args.instance->sval[0][0]) { + instance = mdns_add_args.instance->sval[0]; + printf("MDNS: Service Instance: %s\n", instance); + } + const char *host = NULL; + if (mdns_add_args.host->count && mdns_add_args.host->sval[0]) { + host = mdns_add_args.host->sval[0]; + printf("MDNS: Service for delegated host: %s\n", host); + } + mdns_txt_item_t *items = NULL; + if (mdns_add_args.txt->count) { + items = _convert_items(mdns_add_args.txt->sval, mdns_add_args.txt->count); + if (!items) { + printf("ERROR: No Memory!\n"); + return 1; + + } + } + + ESP_ERROR_CHECK(mdns_service_add_for_host(instance, mdns_add_args.service->sval[0], mdns_add_args.proto->sval[0], + host, mdns_add_args.port->ival[0], items, mdns_add_args.txt->count)); + mdns_mem_free(items); + return 0; +} + +static void register_mdns_service_add(void) +{ + mdns_add_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_add_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_add_args.port = arg_int1(NULL, NULL, "", "Service Port"); + mdns_add_args.instance = arg_str0("i", "instance", "", "Instance name"); + mdns_add_args.host = arg_str0("h", "host", "", "Service for this (delegated) host"); + mdns_add_args.txt = arg_strn(NULL, NULL, "item", 0, 30, "TXT Items (name=value)"); + mdns_add_args.end = arg_end(2); + + const esp_console_cmd_t cmd_add = { + .command = "mdns_service_add", + .help = "Add service to MDNS", + .hint = NULL, + .func = &cmd_mdns_service_add, + .argtable = &mdns_add_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_add)); +} + +static struct { + struct arg_str *instance; + struct arg_str *service; + struct arg_str *proto; + struct arg_str *host; + struct arg_end *end; +} mdns_remove_args; + +static int cmd_mdns_service_remove(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_remove_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_remove_args.end, argv[0]); + return 1; + } + + if (!mdns_remove_args.service->sval[0] || !mdns_remove_args.proto->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + + const char *instance = NULL; + if (mdns_remove_args.instance->count && mdns_remove_args.instance->sval[0]) { + instance = mdns_remove_args.instance->sval[0]; + } + const char *host = NULL; + if (mdns_remove_args.host->count && mdns_remove_args.host->sval[0]) { + host = mdns_remove_args.host->sval[0]; + } + + ESP_ERROR_CHECK(mdns_service_remove_for_host(instance, mdns_remove_args.service->sval[0], mdns_remove_args.proto->sval[0], host)); + return 0; +} + +static void register_mdns_service_remove(void) +{ + mdns_remove_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_remove_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_remove_args.host = arg_str0("h", "host", "", "Service for this (delegated) host"); + mdns_remove_args.instance = arg_str0("i", "instance", "", "Instance name"); + mdns_remove_args.end = arg_end(4); + + const esp_console_cmd_t cmd_remove = { + .command = "mdns_service_remove", + .help = "Remove service from MDNS", + .hint = NULL, + .func = &cmd_mdns_service_remove, + .argtable = &mdns_remove_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_remove)); +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_str *instance; + struct arg_str *host; + struct arg_str *old_instance; + struct arg_end *end; +} mdns_service_instance_set_args; + +static int cmd_mdns_service_instance_set(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_service_instance_set_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_service_instance_set_args.end, argv[0]); + return 1; + } + + if (!mdns_service_instance_set_args.service->sval[0] || !mdns_service_instance_set_args.proto->sval[0] || !mdns_service_instance_set_args.instance->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + const char *host = NULL; + if (mdns_service_instance_set_args.host->count && mdns_service_instance_set_args.host->sval[0]) { + host = mdns_service_instance_set_args.host->sval[0]; + } + const char *old_instance = NULL; + if (mdns_service_instance_set_args.old_instance->count && mdns_service_instance_set_args.old_instance->sval[0]) { + old_instance = mdns_service_instance_set_args.old_instance->sval[0]; + } + esp_err_t err = mdns_service_instance_name_set_for_host(old_instance, mdns_service_instance_set_args.service->sval[0], mdns_service_instance_set_args.proto->sval[0], host, mdns_service_instance_set_args.instance->sval[0]); + if (err != ESP_OK) { + printf("mdns_service_instance_name_set_for_host() failed with %s\n", esp_err_to_name(err)); + return 1; + } + + return 0; +} + +static void register_mdns_service_instance_set(void) +{ + mdns_service_instance_set_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_service_instance_set_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_service_instance_set_args.instance = arg_str1(NULL, NULL, "", "Instance name"); + mdns_service_instance_set_args.host = arg_str0("h", "host", "", "Service for this (delegated) host"); + mdns_service_instance_set_args.old_instance = arg_str0("i", "old_instance", "", "Instance name before update"); + mdns_service_instance_set_args.end = arg_end(4); + + const esp_console_cmd_t cmd_add = { + .command = "mdns_service_instance_set", + .help = "Set MDNS Service Instance Name", + .hint = NULL, + .func = &cmd_mdns_service_instance_set, + .argtable = &mdns_service_instance_set_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_add)); +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_int *port; + struct arg_str *host; + struct arg_str *instance; + struct arg_end *end; +} mdns_service_port_set_args; + +static int cmd_mdns_service_port_set(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_service_port_set_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_service_port_set_args.end, argv[0]); + return 1; + } + + if (!mdns_service_port_set_args.service->sval[0] || !mdns_service_port_set_args.proto->sval[0] || !mdns_service_port_set_args.port->ival[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + + const char *host = NULL; + if (mdns_service_port_set_args.host->count && mdns_service_port_set_args.host->sval[0]) { + host = mdns_service_port_set_args.host->sval[0]; + } + const char *instance = NULL; + if (mdns_service_port_set_args.instance->count && mdns_service_port_set_args.instance->sval[0]) { + instance = mdns_service_port_set_args.instance->sval[0]; + } + esp_err_t err = mdns_service_port_set_for_host(instance, mdns_service_port_set_args.service->sval[0], mdns_service_port_set_args.proto->sval[0], host, mdns_service_port_set_args.port->ival[0]); + if (err != ESP_OK) { + printf("mdns_service_port_set_for_host() failed with %s\n", esp_err_to_name(err)); + return 1; + } + return 0; +} + +static void register_mdns_service_port_set(void) +{ + mdns_service_port_set_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_service_port_set_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_service_port_set_args.port = arg_int1(NULL, NULL, "", "Service Port"); + mdns_service_port_set_args.host = arg_str0("h", "host", "", "Service for this (delegated) host"); + mdns_service_port_set_args.instance = arg_str0("i", "instance", "", "Instance name"); + mdns_service_port_set_args.end = arg_end(2); + + const esp_console_cmd_t cmd_add = { + .command = "mdns_service_port_set", + .help = "Set MDNS Service port", + .hint = NULL, + .func = &cmd_mdns_service_port_set, + .argtable = &mdns_service_port_set_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_add)); +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_str *instance; + struct arg_str *host; + struct arg_str *txt; + struct arg_end *end; +} mdns_txt_replace_args; + +static int cmd_mdns_service_txt_replace(int argc, char **argv) +{ + mdns_txt_item_t *items = NULL; + int nerrors = arg_parse(argc, argv, (void **) &mdns_txt_replace_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_txt_replace_args.end, argv[0]); + return 1; + } + + if (!mdns_txt_replace_args.service->sval[0] || !mdns_txt_replace_args.proto->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + const char *instance = NULL; + if (mdns_txt_replace_args.instance->count && mdns_txt_replace_args.instance->sval[0]) { + instance = mdns_txt_replace_args.instance->sval[0]; + printf("MDNS: Service Instance: %s\n", instance); + } + const char *host = NULL; + if (mdns_txt_replace_args.host->count && mdns_txt_replace_args.host->sval[0]) { + host = mdns_txt_replace_args.host->sval[0]; + printf("MDNS: Service for delegated host: %s\n", host); + } + if (mdns_txt_replace_args.txt->count) { + items = _convert_items(mdns_txt_replace_args.txt->sval, mdns_txt_replace_args.txt->count); + if (!items) { + printf("ERROR: No Memory!\n"); + return 1; + + } + } + ESP_ERROR_CHECK(mdns_service_txt_set_for_host(instance, mdns_txt_replace_args.service->sval[0], mdns_txt_replace_args.proto->sval[0], host, items, mdns_txt_replace_args.txt->count)); + mdns_mem_free(items); + return 0; +} + +static void register_mdns_service_txt_replace(void) +{ + mdns_txt_replace_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_txt_replace_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_txt_replace_args.instance = arg_str0("i", "instance", "", "Instance name"); + mdns_txt_replace_args.host = arg_str0("h", "host", "", "Service for this (delegated) host"); + mdns_txt_replace_args.txt = arg_strn(NULL, NULL, "item", 0, 30, "TXT Items (name=value)"); + mdns_txt_replace_args.end = arg_end(5); + + const esp_console_cmd_t cmd_txt_set = { + .command = "mdns_service_txt_replace", + .help = "Replace MDNS service TXT items", + .hint = NULL, + .func = &cmd_mdns_service_txt_replace, + .argtable = &mdns_txt_replace_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_txt_set)); +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_str *instance; + struct arg_str *host; + struct arg_str *var; + struct arg_str *value; + struct arg_end *end; +} mdns_txt_set_args; + +static int cmd_mdns_service_txt_set(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_txt_set_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_txt_set_args.end, argv[0]); + return 1; + } + + if (!mdns_txt_set_args.service->sval[0] || !mdns_txt_set_args.proto->sval[0] || !mdns_txt_set_args.var->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + const char *instance = NULL; + if (mdns_txt_set_args.instance->count && mdns_txt_set_args.instance->sval[0]) { + instance = mdns_txt_set_args.instance->sval[0]; + printf("MDNS: Service Instance: %s\n", instance); + } + const char *host = NULL; + if (mdns_txt_set_args.host->count && mdns_txt_set_args.host->sval[0]) { + host = mdns_txt_set_args.host->sval[0]; + printf("MDNS: Service for delegated host: %s\n", host); + } + + ESP_ERROR_CHECK(mdns_service_txt_item_set_for_host(instance, mdns_txt_set_args.service->sval[0], mdns_txt_set_args.proto->sval[0], host, mdns_txt_set_args.var->sval[0], mdns_txt_set_args.value->sval[0])); + return 0; +} + +static void register_mdns_service_txt_set(void) +{ + mdns_txt_set_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_txt_set_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_txt_set_args.var = arg_str1(NULL, NULL, "", "Item Name"); + mdns_txt_set_args.value = arg_str1(NULL, NULL, "", "Item Value"); + mdns_txt_set_args.instance = arg_str0("i", "instance", "", "Instance name"); + mdns_txt_set_args.host = arg_str0("h", "host", "", "Service for this (delegated) host"); + mdns_txt_set_args.end = arg_end(6); + + const esp_console_cmd_t cmd_txt_set = { + .command = "mdns_service_txt_set", + .help = "Add/Set MDNS service TXT item", + .hint = NULL, + .func = &cmd_mdns_service_txt_set, + .argtable = &mdns_txt_set_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_txt_set)); +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_str *var; + struct arg_str *instance; + struct arg_str *host; + struct arg_end *end; +} mdns_txt_remove_args; + +static int cmd_mdns_service_txt_remove(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_txt_remove_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_txt_remove_args.end, argv[0]); + return 1; + } + + if (!mdns_txt_remove_args.service->sval[0] || !mdns_txt_remove_args.proto->sval[0] || !mdns_txt_remove_args.var->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + const char *instance = NULL; + if (mdns_txt_remove_args.instance->count && mdns_txt_remove_args.instance->sval[0]) { + instance = mdns_txt_remove_args.instance->sval[0]; + } + const char *host = NULL; + if (mdns_txt_remove_args.host->count && mdns_txt_remove_args.host->sval[0]) { + host = mdns_txt_remove_args.host->sval[0]; + } + ESP_ERROR_CHECK(mdns_service_txt_item_remove_for_host(instance, mdns_txt_remove_args.service->sval[0], mdns_txt_remove_args.proto->sval[0], host, mdns_txt_remove_args.var->sval[0])); + return 0; +} + +static void register_mdns_service_txt_remove(void) +{ + mdns_txt_remove_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_txt_remove_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_txt_remove_args.var = arg_str1(NULL, NULL, "", "Item Name"); + mdns_txt_remove_args.instance = arg_str0("i", "instance", "", "Instance name"); + mdns_txt_remove_args.host = arg_str0("h", "host", "", "Service for this (delegated) host"); + mdns_txt_remove_args.end = arg_end(2); + + const esp_console_cmd_t cmd_txt_remove = { + .command = "mdns_service_txt_remove", + .help = "Remove MDNS service TXT item", + .hint = NULL, + .func = &cmd_mdns_service_txt_remove, + .argtable = &mdns_txt_remove_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_txt_remove)); +} + +static int cmd_mdns_service_remove_all(int argc, char **argv) +{ + mdns_service_remove_all(); + return 0; +} + +static void register_mdns_service_remove_all(void) +{ + const esp_console_cmd_t cmd_free = { + .command = "mdns_service_remove_all", + .help = "Remove all MDNS services", + .hint = NULL, + .func = &cmd_mdns_service_remove_all, + .argtable = NULL + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_free)); +} + +#define MDNS_MAX_LOOKUP_RESULTS CONFIG_MDNS_MAX_SERVICES + +static struct { + struct arg_str *instance; + struct arg_str *service; + struct arg_str *proto; + struct arg_lit *delegated; + struct arg_end *end; +} mdns_lookup_service_args; + +static esp_err_t lookup_service(const char *instance, const char *service, const char *proto, size_t max_results, + mdns_result_t **result, bool delegated) +{ + if (delegated) { + return mdns_lookup_delegated_service(instance, service, proto, max_results, result); + } + return mdns_lookup_selfhosted_service(instance, service, proto, max_results, result); +} + +static int cmd_mdns_lookup_service(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_lookup_service_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_lookup_service_args.end, argv[0]); + return 1; + } + + if (!mdns_lookup_service_args.instance->sval[0] || !mdns_lookup_service_args.service->sval[0] || !mdns_lookup_service_args.proto->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + mdns_result_t *results = NULL; + esp_err_t err = lookup_service(mdns_lookup_service_args.instance->count ? mdns_lookup_service_args.instance->sval[0] : NULL, + mdns_lookup_service_args.service->sval[0], mdns_lookup_service_args.proto->sval[0], + MDNS_MAX_LOOKUP_RESULTS, &results, mdns_lookup_service_args.delegated->count); + if (err) { + printf("Service lookup failed\n"); + return 1; + } + if (!results) { + printf("No results found!\n"); + return 0; + } + mdns_print_results(results); + mdns_query_results_free(results); + return 0; +} + +static void register_mdns_lookup_service(void) +{ + mdns_lookup_service_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_lookup_service_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_lookup_service_args.instance = arg_str0("i", "instance", "", "Instance name"); + mdns_lookup_service_args.delegated = arg_lit0("d", "delegated", "Lookup delegated services"); + mdns_lookup_service_args.end = arg_end(4); + + const esp_console_cmd_t cmd_lookup_service = { + .command = "mdns_service_lookup", + .help = "Lookup registered service", + .hint = NULL, + .func = &cmd_mdns_lookup_service, + .argtable = &mdns_lookup_service_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_lookup_service)); +} + +static struct { + struct arg_str *hostname; + struct arg_str *address; + struct arg_end *end; +} mdns_delegate_host_args; + +static int cmd_mdns_delegate_host(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_delegate_host_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_delegate_host_args.end, argv[0]); + return 1; + } + + if (!mdns_delegate_host_args.hostname->sval[0] || !mdns_delegate_host_args.address->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + + mdns_ip_addr_t addr = { .next = NULL}; + esp_netif_str_to_ip4(mdns_delegate_host_args.address->sval[0], &addr.addr.u_addr.ip4); + addr.addr.type = ESP_IPADDR_TYPE_V4; + + esp_err_t err = mdns_delegate_hostname_add(mdns_delegate_host_args.hostname->sval[0], &addr); + if (err) { + printf("mdns_delegate_hostname_add() failed\n"); + return 1; + } + return 0; +} + +static void register_mdns_delegate_host(void) +{ + mdns_delegate_host_args.hostname = arg_str1(NULL, NULL, "", "Delegated hostname"); + mdns_delegate_host_args.address = arg_str1(NULL, NULL, "
", "Delegated hosts address"); + mdns_delegate_host_args.end = arg_end(2); + + const esp_console_cmd_t cmd_delegate_host = { + .command = "mdns_delegate_host", + .help = "Add delegated hostname", + .hint = NULL, + .func = &cmd_mdns_delegate_host, + .argtable = &mdns_delegate_host_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_delegate_host)); +} + +static struct { + struct arg_str *hostname; + struct arg_end *end; +} mdns_undelegate_host_args; + +static int cmd_mdns_undelegate_host(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_undelegate_host_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_undelegate_host_args.end, argv[0]); + return 1; + } + + if (!mdns_undelegate_host_args.hostname->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + + if (mdns_delegate_hostname_remove(mdns_undelegate_host_args.hostname->sval[0]) != ESP_OK) { + printf("mdns_delegate_hostname_remove() failed\n"); + return 1; + } + return 0; +} + +static void register_mdns_undelegate_host(void) +{ + mdns_undelegate_host_args.hostname = arg_str1(NULL, NULL, "", "Delegated hostname"); + mdns_undelegate_host_args.end = arg_end(2); + + const esp_console_cmd_t cmd_undelegate_host = { + .command = "mdns_undelegate_host", + .help = "Remove delegated hostname", + .hint = NULL, + .func = &cmd_mdns_undelegate_host, + .argtable = &mdns_undelegate_host_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_undelegate_host)); +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_str *sub; + struct arg_str *instance; + struct arg_str *host; + struct arg_end *end; +} mdns_service_subtype_args; + +static int cmd_mdns_service_subtype(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_service_subtype_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_service_subtype_args.end, argv[0]); + return 1; + } + + if (!mdns_service_subtype_args.service->sval[0] || !mdns_service_subtype_args.proto->sval[0] || !mdns_service_subtype_args.sub->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + const char *instance = NULL; + if (mdns_service_subtype_args.instance->count && mdns_service_subtype_args.instance->sval[0]) { + instance = mdns_service_subtype_args.instance->sval[0]; + } + const char *host = NULL; + if (mdns_service_subtype_args.host->count && mdns_service_subtype_args.host->sval[0]) { + host = mdns_service_subtype_args.host->sval[0]; + } + ESP_ERROR_CHECK(mdns_service_subtype_add_for_host(instance, mdns_service_subtype_args.service->sval[0], mdns_service_subtype_args.proto->sval[0], host, mdns_service_subtype_args.sub->sval[0])); + return 0; +} + +static void register_mdns_service_subtype_set(void) +{ + mdns_service_subtype_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_service_subtype_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_service_subtype_args.sub = arg_str1(NULL, NULL, "", "Subtype"); + mdns_service_subtype_args.instance = arg_str0("i", "instance", "", "Instance name"); + mdns_service_subtype_args.host = arg_str0("h", "host", "", "Service for this (delegated) host"); + mdns_service_subtype_args.end = arg_end(5); + + const esp_console_cmd_t cmd_service_sub = { + .command = "mdns_service_subtype", + .help = "Adds subtype for service", + .hint = NULL, + .func = &cmd_mdns_service_subtype, + .argtable = &mdns_service_subtype_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_service_sub)); +} + +static struct { + struct arg_str *service; + struct arg_str *proto; + struct arg_end *end; +} mdns_browse_args; + +static void mdns_browse_notifier(mdns_result_t *result) +{ + if (result) { + mdns_print_results(result); + } +} + +static int cmd_mdns_browse(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_browse_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_browse_args.end, argv[0]); + return 1; + } + + if (!mdns_browse_args.service->sval[0] || !mdns_browse_args.proto->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + mdns_browse_t *handle = mdns_browse_new(mdns_browse_args.service->sval[0], mdns_browse_args.proto->sval[0], mdns_browse_notifier); + return handle ? 0 : 1; +} + +static void register_mdns_browse(void) +{ + mdns_browse_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_browse_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_browse_args.end = arg_end(2); + + const esp_console_cmd_t cmd_browse = { + .command = "mdns_browse", + .help = "Start browsing", + .hint = NULL, + .func = &cmd_mdns_browse, + .argtable = &mdns_browse_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_browse)); +} + +static int cmd_mdns_browse_del(int argc, char **argv) +{ + int nerrors = arg_parse(argc, argv, (void **) &mdns_browse_args); + if (nerrors != 0) { + arg_print_errors(stderr, mdns_browse_args.end, argv[0]); + return 1; + } + + if (!mdns_browse_args.service->sval[0] || !mdns_browse_args.proto->sval[0]) { + printf("ERROR: Bad arguments!\n"); + return 1; + } + esp_err_t err = mdns_browse_delete(mdns_browse_args.service->sval[0], mdns_browse_args.proto->sval[0]); + return err == ESP_OK ? 0 : 1; +} + +static void register_mdns_browse_del(void) +{ + mdns_browse_args.service = arg_str1(NULL, NULL, "", "MDNS Service"); + mdns_browse_args.proto = arg_str1(NULL, NULL, "", "IP Protocol"); + mdns_browse_args.end = arg_end(2); + + const esp_console_cmd_t cmd_browse_del = { + .command = "mdns_browse_del", + .help = "Stop browsing", + .hint = NULL, + .func = &cmd_mdns_browse_del, + .argtable = &mdns_browse_args + }; + + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_browse_del)); +} + +void mdns_console_register(void) +{ + register_mdns_init(); + register_mdns_free(); + register_mdns_set_hostname(); + register_mdns_set_instance(); + register_mdns_service_add(); + register_mdns_service_remove(); + register_mdns_service_instance_set(); + register_mdns_service_port_set(); + register_mdns_service_txt_replace(); + register_mdns_service_txt_set(); + register_mdns_service_txt_remove(); + register_mdns_service_remove_all(); + + register_mdns_lookup_service(); + register_mdns_delegate_host(); + register_mdns_undelegate_host(); + register_mdns_service_subtype_set(); + + register_mdns_browse(); + register_mdns_browse_del(); + +#ifdef CONFIG_LWIP_IPV4 + register_mdns_query_a(); +#endif +#ifdef CONFIG_LWIP_IPV6 + register_mdns_query_aaaa(); +#endif + register_mdns_query_txt(); + register_mdns_query_srv(); + register_mdns_query_ptr(); + + register_mdns_query_ip(); + register_mdns_query_svc(); +} diff --git a/managed_components/espressif__mdns/mdns_mem_caps.c b/managed_components/espressif__mdns/mdns_mem_caps.c new file mode 100644 index 0000000..78bdbc1 --- /dev/null +++ b/managed_components/espressif__mdns/mdns_mem_caps.c @@ -0,0 +1,96 @@ +/* + * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#include +#include "sdkconfig.h" +#include "mdns_private.h" +#include "mdns_mem_caps.h" +#include "esp_heap_caps.h" +#include "esp_log.h" + +#if CONFIG_MDNS_MEMORY_CUSTOM_IMPL +#define ALLOW_WEAK __attribute__((weak)) +#else +#define ALLOW_WEAK +#endif + +#if CONFIG_MDNS_TASK_CREATE_FROM_SPIRAM +#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT) +#define MDNS_TASK_MEMORY_LOG "SPIRAM" +#endif +#if CONFIG_MDNS_TASK_CREATE_FROM_INTERNAL +#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT) +#define MDNS_TASK_MEMORY_LOG "internal RAM" +#endif + +#if CONFIG_MDNS_MEMORY_ALLOC_SPIRAM +#define MDNS_MEMORY_CAPS (MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT) +#endif +#if CONFIG_MDNS_MEMORY_ALLOC_INTERNAL +#define MDNS_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT) +#endif + +// Allocate memory from internal heap as default. +#ifndef MDNS_MEMORY_CAPS +#warning "No memory allocation method defined, using internal memory" +#define MDNS_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT) +#endif +#ifndef MDNS_TASK_MEMORY_CAPS +#define MDNS_TASK_MEMORY_CAPS (MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT) +#define MDNS_TASK_MEMORY_LOG "internal RAM" +#endif + +void ALLOW_WEAK *mdns_mem_malloc(size_t size) +{ + return heap_caps_malloc(size, MDNS_MEMORY_CAPS); +} + +void ALLOW_WEAK *mdns_mem_calloc(size_t num, size_t size) +{ + return heap_caps_calloc(num, size, MDNS_MEMORY_CAPS); +} + +void ALLOW_WEAK mdns_mem_free(void *ptr) +{ + heap_caps_free(ptr); +} + +char ALLOW_WEAK *mdns_mem_strdup(const char *s) +{ + if (!s) { + return NULL; + } + size_t len = strlen(s) + 1; + char *copy = (char *)heap_caps_malloc(len, MDNS_MEMORY_CAPS); + if (copy) { + memcpy(copy, s, len); + } + return copy; +} + +char ALLOW_WEAK *mdns_mem_strndup(const char *s, size_t n) +{ + if (!s) { + return NULL; + } + size_t len = strnlen(s, n); + char *copy = (char *)heap_caps_malloc(len + 1, MDNS_MEMORY_CAPS); + if (copy) { + memcpy(copy, s, len); + copy[len] = '\0'; + } + return copy; +} + +void ALLOW_WEAK *mdns_mem_task_malloc(size_t size) +{ + ESP_LOGI("mdns_mem", "mDNS task will be created from %s", MDNS_TASK_MEMORY_LOG); + return heap_caps_malloc(size, MDNS_TASK_MEMORY_CAPS); +} + +void ALLOW_WEAK mdns_mem_task_free(void *ptr) +{ + heap_caps_free(ptr); +} diff --git a/managed_components/espressif__mdns/mdns_networking_lwip.c b/managed_components/espressif__mdns/mdns_networking_lwip.c new file mode 100644 index 0000000..a686727 --- /dev/null +++ b/managed_components/espressif__mdns/mdns_networking_lwip.c @@ -0,0 +1,398 @@ +/* + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/* + * MDNS Server Networking + * + */ +#include +#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" +#include "mdns_mem_caps.h" + +/* + * MDNS Server Networking + * + */ +enum interface_protocol { + PROTO_IPV4 = 1 << MDNS_IP_PROTOCOL_V4, + PROTO_IPV6 = 1 << MDNS_IP_PROTOCOL_V6 +}; + +typedef struct interfaces { + bool ready; + int proto; +} interfaces_t; + +static interfaces_t s_interfaces[MDNS_MAX_INTERFACES]; + +static struct udp_pcb *_pcb_main = NULL; + +static const char *TAG = "mdns_networking"; + +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, NULL); + 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 LWIP_IPV4 + 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; + } + } + } +#endif // LWIP_IPV4 +#if LWIP_IPV6 + if (ip_protocol == MDNS_IP_PROTOCOL_V6) { + ip_addr_t multicast_addr = IPADDR6_INIT(0x000002ff, 0, 0, 0xfb000000); + + if (join) { + if (mld6_joingroup_netif(netif, ip_2_ip6(&multicast_addr))) { + return ESP_ERR_INVALID_STATE; + } + } else { + if (mld6_leavegroup_netif(netif, ip_2_ip6(&multicast_addr))) { + return ESP_ERR_INVALID_STATE; + } + } + } +#endif // LWIP_IPV6 + 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 *)mdns_mem_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 LWIP_IPV4 && LWIP_IPV6 + packet->src.type = raddr->type; + memcpy(&packet->src.u_addr, &raddr->u_addr, sizeof(raddr->u_addr)); +#elif LWIP_IPV4 + packet->src.type = IPADDR_TYPE_V4; + packet->src.u_addr.ip4.addr = raddr->addr; +#elif LWIP_IPV6 + packet->src.type = IPADDR_TYPE_V6; + memcpy(&packet->src.u_addr.ip6, raddr, sizeof(ip_addr_t)); +#endif + packet->dest.type = packet->src.type; + +#if LWIP_IPV4 + 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)); + } +#endif // LWIP_IPV4 +#if LWIP_IPV6 + if (packet->src.type == IPADDR_TYPE_V6) { + 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_IPV6 + + //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; + bool found = false; + for (i = 0; i < MDNS_MAX_INTERFACES; i++) { + netif = esp_netif_get_netif_impl(_mdns_get_esp_netif(i)); + if (s_interfaces[i].proto && netif && netif == ip_current_input_netif()) { +#if LWIP_IPV4 + if (packet->src.type == IPADDR_TYPE_V4) { + if ((packet->src.u_addr.ip4.addr & ip_2_ip4(&netif->netmask)->addr) != (ip_2_ip4(&netif->ip_addr)->addr & ip_2_ip4(&netif->netmask)->addr)) { + //packet source is not in the same subnet + break; + } + } +#endif // LWIP_IPV4 + packet->tcpip_if = i; + found = true; + break; + } + } + + if (!found || _mdns_send_rx_action(packet) != ESP_OK) { + pbuf_free(this_pb); + mdns_mem_free(packet); + } + } + +} + +bool mdns_is_netif_ready(mdns_if_t netif, mdns_ip_protocol_t ip_proto) +{ + return s_interfaces[netif].ready && + s_interfaces[netif].proto & (ip_proto == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6); +} + +/** + * @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_is_netif_ready(i, p)) { + 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) +{ + s_interfaces[tcpip_if].proto &= ~(ip_protocol == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6); + if (s_interfaces[tcpip_if].proto == 0) { + s_interfaces[tcpip_if].ready = false; + _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_is_netif_ready(tcpip_if, ip_protocol)) { + 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; + } + s_interfaces[tcpip_if].proto |= (ip_protocol == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6); + s_interfaces[tcpip_if].ready = true; + + 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) == ESP_OK ? ERR_OK : ERR_IF; + 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; + nif = esp_netif_get_netif_impl(_mdns_get_esp_netif(msg->tcpip_if)); + if (!nif || !mdns_is_netif_ready(msg->tcpip_if, msg->ip_protocol) || _pcb_main == NULL) { + pbuf_free(msg->pbt); + msg->err = ERR_IF; + return ERR_IF; + } + esp_err_t err = udp_sendto_if(_pcb_main, 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); + + ip_addr_t ip_add_copy; +#if LWIP_IPV6 && LWIP_IPV4 + ip_add_copy.type = ip->type; + memcpy(&(ip_add_copy.u_addr), &(ip->u_addr), sizeof(ip_add_copy.u_addr)); +#elif LWIP_IPV4 + ip_add_copy.addr = ip->u_addr.ip4.addr; +#elif LWIP_IPV6 +#if LWIP_IPV6_SCOPES + ip_add_copy.zone = ip->u_addr.ip6.zone; +#endif // LWIP_IPV6_SCOPES + memcpy(ip_add_copy.addr, ip->u_addr.ip6.addr, sizeof(ip_add_copy.addr)); +#endif + + mdns_api_call_t msg = { + .tcpip_if = tcpip_if, + .ip_protocol = ip_protocol, + .pbt = pbt, + .ip = &ip_add_copy, + .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); + mdns_mem_free(packet); +} diff --git a/managed_components/espressif__mdns/mdns_networking_socket.c b/managed_components/espressif__mdns/mdns_networking_socket.c new file mode 100644 index 0000000..7bcafbb --- /dev/null +++ b/managed_components/espressif__mdns/mdns_networking_socket.c @@ -0,0 +1,499 @@ +/* + * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * @brief MDNS Server Networking module implemented using BSD sockets + */ + +#include +#include "esp_event.h" +#include "mdns_networking.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "esp_log.h" +#include "mdns_mem_caps.h" + +#if defined(CONFIG_IDF_TARGET_LINUX) +#include +#include +#endif + +enum interface_protocol { + PROTO_IPV4 = 1 << MDNS_IP_PROTOCOL_V4, + PROTO_IPV6 = 1 << MDNS_IP_PROTOCOL_V6 +}; + +typedef struct interfaces { + int sock; + int proto; +} interfaces_t; + +static interfaces_t s_interfaces[MDNS_MAX_INTERFACES]; + +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 __attribute__((constructor)) ctor_networking_socket(void) +{ + for (int i = 0; i < sizeof(s_interfaces) / sizeof(s_interfaces[0]); ++i) { + s_interfaces[i].sock = -1; + s_interfaces[i].proto = 0; + } +} + +static void delete_socket(int sock) +{ + close(sock); +} + +bool mdns_is_netif_ready(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + return s_interfaces[tcpip_if].proto & (ip_protocol == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6); +} + +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) +{ + mdns_mem_free(packet->pb->payload); + mdns_mem_free(packet->pb); + mdns_mem_free(packet); +} + +esp_err_t _mdns_pcb_deinit(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + s_interfaces[tcpip_if].proto &= ~(ip_protocol == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6); + if (s_interfaces[tcpip_if].proto == 0) { + // if the interface for both protocols uninitialized, close the interface socket + if (s_interfaces[tcpip_if].sock >= 0) { + delete_socket(s_interfaces[tcpip_if].sock); + } + } + + for (int i = 0; i < MDNS_MAX_INTERFACES; i++) { + if (s_interfaces[i].sock >= 0) { + // If any of the interfaces 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 +#ifdef CONFIG_LWIP_IPV4 + if (source_addr->ss_family == PF_INET) { + res = inet_ntoa_r(((struct sockaddr_in *)source_addr)->sin_addr, address_str, sizeof(address_str)); + } +#endif +#ifdef CONFIG_LWIP_IPV6 + 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)); +#ifdef CONFIG_LWIP_IPV4 + 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; + } +#endif // CONFIG_LWIP_IPV4 +#ifdef CONFIG_LWIP_IPV6 + 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) +{ + if (!(s_interfaces[tcpip_if].proto & (ip_protocol == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6))) { + return 0; + } + int sock = s_interfaces[tcpip_if].sock; + 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) +{ +#ifdef CONFIG_LWIP_IPV4 + 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; + } +#endif /* CONFIG_LWIP_IPV4 */ +#ifdef CONFIG_LWIP_IPV6 + 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++) { + int sock = s_interfaces[i].sock; + 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++) { + int sock = s_interfaces[tcpip_if].sock; + 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 *) mdns_mem_calloc(1, sizeof(mdns_rx_packet_t)); + struct pbuf *packet_pbuf = mdns_mem_calloc(1, sizeof(struct pbuf)); + uint8_t *buf = mdns_mem_malloc(len); + if (packet == NULL || packet_pbuf == NULL || buf == NULL) { + mdns_mem_free(buf); + mdns_mem_free(packet_pbuf); + mdns_mem_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_send_rx_action(packet) != ESP_OK) { + ESP_LOGE(TAG, "_mdns_send_rx_action failed!"); + mdns_mem_free(packet->pb->payload); + mdns_mem_free(packet->pb); + mdns_mem_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 bool create_pcb(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + if (s_interfaces[tcpip_if].proto & (ip_protocol == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6)) { + return true; + } + int sock = s_interfaces[tcpip_if].sock; + esp_netif_t *netif = _mdns_get_esp_netif(tcpip_if); + if (sock < 0) { + sock = create_socket(netif); + } + if (sock < 0) { + ESP_LOGE(TAG, "Failed to create the socket!"); + return false; + } + 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); + } + s_interfaces[tcpip_if].proto |= (ip_protocol == MDNS_IP_PROTOCOL_V4 ? PROTO_IPV4 : PROTO_IPV6); + s_interfaces[tcpip_if].sock = sock; + return true; +} + +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=%lu, ip_protocol=%lu)", (unsigned long)tcpip_if, (unsigned long)ip_protocol); + if (!create_pcb(tcpip_if, ip_protocol)) { + return ESP_FAIL; + } + + mdns_networking_init(); + return ESP_OK; +} + +static int create_socket(esp_netif_t *netif) +{ +#ifdef 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 +#ifdef 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; +} + +#ifdef 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 + +#ifdef CONFIG_LWIP_IPV4 +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; +} +#endif // CONFIG_LWIP_IPV4 + +static int join_mdns_multicast_group(int sock, esp_netif_t *netif, mdns_ip_protocol_t ip_protocol) +{ +#ifdef CONFIG_LWIP_IPV4 + if (ip_protocol == MDNS_IP_PROTOCOL_V4) { + return socket_add_ipv4_multicast_group(sock, netif); + } +#endif // CONFIG_LWIP_IPV4 +#ifdef CONFIG_LWIP_IPV6 + if (ip_protocol == MDNS_IP_PROTOCOL_V6) { + return socket_add_ipv6_multicast_group(sock, netif); + } +#endif // CONFIG_LWIP_IPV6 + return -1; +} diff --git a/managed_components/espressif__mdns/mem_prefix_script.py b/managed_components/espressif__mdns/mem_prefix_script.py new file mode 100644 index 0000000..b9af09d --- /dev/null +++ b/managed_components/espressif__mdns/mem_prefix_script.py @@ -0,0 +1,54 @@ +# SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD +# SPDX-License-Identifier: Apache-2.0 +import re +import sys + +# Configurable prefix for memory functions +MDNS_MEM_PREFIX = 'mdns_mem_' # Change this to modify the prefix + + +def add_prefix_to_mem_funcs(content): + # List of memory functions to prefix + mem_funcs = [ + 'malloc', + 'calloc', + 'free', + 'strdup', + 'strndup' + ] + + # Create regex pattern matching the memory functions but not already prefixed ones + pattern = fr'(?') + sys.exit(1) + + process_file(sys.argv[1]) diff --git a/managed_components/espressif__mdns/private_include/mdns_mem_caps.h b/managed_components/espressif__mdns/private_include/mdns_mem_caps.h new file mode 100644 index 0000000..2d63390 --- /dev/null +++ b/managed_components/espressif__mdns/private_include/mdns_mem_caps.h @@ -0,0 +1,65 @@ +/* + * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Allocate memory. + * @param size Number of bytes to allocate. + * @return Pointer to allocated memory, or NULL on failure. + */ +void *mdns_mem_malloc(size_t size); + +/** + * @brief Allocate and zero memory. + * @param num Number of elements. + * @param size Size of each element. + * @return Pointer to allocated memory, or NULL on failure. + */ +void *mdns_mem_calloc(size_t num, size_t size); + +/** + * @brief Free allocated memory. + * @param ptr Pointer to memory to free. + */ +void mdns_mem_free(void *ptr); + +/** + * @brief Duplicate a string. + * @param s String to duplicate. + * @return Pointer to duplicated string, or NULL on failure. + */ +char *mdns_mem_strdup(const char *s); + +/** + * @brief Duplicate a string with length limit. + * @param s String to duplicate. + * @param n Maximum number of characters to copy. + * @return Pointer to duplicated string, or NULL on failure. + */ +char *mdns_mem_strndup(const char *s, size_t n); + +/** + * @brief Allocate memory for mDNS task. + * @param size Number of bytes to allocate. + * @return Pointer to allocated memory, or NULL on failure. + */ +void *mdns_mem_task_malloc(size_t size); + +/** + * @brief Free allocated memory for mDNS task. + * @param ptr Pointer to memory to free. + */ +void mdns_mem_task_free(void *ptr); + +#ifdef __cplusplus +} +#endif diff --git a/managed_components/espressif__mdns/private_include/mdns_networking.h b/managed_components/espressif__mdns/private_include/mdns_networking.h new file mode 100644 index 0000000..83cbe90 --- /dev/null +++ b/managed_components/espressif__mdns/private_include/mdns_networking.h @@ -0,0 +1,60 @@ +/* + * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#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); + +bool mdns_is_netif_ready(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol); + +/** + * @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_ */ diff --git a/managed_components/espressif__mdns/private_include/mdns_private.h b/managed_components/espressif__mdns/private_include/mdns_private.h new file mode 100644 index 0000000..6bc0891 --- /dev/null +++ b/managed_components/espressif__mdns/private_include/mdns_private.h @@ -0,0 +1,468 @@ +/* + * SPDX-FileCopyrightText: 2015-2025 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" +#include "esp_system.h" + +#ifdef CONFIG_MDNS_ENABLE_DEBUG_PRINTS +#define MDNS_ENABLE_DEBUG +#define _mdns_dbg_printf(...) printf(__VA_ARGS__) +#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) + +#ifdef CONFIG_LWIP_IPV6_NUM_ADDRESSES +#define NETIF_IPV6_MAX_NUMS CONFIG_LWIP_IPV6_NUM_ADDRESSES +#else +#define NETIF_IPV6_MAX_NUMS 3 +#endif + +#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 1, 0) +/* CONFIG_LWIP_IPV4 was introduced in IDF v5.1 */ +/* For IDF v5.0, set CONFIG_LWIP_IPV4 to 1 by default */ +#ifndef CONFIG_LWIP_IPV4 +#define CONFIG_LWIP_IPV4 1 +#endif // CONFIG_LWIP_IPV4 +#endif // ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 1, 0) + +/** 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_QUERY_REPSONSE 0x8000 +#define MDNS_FLAGS_AUTHORITATIVE 0x0400 +#define MDNS_FLAGS_QR_AUTHORITATIVE (MDNS_FLAGS_QUERY_REPSONSE | MDNS_FLAGS_AUTHORITATIVE) +#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 CONFIG_MDNS_ACTION_QUEUE_LEN // Maximum actions pending to the server +#define MDNS_TXT_MAX_LEN 1024 // Maximum string length of text data in TXT record +#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; mdns_mem_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: %" PRIu32 " 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_SEARCH_ADD, + ACTION_SEARCH_SEND, + ACTION_SEARCH_END, + ACTION_BROWSE_ADD, + ACTION_BROWSE_SYNC, + ACTION_BROWSE_END, + ACTION_TX_HANDLE, + ACTION_RX_HANDLE, + ACTION_TASK_STOP, + ACTION_DELEGATE_HOSTNAME_ADD, + ACTION_DELEGATE_HOSTNAME_REMOVE, + ACTION_DELEGATE_HOSTNAME_SET_ADDR, + ACTION_MAX +} mdns_action_type_t; + + +typedef struct { + uint16_t id; + uint16_t 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; + 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 enum { + BROWSE_OFF, + BROWSE_INIT, + BROWSE_RUNNING, + BROWSE_MAX +} mdns_browse_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_browse_s { + struct mdns_browse_s *next; + + mdns_browse_state_t state; + mdns_browse_notify_t notifier; + + char *service; + char *proto; + mdns_result_t *result; +} mdns_browse_t; + +typedef struct mdns_browse_result_sync_t { + mdns_result_t *result; + struct mdns_browse_result_sync_t *next; +} mdns_browse_result_sync_t; + +typedef struct mdns_browse_sync { + mdns_browse_t *browse; + mdns_browse_result_sync_t *sync_result; +} mdns_browse_sync_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; + QueueHandle_t action_queue; + SemaphoreHandle_t action_sema; + mdns_tx_packet_t *tx_queue_head; + mdns_search_once_t *search_once; + esp_timer_handle_t timer_handle; + mdns_browse_t *browse; +} mdns_server_t; + +typedef struct { + mdns_action_type_t type; + union { + struct { + char *hostname; + } hostname_set; + char *instance; + struct { + mdns_if_t interface; + mdns_event_actions_t event_action; + } sys_event; + 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; + struct { + mdns_browse_t *browse; + } browse_add; + struct { + mdns_browse_sync_t *browse_sync; + } browse_sync; + } 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_ */ diff --git a/managed_components/espressif__mdns/tests/host_test/CMakeLists.txt b/managed_components/espressif__mdns/tests/host_test/CMakeLists.txt new file mode 100644 index 0000000..5f0d7bd --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/CMakeLists.txt @@ -0,0 +1,16 @@ +cmake_minimum_required(VERSION 3.5) + + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) +if(${IDF_TARGET} STREQUAL "linux") + set(EXTRA_COMPONENT_DIRS "../../../../common_components/linux_compat") + set(COMPONENTS main) +endif() + +project(mdns_host) + +# Enable sanitizers only without console (we'd see some leaks on argtable when console exits) +if(NOT CONFIG_TEST_CONSOLE AND CONFIG_IDF_TARGET_LINUX) +idf_component_get_property(mdns mdns COMPONENT_LIB) +target_link_options(${mdns} INTERFACE -fsanitize=address -fsanitize=undefined) +endif() diff --git a/managed_components/espressif__mdns/tests/host_test/README.md b/managed_components/espressif__mdns/tests/host_test/README.md new file mode 100644 index 0000000..4953f0e --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/README.md @@ -0,0 +1,33 @@ +# Setup dummy network interfaces + +Note: Set two addresses so we could use one as source and another as destination +``` +sudo ip link add eth2 type dummy +sudo ip addr add 192.168.1.200/24 dev eth2 +sudo ip addr add 192.168.1.201/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 +``` + +or a reverse query: +``` +dig +short -b 192.168.2.200 -p 5353 @224.0.0.251 -x 192.168.1.200 +``` + +# 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" +``` diff --git a/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/CMakeLists.txt b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/CMakeLists.txt new file mode 100644 index 0000000..6f8d51e --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/CMakeLists.txt @@ -0,0 +1,8 @@ +idf_build_get_property(idf_target IDF_TARGET) +if(${IDF_TARGET} STREQUAL "linux") + idf_component_register(SRCS esp_netif_linux.c + INCLUDE_DIRS include $ENV{IDF_PATH}/components/esp_netif/include + REQUIRES esp_event) +else() + idf_component_register() +endif() diff --git a/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/Kconfig b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/Kconfig new file mode 100644 index 0000000..3b3c309 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/Kconfig @@ -0,0 +1,15 @@ +menu "LWIP-MOCK-CONFIG" + + config LWIP_IPV6 + bool "Enable IPv6" + default y + help + Enable/disable IPv6 + + config LWIP_IPV4 + bool "Enable IPv4" + default y + help + Enable/disable IPv4 + +endmenu diff --git a/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/esp_netif_linux.c b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/esp_netif_linux.c new file mode 100644 index 0000000..13cf412 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/esp_netif_linux.c @@ -0,0 +1,197 @@ +/* + * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#include +#include + +#include "esp_netif.h" +#include "esp_err.h" +#include //strlen +#include +#include //inet_addr +#include +#include +#include +#include "esp_netif_types.h" +#include "esp_log.h" + +#define MAX_NETIFS 4 + +static const char *TAG = "esp_netif_linux"; + +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) { + ESP_LOGD(TAG, "AF_INET4: %s: %s\n", tmp->ifa_name, addr); + memcpy(&ip_info->ip.addr, &pAddr->sin_addr, 4); + } + } + tmp = tmp->ifa_next; + } + freeifaddrs(addrs); + 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; +} + +int esp_netif_get_all_ip6(esp_netif_t *esp_netif, esp_ip6_addr_t if_ip6[]) +{ + if (esp_netif == NULL) { + return 0; + } + struct ifaddrs *addrs, *tmp; + int addr_count = 0; + getifaddrs(&addrs); + tmp = addrs; + + while (tmp) { + if (tmp->ifa_addr && tmp->ifa_addr->sa_family == AF_INET6) { + struct sockaddr_in6 *pAddr = (struct sockaddr_in6 *)tmp->ifa_addr; + if (strcmp(esp_netif->if_desc, tmp->ifa_name) == 0) { + memcpy(&if_ip6[addr_count++], &pAddr->sin6_addr, 4 * 4); + } + } + tmp = tmp->ifa_next; + } + + freeifaddrs(addrs); + return addr_count; +} + +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) { + ESP_LOGD(TAG, "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); +} + +const char *esp_netif_get_ifkey(esp_netif_t *esp_netif) +{ + return esp_netif->if_key; +} + +esp_err_t esp_netif_str_to_ip4(const char *src, esp_ip4_addr_t *dst) +{ + if (src == NULL || dst == NULL) { + return ESP_ERR_INVALID_ARG; + } + struct in_addr addr; + if (inet_pton(AF_INET, src, &addr) != 1) { + return ESP_FAIL; + } + dst->addr = addr.s_addr; + return ESP_OK; +} diff --git a/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/include/esp_wifi_types.h b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/include/esp_wifi_types.h new file mode 100644 index 0000000..e878e27 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/include/esp_wifi_types.h @@ -0,0 +1,7 @@ +/* + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#pragma once +#include "esp_event.h" diff --git a/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/include/machine/endian.h b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/include/machine/endian.h new file mode 100644 index 0000000..488bce0 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/components/esp_netif_linux/include/machine/endian.h @@ -0,0 +1,8 @@ +/* + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#pragma once + +#include_next "endian.h" diff --git a/managed_components/espressif__mdns/tests/host_test/dnsfixture.py b/managed_components/espressif__mdns/tests/host_test/dnsfixture.py new file mode 100644 index 0000000..c16b061 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/dnsfixture.py @@ -0,0 +1,178 @@ +# SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD +# SPDX-License-Identifier: Unlicense OR CC0-1.0 +import logging +import re +import socket +import sys + +import dns.message +import dns.query +import dns.rdataclass +import dns.rdatatype +import dns.resolver + +# Configure logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +class DnsPythonWrapper: + def __init__(self, server='224.0.0.251', port=5353, retries=3): + self.server = server + self.port = port + self.retries = retries + + def send_and_receive_query(self, query, timeout=3): + logger.info(f'Sending DNS query to {self.server}:{self.port}') + try: + # Create a UDP socket + with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock: + sock.settimeout(timeout) + + # Send the DNS query + query_data = query.to_wire() + sock.sendto(query_data, (self.server, self.port)) + + # Receive the DNS response + response_data, _ = sock.recvfrom(512) # 512 bytes is the typical size for a DNS response + + # Parse the response + response = dns.message.from_wire(response_data) + + return response + + except socket.timeout as e: + logger.warning(f'DNS query timed out: {e}') + return None + except dns.exception.DNSException as e: + logger.error(f'DNS query failed: {e}') + return None + + def run_query(self, name, query_type='PTR', timeout=3): + logger.info(f'Running DNS query for {name} with type {query_type}') + query = dns.message.make_query(name, dns.rdatatype.from_text(query_type), dns.rdataclass.IN) + + # Print the DNS question section + logger.info(f'DNS question section: {query.question}') + + # Send and receive the DNS query + response = None + for attempt in range(1, self.retries + 1): + logger.info(f'Attempt {attempt}/{self.retries}') + response = self.send_and_receive_query(query, timeout) + if response: + break + + if response: + logger.info(f'DNS query response:\n{response}') + else: + logger.warning('No response received or response was invalid.') + + return response + + def parse_answer_section(self, response, query_type): + answers = [] + if response: + for answer in response.answer: + if dns.rdatatype.to_text(answer.rdtype) == query_type: + for item in answer.items: + full_answer = ( + f'{answer.name} {answer.ttl} ' + f'{dns.rdataclass.to_text(answer.rdclass)} ' + f'{dns.rdatatype.to_text(answer.rdtype)} ' + f'{item.to_text()}' + ) + answers.append(full_answer) + return answers + + def check_record(self, name, query_type, expected=True, expect=None): + output = self.run_query(name, query_type=query_type) + answers = self.parse_answer_section(output, query_type) + logger.info(f'answers: {answers}') + if expect is None: + expect = name + if expected: + assert any(expect in answer for answer in answers), f"Expected record '{expect}' not in answer section" + else: + assert not any(expect in answer for answer in answers), f"Unexpected record '{expect}' found in answer section" + + def parse_section(self, response, section: str, rdtype_text: str): + """Parse a specific response section (answer, authority, additional) for given rdtype. + + Returns list of textual records for that rdtype. + """ + out = [] + if not response: + return out + rrsets = [] + if section == 'answer': + rrsets = response.answer + elif section == 'authority': + rrsets = response.authority + elif section == 'additional': + rrsets = response.additional + else: + raise ValueError('invalid section') + for rr in rrsets: + if dns.rdatatype.to_text(rr.rdtype) != rdtype_text: + continue + for item in rr.items: + full = ( + f'{rr.name} {rr.ttl} ' + f'{dns.rdataclass.to_text(rr.rdclass)} ' + f'{dns.rdatatype.to_text(rr.rdtype)} ' + f'{item.to_text()}' + ) + out.append(full) + return out + + def check_additional(self, response, rdtype_text: str, owner_contains: str, expected: bool = True, expect_substr: str | None = None): + """Check Additional section for an RR of type rdtype_text whose owner includes owner_contains. + + If expect_substr is provided, also require it to appear in the textual RR. + """ + records = self.parse_section(response, 'additional', rdtype_text) + logger.info(f'additional({rdtype_text}): {records}') + + def _matches(line: str) -> bool: + in_owner = owner_contains in line + has_val = (expect_substr in line) if expect_substr else True + return in_owner and has_val + found = any(_matches(r) for r in records) + if expected: + assert found, f"Expected {rdtype_text} for {owner_contains} in Additional not found" + else: + assert not found, f"Unexpected {rdtype_text} for {owner_contains} found in Additional" + + +if __name__ == '__main__': + if len(sys.argv) < 3: + print('Usage: python dns_fixture.py ') + sys.exit(1) + + query_type = sys.argv[1] + name = sys.argv[2] + ip_only = len(sys.argv) > 3 and sys.argv[3] == '--ip_only' + if ip_only: + logger.setLevel(logging.WARNING) + + dns_wrapper = DnsPythonWrapper() + if query_type == 'X' and '.' in name: + # Sends an IPv4 reverse query + reversed_ip = '.'.join(reversed(name.split('.'))) + name = f'{reversed_ip}.in-addr.arpa' + query_type = 'PTR' + response = dns_wrapper.run_query(name, query_type=query_type) + answers = dns_wrapper.parse_answer_section(response, query_type) + + if answers: + for answer in answers: + logger.info(f'DNS query response: {answer}') + if ip_only: + ipv4_pattern = re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b') + ipv4_addresses = ipv4_pattern.findall(answer) + if ipv4_addresses: + print(f"{', '.join(ipv4_addresses)}") + else: + logger.info(f'No response for {name} with query type {query_type}') + exit(9) # Same as dig timeout diff --git a/managed_components/espressif__mdns/tests/host_test/main/CMakeLists.txt b/managed_components/espressif__mdns/tests/host_test/main/CMakeLists.txt new file mode 100644 index 0000000..0e6f226 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/main/CMakeLists.txt @@ -0,0 +1,4 @@ +idf_component_register(SRCS "main.c" + INCLUDE_DIRS + "." + REQUIRES mdns console nvs_flash) diff --git a/managed_components/espressif__mdns/tests/host_test/main/Kconfig.projbuild b/managed_components/espressif__mdns/tests/host_test/main/Kconfig.projbuild new file mode 100644 index 0000000..9bf4bba --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/main/Kconfig.projbuild @@ -0,0 +1,21 @@ +menu "Test Configuration" + + config TEST_HOSTNAME + string "mDNS Hostname" + default "esp32-mdns" + help + mDNS Hostname for example to use + + config TEST_NETIF_NAME + string "Network interface name" + default "eth2" + help + Name/ID if the network interface on which we run the mDNS host test + + config TEST_CONSOLE + bool "Start console" + default n + help + Test uses esp_console for interactive testing. + +endmenu diff --git a/managed_components/espressif__mdns/tests/host_test/main/idf_component.yml b/managed_components/espressif__mdns/tests/host_test/main/idf_component.yml new file mode 100644 index 0000000..e2d4fe9 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/main/idf_component.yml @@ -0,0 +1,7 @@ +dependencies: + idf: ">=5.0" + espressif/mdns: + version: "^1.0.0" + override_path: "../../.." + protocol_examples_common: + path: ${IDF_PATH}/examples/common_components/protocol_examples_common diff --git a/managed_components/espressif__mdns/tests/host_test/main/main.c b/managed_components/espressif__mdns/tests/host_test/main/main.c new file mode 100644 index 0000000..a02b8e1 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/main/main.c @@ -0,0 +1,126 @@ +/* + * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ +#include +#include "esp_log.h" +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "esp_console.h" +#include "mdns.h" +#include "mdns_console.h" + +static const char *TAG = "mdns-test"; + +static void mdns_test_app(esp_netif_t *interface); + +#ifdef CONFIG_TEST_CONSOLE +static EventGroupHandle_t s_exit_signal = NULL; + +static int exit_console(int argc, char **argv) +{ + xEventGroupSetBits(s_exit_signal, 1); + return 0; +} + +#else +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)); +} +#endif // TEST_CONSOLE + +#ifndef CONFIG_IDF_TARGET_LINUX +#include "protocol_examples_common.h" +#include "esp_event.h" +#include "nvs_flash.h" + +/** + * @brief This is an entry point for the real target device, + * need to init few components and connect to a network interface + */ +void app_main(void) +{ + ESP_ERROR_CHECK(nvs_flash_init()); + ESP_ERROR_CHECK(esp_netif_init()); + ESP_ERROR_CHECK(esp_event_loop_create_default()); + ESP_ERROR_CHECK(example_connect()); + + mdns_test_app(EXAMPLE_INTERFACE); + + ESP_ERROR_CHECK(example_disconnect()); +} +#else + +/** + * @brief This is an entry point for the linux target (simulator on host) + * need to create a dummy WiFi station and use it as mdns network interface + */ +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 = CONFIG_TEST_NETIF_NAME }; + esp_netif_config_t cfg = { .base = &base_cg }; + esp_netif_t *sta = esp_netif_new(&cfg); + + mdns_test_app(sta); + + esp_netif_destroy(sta); + return 0; +} +#endif + +static void mdns_test_app(esp_netif_t *interface) +{ + ESP_ERROR_CHECK(mdns_init()); + ESP_ERROR_CHECK(mdns_hostname_set(CONFIG_TEST_HOSTNAME)); + ESP_LOGI(TAG, "mdns hostname set to: [%s]", CONFIG_TEST_HOSTNAME); + ESP_ERROR_CHECK(mdns_register_netif(interface)); + ESP_ERROR_CHECK(mdns_netif_action(interface, MDNS_EVENT_ENABLE_IP4 /*| MDNS_EVENT_ENABLE_IP6 */ | MDNS_EVENT_IP4_REVERSE_LOOKUP | MDNS_EVENT_IP6_REVERSE_LOOKUP)); + +#ifdef CONFIG_TEST_CONSOLE + esp_console_repl_t *repl = NULL; + esp_console_repl_config_t repl_config = ESP_CONSOLE_REPL_CONFIG_DEFAULT(); + esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT(); + s_exit_signal = xEventGroupCreate(); + + repl_config.prompt = "mdns>"; + // init console REPL environment + ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &repl)); + + const esp_console_cmd_t cmd_exit = { + .command = "exit", + .help = "exit mDNS console application", + .hint = NULL, + .func = exit_console, + .argtable = NULL + }; + ESP_ERROR_CHECK(esp_console_cmd_register(&cmd_exit)); + mdns_console_register(); + ESP_ERROR_CHECK(esp_console_start_repl(repl)); + xEventGroupWaitBits(s_exit_signal, 1, pdTRUE, pdFALSE, portMAX_DELAY); + repl->del(repl); +#else + vTaskDelay(pdMS_TO_TICKS(10000)); + query_mdns_host("david-work"); + vTaskDelay(pdMS_TO_TICKS(1000)); +#endif + mdns_free(); + ESP_LOGI(TAG, "Exit"); +} diff --git a/managed_components/espressif__mdns/tests/host_test/pytest_mdns.py b/managed_components/espressif__mdns/tests/host_test/pytest_mdns.py new file mode 100644 index 0000000..95fefc2 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/pytest_mdns.py @@ -0,0 +1,191 @@ +# SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD +# SPDX-License-Identifier: Unlicense OR CC0-1.0 +import logging + +import pexpect +import pytest +from dnsfixture import DnsPythonWrapper + +# Configure logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) +ipv6_enabled = False + + +class MdnsConsole: + def __init__(self, command): + self.process = pexpect.spawn(command, encoding='utf-8') + self.process.logfile = open('mdns_interaction.log', 'w') # Log all interactions + self.process.expect('mdns> ', timeout=10) + + def send_input(self, input_data): + logger.info(f'Sending to stdin: {input_data}') + self.process.sendline(input_data) + + def get_output(self, expected_data): + logger.info(f'Expecting: {expected_data}') + self.process.expect(expected_data, timeout=10) + output = self.process.before.strip() + logger.info(f'Received from stdout: {output}') + return output + + def terminate(self): + self.send_input('exit') + self.get_output('Exit') + self.process.wait() + self.process.close() + assert self.process.exitstatus == 0 + + +@pytest.fixture(scope='module') +def mdns_console(): + app = MdnsConsole('./build_linux_console/mdns_host.elf') + yield app + app.terminate() + + +@pytest.fixture(scope='module') +def dig_app(): + return DnsPythonWrapper() + + +def test_mdns_init(mdns_console, dig_app): + mdns_console.send_input('mdns_init -h hostname') + mdns_console.get_output('MDNS: Hostname: hostname') + dig_app.check_record('hostname.local', query_type='A', expected=True) + if ipv6_enabled: + dig_app.check_record('hostname.local', query_type='AAAA', expected=True) + + +def test_add_service(mdns_console, dig_app): + mdns_console.send_input('mdns_service_add _http _tcp 80 -i test_service') + mdns_console.get_output('MDNS: Service Instance: test_service') + mdns_console.send_input('mdns_service_lookup _http _tcp') + mdns_console.get_output('PTR : test_service') + dig_app.check_record('_http._tcp.local', query_type='PTR', expected=True) + + +def test_ptr_additional_records_for_service(dig_app): + # Query PTR for the service type and ensure SRV/TXT are in Additional (RFC 6763 §12.1) + resp = dig_app.run_query('_http._tcp.local', query_type='PTR') + # Answer section should have at least one PTR to the instance + answers = dig_app.parse_answer_section(resp, 'PTR') + assert any('test_service._http._tcp.local' in a for a in answers) + # Additional section should include SRV and TXT for the same instance + dig_app.check_additional(resp, 'SRV', 'test_service._http._tcp.local', expected=True) + dig_app.check_additional(resp, 'TXT', 'test_service._http._tcp.local', expected=True) + + +def test_remove_service(mdns_console, dig_app): + mdns_console.send_input('mdns_service_remove _http _tcp') + mdns_console.send_input('mdns_service_lookup _http _tcp') + mdns_console.get_output('No results found!') + dig_app.check_record('_http._tcp.local', query_type='PTR', expected=False) + + +def test_delegate_host(mdns_console, dig_app): + mdns_console.send_input('mdns_delegate_host delegated 1.2.3.4') + dig_app.check_record('delegated.local', query_type='A', expected=True) + + +def test_undelegate_host(mdns_console, dig_app): + mdns_console.send_input('mdns_undelegate_host delegated') + dig_app.check_record('delegated.local', query_type='A', expected=False) + + +def test_add_delegated_service(mdns_console, dig_app): + mdns_console.send_input('mdns_delegate_host delegated 1.2.3.4') + dig_app.check_record('delegated.local', query_type='A', expected=True) + mdns_console.send_input('mdns_service_add _test _tcp 80 -i local') + mdns_console.get_output('MDNS: Service Instance: local') + mdns_console.send_input('mdns_service_add _test2 _tcp 80 -i extern -h delegated') + mdns_console.get_output('MDNS: Service Instance: extern') + mdns_console.send_input('mdns_service_lookup _test _tcp') + mdns_console.get_output('PTR : local') + mdns_console.send_input('mdns_service_lookup _test2 _tcp -d') + mdns_console.get_output('PTR : extern') + dig_app.check_record('_test2._tcp.local', query_type='PTR', expected=True) + dig_app.check_record('extern._test2._tcp.local', query_type='SRV', expected=True) + + +def test_remove_delegated_service(mdns_console, dig_app): + mdns_console.send_input('mdns_service_remove _test2 _tcp -h delegated') + mdns_console.send_input('mdns_service_lookup _test2 _tcp -d') + mdns_console.get_output('No results found!') + dig_app.check_record('_test2._tcp.local', query_type='PTR', expected=False) + # add the delegated service again, would be used in the TXT test + mdns_console.send_input('mdns_service_add _test2 _tcp 80 -i extern -h delegated') + mdns_console.get_output('MDNS: Service Instance: extern') + + +def check_txt_for_service(instance, service, proto, mdns_console, dig_app, host=None, with_inst=False): + for_host_arg = f'-h {host}' if host is not None else '' + for_inst_arg = f'-i {instance}' if with_inst else '' + mdns_console.send_input(f'mdns_service_txt_set {service} {proto} {for_host_arg} {for_inst_arg} key1 value1') + dig_app.check_record(f'{instance}.{service}.{proto}.local', query_type='SRV', expected=True) + dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key1=value1') + mdns_console.send_input(f'mdns_service_txt_set {service} {proto} {for_host_arg} {for_inst_arg} key2 value2') + dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key2=value2') + mdns_console.send_input(f'mdns_service_txt_remove {service} {proto} {for_host_arg} {for_inst_arg} key2') + dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=False, expect='key2=value2') + dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key1=value1') + mdns_console.send_input(f'mdns_service_txt_replace {service} {proto} {for_host_arg} {for_inst_arg} key3=value3 key4=value4') + dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=False, expect='key1=value1') + dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key3=value3') + dig_app.check_record(f'{service}.{proto}.local', query_type='TXT', expected=True, expect='key4=value4') + + +def test_update_txt(mdns_console, dig_app): + check_txt_for_service('local', '_test', '_tcp', mdns_console=mdns_console, dig_app=dig_app) + check_txt_for_service('local', '_test', '_tcp', mdns_console=mdns_console, dig_app=dig_app, with_inst=True) + + +def test_update_delegated_txt(mdns_console, dig_app): + check_txt_for_service('extern', '_test2', '_tcp', mdns_console=mdns_console, dig_app=dig_app, host='delegated') + check_txt_for_service('extern', '_test2', '_tcp', mdns_console=mdns_console, dig_app=dig_app, host='delegated', with_inst=True) + + +def test_service_port_set(mdns_console, dig_app): + dig_app.check_record('local._test._tcp.local', query_type='SRV', expected=True, expect='80') + mdns_console.send_input('mdns_service_port_set _test _tcp 81') + dig_app.check_record('local._test._tcp.local', query_type='SRV', expected=True, expect='81') + mdns_console.send_input('mdns_service_port_set _test2 _tcp -h delegated 82') + dig_app.check_record('extern._test2._tcp.local', query_type='SRV', expected=True, expect='82') + mdns_console.send_input('mdns_service_port_set _test2 _tcp -h delegated -i extern 83') + dig_app.check_record('extern._test2._tcp.local', query_type='SRV', expected=True, expect='83') + mdns_console.send_input('mdns_service_port_set _test2 _tcp -h delegated -i invalid_inst 84') + mdns_console.get_output('ESP_ERR_NOT_FOUND') + dig_app.check_record('extern._test2._tcp.local', query_type='SRV', expected=True, expect='83') + + +def test_service_subtype(mdns_console, dig_app): + dig_app.check_record('local._test._tcp.local', query_type='SRV', expected=True) + mdns_console.send_input('mdns_service_subtype _test _tcp _subtest -i local') + dig_app.check_record('_subtest._sub._test._tcp.local', query_type='PTR', expected=True) + mdns_console.send_input('mdns_service_subtype _test2 _tcp _subtest2 -i extern -h delegated') + dig_app.check_record('_subtest2._sub._test2._tcp.local', query_type='PTR', expected=True) + + +def test_service_set_instance(mdns_console, dig_app): + dig_app.check_record('local._test._tcp.local', query_type='SRV', expected=True) + mdns_console.send_input('mdns_service_instance_set _test _tcp local2') + dig_app.check_record('local2._test._tcp.local', query_type='SRV', expected=True) + mdns_console.send_input('mdns_service_instance_set _test2 _tcp extern2 -h delegated') + mdns_console.send_input('mdns_service_lookup _test2 _tcp -d') + mdns_console.get_output('PTR : extern2') + dig_app.check_record('extern2._test2._tcp.local', query_type='SRV', expected=True) + mdns_console.send_input('mdns_service_instance_set _test2 _tcp extern3 -h delegated -i extern') + mdns_console.get_output('ESP_ERR_NOT_FOUND') + + +def test_service_remove_all(mdns_console, dig_app): + mdns_console.send_input('mdns_service_remove_all') + mdns_console.send_input('mdns_service_lookup _test2 _tcp -d') + mdns_console.get_output('No results found!') + mdns_console.send_input('mdns_service_lookup _test _tcp') + mdns_console.get_output('No results found!') + dig_app.check_record('_test._tcp.local', query_type='PTR', expected=False) + + +if __name__ == '__main__': + pytest.main(['-s', 'test_mdns.py']) diff --git a/managed_components/espressif__mdns/tests/host_test/sdkconfig.ci.console b/managed_components/espressif__mdns/tests/host_test/sdkconfig.ci.console new file mode 100644 index 0000000..3b6dcb6 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/sdkconfig.ci.console @@ -0,0 +1,4 @@ +CONFIG_IDF_TARGET="linux" +CONFIG_ESP_EVENT_POST_FROM_ISR=n +CONFIG_MDNS_ENABLE_CONSOLE_CLI=y +CONFIG_TEST_CONSOLE=y diff --git a/managed_components/espressif__mdns/tests/host_test/sdkconfig.ci.target b/managed_components/espressif__mdns/tests/host_test/sdkconfig.ci.target new file mode 100644 index 0000000..2a43df1 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/sdkconfig.ci.target @@ -0,0 +1 @@ +CONFIG_IDF_TARGET="esp32" diff --git a/managed_components/espressif__mdns/tests/host_test/sdkconfig.defaults b/managed_components/espressif__mdns/tests/host_test/sdkconfig.defaults new file mode 100644 index 0000000..7e79ce4 --- /dev/null +++ b/managed_components/espressif__mdns/tests/host_test/sdkconfig.defaults @@ -0,0 +1,6 @@ +CONFIG_TEST_NETIF_NAME="eth0" +CONFIG_ESP_EVENT_POST_FROM_ISR=n +CONFIG_MDNS_NETWORKING_SOCKET=y +CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES=y +CONFIG_MDNS_PREDEF_NETIF_STA=n +CONFIG_MDNS_PREDEF_NETIF_AP=n diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/CMakeLists.txt b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/CMakeLists.txt new file mode 100644 index 0000000..d658451 --- /dev/null +++ b/managed_components/espressif__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) diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/Makefile b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/Makefile new file mode 100644 index 0000000..c9f08b1 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/Makefile @@ -0,0 +1,96 @@ +#INSTR=off +TEST_NAME=test +FUZZ=afl-fuzz +COMPONENTS_DIR=$(IDF_PATH)/components +# Use ESP32 toolchain include path if available, otherwise fall back to system includes for host-based compilation +COMPILER_INCLUDE_DIR=$(shell if command -v xtensa-esp32-elf-gcc >/dev/null 2>&1; then echo `which xtensa-esp32-elf-gcc | xargs dirname | xargs dirname`/xtensa-esp32-elf; else echo /usr; fi) + +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)/linux/include \ + -I$(COMPONENTS_DIR)/lwip/port/esp32/include \ + -I$(COMPONENTS_DIR)/lwip/lwip/src/include/lwip/apps \ + -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$(COMPONENTS_DIR)/esp_hw_support/etm/include \ + -I$(COMPILER_INCLUDE_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) + # timeout returns 124 if time limit is reached, original return code otherwise + # pass only if: fuzzing was running smoothly until timeout AND no crash found + @timeout 10m $(FUZZ) -i "in" -o "out" -- ./$(TEST_NAME) || \ + if [ $$? -eq 124 ]; then \ + if [ -n "$$(find out/default/crashes -type f 2>/dev/null)" ]; then \ + echo "Crashes found!"; \ + tar -czf out/default/crashes.tar.gz -C out/default crashes; \ + exit 1; \ + fi \ + else \ + exit 1; \ + fi + +clean: + @rm -rf *.o *.SYM $(TEST_NAME) out diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/README.md b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/README.md new file mode 100644 index 0000000..e22a896 --- /dev/null +++ b/managed_components/espressif__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 +``` diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp32_mock.c b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp32_mock.c new file mode 100644 index 0000000..7f14dc6 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp32_mock.c @@ -0,0 +1,162 @@ +/* + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ +#include +#include +#include +#include +#include +#include "esp32_mock.h" +#include "esp_log.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; +} + +void esp_log_write(esp_log_level_t level, const char *tag, const char *format, ...) +{ +} + +void esp_log(esp_log_config_t config, const char *tag, const char *format, ...) +{ +} + +uint32_t esp_log_timestamp(void) +{ + return 0; +} + +void *mdns_mem_malloc(size_t size) +{ + return malloc(size); +} + +void *mdns_mem_calloc(size_t num, size_t size) +{ + return calloc(num, size); +} + +void mdns_mem_free(void *ptr) +{ + free(ptr); +} + +char *mdns_mem_strdup(const char *s) +{ + return strdup(s); +} + +char *mdns_mem_strndup(const char *s, size_t n) +{ + return strndup(s, n); +} + +void *mdns_mem_task_malloc(size_t size) +{ + return malloc(size); +} + +void mdns_mem_task_free(void *ptr) +{ + free(ptr); +} diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp32_mock.h b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp32_mock.h new file mode 100644 index 0000000..70a2037 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp32_mock.h @@ -0,0 +1,145 @@ +/* + * SPDX-FileCopyrightText: 2015-2025 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 +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#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 MDNS_TASK_MEMORY_LOG "internal RAM" +#define MALLOC_CAP_8BIT (1<<2) +#define MALLOC_CAP_INTERNAL (1<<11) + +#define pdTRUE true +#define pdFALSE false +#define pdPASS ( pdTRUE ) +#define pdFAIL ( pdFALSE ) + +#define portMAX_DELAY 0xFFFFFFFF +#define portTICK_PERIOD_MS 1 +#define LWIP_HDR_PBUF_H +#define __ESP_RANDOM_H__ +#define INC_TASK_H + +#define pdMS_TO_TICKS(a) a +#define xSemaphoreTake(s,d) true +#define vTaskDelete(a) free(NULL) +#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 xTaskCreateStaticPinnedToCore(a,b,c,d,e,f,g,h) ((void*)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; +typedef void *StackType_t; +typedef void *StaticTask_t; + +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); + +static inline void xTaskGetStaticBuffers(void *pvTaskBuffer, void *pvStackBuffer, void *pvTaskTCB) +{ +} + +#endif //_ESP32_COMPAT_H_ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp_attr.h b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp_attr.h new file mode 100644 index 0000000..75b6678 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp_attr.h @@ -0,0 +1,14 @@ +/* + * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ +#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 diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp_netif_mock.c b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp_netif_mock.c new file mode 100644 index 0000000..80629ad --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/esp_netif_mock.c @@ -0,0 +1,55 @@ +/* + * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include +#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; +} diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/file2.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/file2.bin new file mode 100644 index 0000000..a7ce859 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/file2.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_4a_txt.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_4a_txt.bin new file mode 100644 index 0000000..37f2803 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_4a_txt.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_aaaa.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_aaaa.bin new file mode 100644 index 0000000..6ddb7ac Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_aaaa.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_any.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_any.bin new file mode 100644 index 0000000..99a6d18 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_any.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_disc.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_disc.bin new file mode 100644 index 0000000..5f3ba62 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_disc.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_ptr.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_ptr.bin new file mode 100644 index 0000000..67da5ed Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_ptr.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_query.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_query.bin new file mode 100644 index 0000000..d21c0d2 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_query.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_query2.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_query2.bin new file mode 100644 index 0000000..986118d Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/minif_query2.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/sub_fritz_m.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/sub_fritz_m.bin new file mode 100644 index 0000000..68e1d75 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/sub_fritz_m.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/telnet_ptr.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/telnet_ptr.bin new file mode 100644 index 0000000..1cd8e85 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/telnet_ptr.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-14.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-14.bin new file mode 100644 index 0000000..b9d059d Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-14.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-15.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-15.bin new file mode 100644 index 0000000..3250de5 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-15.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-16.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-16.bin new file mode 100644 index 0000000..19915d8 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-16.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-28.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-28.bin new file mode 100644 index 0000000..537352a Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-28.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-29.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-29.bin new file mode 100644 index 0000000..837737b Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-29.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-31.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-31.bin new file mode 100644 index 0000000..690b735 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-31.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-53.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-53.bin new file mode 100644 index 0000000..73181ea Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-53.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-56.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-56.bin new file mode 100644 index 0000000..980b651 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-56.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-63.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-63.bin new file mode 100644 index 0000000..883d444 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-63.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-83.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-83.bin new file mode 100644 index 0000000..c6cc159 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-83.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-88.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-88.bin new file mode 100644 index 0000000..fcbb384 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-88.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-89.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-89.bin new file mode 100644 index 0000000..d60a987 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-89.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-95.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-95.bin new file mode 100644 index 0000000..2655309 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-95.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-96.bin b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-96.bin new file mode 100644 index 0000000..fabf8b7 Binary files /dev/null and b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/in/test-96.bin differ diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/input_packets.txt b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/input_packets.txt new file mode 100644 index 0000000..15c5df2 --- /dev/null +++ b/managed_components/espressif__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 diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/mdns_di.h b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/mdns_di.h new file mode 100644 index 0000000..ed56960 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/mdns_di.h @@ -0,0 +1,61 @@ +/* + * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ +/* + * MDNS Dependecy injection -- preincluded to inject interface test functions into static variables + * + */ + +#include "mdns.h" +#include "mdns_private.h" + +void (*mdns_test_static_execute_action)(mdns_action_t *) = NULL; +mdns_srv_item_t *(*mdns_test_static_mdns_get_service_item)(const char *service, const char *proto, const char *hostname) = NULL; +mdns_search_once_t *(*mdns_test_static_search_init)(const char *name, const char *service, const char *proto, uint16_t type, bool unicast, + uint32_t timeout, uint8_t max_results, + mdns_query_notify_t notifier) = NULL; +esp_err_t (*mdns_test_static_send_search_action)(mdns_action_type_t type, mdns_search_once_t *search) = NULL; +void (*mdns_test_static_search_free)(mdns_search_once_t *search) = NULL; + +static void _mdns_execute_action(mdns_action_t *action); +static mdns_srv_item_t *_mdns_get_service_item(const char *service, const char *proto, const char *hostname); +static mdns_search_once_t *_mdns_search_init(const char *name, const char *service, const char *proto, uint16_t type, bool unicast, + uint32_t timeout, uint8_t max_results, mdns_query_notify_t notifier); +static esp_err_t _mdns_send_search_action(mdns_action_type_t type, mdns_search_once_t *search); +static void _mdns_search_free(mdns_search_once_t *search); + +void mdns_test_init_di(void) +{ + mdns_test_static_execute_action = _mdns_execute_action; + mdns_test_static_mdns_get_service_item = _mdns_get_service_item; + mdns_test_static_search_init = _mdns_search_init; + mdns_test_static_send_search_action = _mdns_send_search_action; + mdns_test_static_search_free = _mdns_search_free; +} + +void mdns_test_execute_action(void *action) +{ + mdns_test_static_execute_action((mdns_action_t *)action); +} + +void mdns_test_search_free(mdns_search_once_t *search) +{ + return mdns_test_static_search_free(search); +} + +esp_err_t mdns_test_send_search_action(mdns_action_type_t type, mdns_search_once_t *search) +{ + return mdns_test_static_send_search_action(type, search); +} + +mdns_search_once_t *mdns_test_search_init(const char *name, const char *service, const char *proto, uint16_t type, uint32_t timeout, uint8_t max_results) +{ + return mdns_test_static_search_init(name, service, proto, type, timeout, type != MDNS_TYPE_PTR, max_results, NULL); +} + +mdns_srv_item_t *mdns_test_mdns_get_service_item(const char *service, const char *proto) +{ + return mdns_test_static_mdns_get_service_item(service, proto, NULL); +} diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/mdns_mock.h b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/mdns_mock.h new file mode 100644 index 0000000..d37da92 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/mdns_mock.h @@ -0,0 +1,31 @@ +/* + * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ +#pragma once +#include "esp32_mock.h" +#include "mdns.h" +#include "mdns_private.h" + + +static inline void *_mdns_get_packet_data(mdns_rx_packet_t *packet) +{ + return packet->pb->payload; +} + +static inline size_t _mdns_get_packet_len(mdns_rx_packet_t *packet) +{ + return packet->pb->len; +} + +static inline void _mdns_packet_free(mdns_rx_packet_t *packet) +{ + free(packet->pb); + free(packet); +} + +static inline bool mdns_is_netif_ready(mdns_if_t tcpip_if, mdns_ip_protocol_t ip_protocol) +{ + return true; +} diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/sdkconfig.h b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/sdkconfig.h new file mode 100644 index 0000000..da75d14 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/sdkconfig.h @@ -0,0 +1,424 @@ +/* + * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ +/* + * This config file commited in order to not run `idf.py reconfigure` each time when running fuzzer test. You can modify it manually or run `idf.py reconfigure` to generate new one if needed. + * Espressif IoT Development Framework (ESP-IDF) Configuration Header + */ +#pragma once +#define CONFIG_IDF_TARGET "esp32" +#define CONFIG_IDF_TARGET_ESP32 1 +#define CONFIG_IDF_FIRMWARE_CHIP_ID 0x0000 +#define CONFIG_SDK_TOOLPREFIX "xtensa-esp32-elf-" +#define CONFIG_APP_BUILD_TYPE_APP_2NDBOOT 1 +#define CONFIG_APP_BUILD_GENERATE_BINARIES 1 +#define CONFIG_APP_BUILD_BOOTLOADER 1 +#define CONFIG_APP_BUILD_USE_FLASH_SECTIONS 1 +#define CONFIG_APP_COMPILE_TIME_DATE 1 +#define CONFIG_APP_RETRIEVE_LEN_ELF_SHA 16 +#define CONFIG_BOOTLOADER_COMPILER_OPTIMIZATION_SIZE 1 +#define CONFIG_BOOTLOADER_LOG_LEVEL_INFO 1 +#define CONFIG_BOOTLOADER_LOG_LEVEL 3 +#define CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V 1 +#define CONFIG_BOOTLOADER_WDT_ENABLE 1 +#define CONFIG_BOOTLOADER_WDT_TIME_MS 9000 +#define CONFIG_BOOTLOADER_RESERVE_RTC_SIZE 0x0 +#define CONFIG_ESPTOOLPY_WITH_STUB 1 +#define CONFIG_ESPTOOLPY_FLASHMODE_DIO 1 +#define CONFIG_ESPTOOLPY_FLASHMODE "dio" +#define CONFIG_ESPTOOLPY_FLASHFREQ_40M 1 +#define CONFIG_ESPTOOLPY_FLASHFREQ "40m" +#define CONFIG_ESPTOOLPY_FLASHSIZE_2MB 1 +#define CONFIG_ESPTOOLPY_FLASHSIZE "2MB" +#define CONFIG_ESPTOOLPY_FLASHSIZE_DETECT 1 +#define CONFIG_ESPTOOLPY_BEFORE_RESET 1 +#define CONFIG_ESPTOOLPY_BEFORE "default_reset" +#define CONFIG_ESPTOOLPY_AFTER_RESET 1 +#define CONFIG_ESPTOOLPY_AFTER "hard_reset" +#define CONFIG_PARTITION_TABLE_SINGLE_APP 1 +#define CONFIG_PARTITION_TABLE_CUSTOM_FILENAME "partitions.csv" +#define CONFIG_PARTITION_TABLE_FILENAME "partitions_singleapp.csv" +#define CONFIG_PARTITION_TABLE_OFFSET 0x8000 +#define CONFIG_PARTITION_TABLE_MD5 1 +#define CONFIG_COMPILER_OPTIMIZATION_DEFAULT 1 +#define CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE 1 +#define CONFIG_COMPILER_STACK_CHECK_MODE_NONE 1 +#define CONFIG_APPTRACE_DEST_NONE 1 +#define CONFIG_APPTRACE_LOCK_ENABLE 1 +#define CONFIG_BTDM_CTRL_BR_EDR_SCO_DATA_PATH_EFF 0 +#define CONFIG_BTDM_CTRL_BLE_MAX_CONN_EFF 0 +#define CONFIG_BTDM_CTRL_BR_EDR_MAX_ACL_CONN_EFF 0 +#define CONFIG_BTDM_CTRL_BR_EDR_MAX_SYNC_CONN_EFF 0 +#define CONFIG_BTDM_CTRL_PINNED_TO_CORE 0 +#define CONFIG_BTDM_BLE_SLEEP_CLOCK_ACCURACY_INDEX_EFF 1 +#define CONFIG_BTDM_RESERVE_DRAM 0x0 +#define CONFIG_COAP_MBEDTLS_PSK 1 +#define CONFIG_COAP_LOG_DEFAULT_LEVEL 0 +#define CONFIG_ADC_DISABLE_DAC 1 +#define CONFIG_SPI_MASTER_ISR_IN_IRAM 1 +#define CONFIG_SPI_SLAVE_ISR_IN_IRAM 1 +#define CONFIG_EFUSE_CODE_SCHEME_COMPAT_3_4 1 +#define CONFIG_EFUSE_MAX_BLK_LEN 192 +#define CONFIG_ESP_TLS_USING_MBEDTLS 1 +#define CONFIG_ESP32_REV_MIN_0 1 +#define CONFIG_ESP32_REV_MIN 0 +#define CONFIG_ESP32_DPORT_WORKAROUND 1 +#define CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_160 1 +#define CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ 160 +#define CONFIG_ESP32_TRACEMEM_RESERVE_DRAM 0x0 +#define CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES_FOUR 1 +#define CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES 4 +#define CONFIG_ULP_COPROC_RESERVE_MEM 0 +#define CONFIG_ESP_DEBUG_OCDAWARE 1 +#define CONFIG_ESP_BROWNOUT_DET 1 +#define CONFIG_ESP_BROWNOUT_DET_LVL_SEL_0 1 +#define CONFIG_ESP_BROWNOUT_DET_LVL 0 +#define CONFIG_ESP32_REDUCE_PHY_TX_POWER 1 +#define CONFIG_NEWLIB_TIME_SYSCALL_USE_RTC_HRT 1 +#define CONFIG_RTC_CLK_SRC_INT_RC 1 +#define CONFIG_RTC_CLK_CAL_CYCLES 1024 +#define CONFIG_ESP32_DEEP_SLEEP_WAKEUP_DELAY 2000 +#define CONFIG_ESP32_XTAL_FREQ_40 1 +#define CONFIG_ESP32_XTAL_FREQ 40 +#define CONFIG_ESP32_DPORT_DIS_INTERRUPT_LVL 5 +#define CONFIG_ADC_CAL_EFUSE_TP_ENABLE 1 +#define CONFIG_ADC_CAL_EFUSE_VREF_ENABLE 1 +#define CONFIG_ADC_CAL_LUT_ENABLE 1 +#define CONFIG_ESP_ERR_TO_NAME_LOOKUP 1 +#define CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE 32 +#define CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE 2304 +#define CONFIG_ESP_MAIN_TASK_STACK_SIZE 3584 +#define CONFIG_ESP_IPC_TASK_STACK_SIZE 1024 +#define CONFIG_ESP_IPC_USES_CALLERS_PRIORITY 1 +#define CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE 2048 +#define CONFIG_ESP_CONSOLE_UART_DEFAULT 1 +#define CONFIG_ESP_CONSOLE_UART_NUM 0 +#define CONFIG_ESP_CONSOLE_UART_TX_GPIO 1 +#define CONFIG_ESP_CONSOLE_UART_RX_GPIO 3 +#define CONFIG_ESP_CONSOLE_UART_BAUDRATE 115200 +#define CONFIG_ESP_INT_WDT 1 +#define CONFIG_ESP_INT_WDT_TIMEOUT_MS 300 +#define CONFIG_ESP_INT_WDT_CHECK_CPU1 1 +#define CONFIG_ESP_TASK_WDT 1 +#define CONFIG_ESP_TASK_WDT_TIMEOUT_S 5 +#define CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0 1 +#define CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1 1 +#define CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_STA 1 +#define CONFIG_ESP_MAC_ADDR_UNIVERSE_WIFI_AP 1 +#define CONFIG_ESP_MAC_ADDR_UNIVERSE_BT 1 +#define CONFIG_ESP_MAC_ADDR_UNIVERSE_BT_OFFSET 2 +#define CONFIG_ESP_MAC_ADDR_UNIVERSE_ETH 1 +#define CONFIG_ETH_ENABLED 1 +#define CONFIG_ETH_USE_ESP32_EMAC 1 +#define CONFIG_ETH_PHY_INTERFACE_RMII 1 +#define CONFIG_ETH_RMII_CLK_INPUT 1 +#define CONFIG_ETH_RMII_CLK_IN_GPIO 0 +#define CONFIG_ETH_DMA_BUFFER_SIZE 512 +#define CONFIG_ETH_DMA_RX_BUFFER_NUM 10 +#define CONFIG_ETH_DMA_TX_BUFFER_NUM 10 +#define CONFIG_ETH_USE_SPI_ETHERNET 1 +#define CONFIG_ESP_EVENT_POST_FROM_ISR 1 +#define CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR 1 +#define CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS 1 +#define CONFIG_HTTPD_MAX_REQ_HDR_LEN 512 +#define CONFIG_HTTPD_MAX_URI_LEN 512 +#define CONFIG_HTTPD_ERR_RESP_NO_DELAY 1 +#define CONFIG_HTTPD_PURGE_BUF_LEN 32 +#define CONFIG_ESP_NETIF_IP_LOST_TIMER_INTERVAL 120 +#define CONFIG_ESP_NETIF_TCPIP_LWIP 1 +#define CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT 1 +#define CONFIG_ESP_TIMER_TASK_STACK_SIZE 3584 +#define CONFIG_ESP_TIMER_IMPL_TG0_LAC 1 +#define CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM 10 +#define CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM 32 +#define CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER 1 +#define CONFIG_ESP32_WIFI_TX_BUFFER_TYPE 1 +#define CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER_NUM 32 +#define CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED 1 +#define CONFIG_ESP32_WIFI_TX_BA_WIN 6 +#define CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED 1 +#define CONFIG_ESP32_WIFI_RX_BA_WIN 6 +#define CONFIG_ESP32_WIFI_NVS_ENABLED 1 +#define CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0 1 +#define CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN 752 +#define CONFIG_ESP32_WIFI_MGMT_SBUF_NUM 32 +#define CONFIG_ESP32_WIFI_IRAM_OPT 1 +#define CONFIG_ESP32_WIFI_RX_IRAM_OPT 1 +#define CONFIG_ESP32_WIFI_ENABLE_WPA3_SAE 1 +#define CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE 1 +#define CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER 20 +#define CONFIG_ESP32_PHY_MAX_TX_POWER 20 +#define CONFIG_ESP_COREDUMP_ENABLE_TO_NONE 1 +#define CONFIG_FATFS_CODEPAGE_437 1 +#define CONFIG_FATFS_CODEPAGE 437 +#define CONFIG_FATFS_LFN_NONE 1 +#define CONFIG_FATFS_FS_LOCK 0 +#define CONFIG_FATFS_TIMEOUT_MS 10000 +#define CONFIG_FATFS_PER_FILE_CACHE 1 +#define CONFIG_FMB_COMM_MODE_RTU_EN 1 +#define CONFIG_FMB_COMM_MODE_ASCII_EN 1 +#define CONFIG_FMB_MASTER_TIMEOUT_MS_RESPOND 150 +#define CONFIG_FMB_MASTER_DELAY_MS_CONVERT 200 +#define CONFIG_FMB_QUEUE_LENGTH 20 +#define CONFIG_FMB_SERIAL_TASK_STACK_SIZE 2048 +#define CONFIG_FMB_SERIAL_BUF_SIZE 256 +#define CONFIG_FMB_SERIAL_ASCII_BITS_PER_SYMB 8 +#define CONFIG_FMB_SERIAL_ASCII_TIMEOUT_RESPOND_MS 1000 +#define CONFIG_FMB_SERIAL_TASK_PRIO 10 +#define CONFIG_FMB_CONTROLLER_NOTIFY_TIMEOUT 20 +#define CONFIG_FMB_CONTROLLER_NOTIFY_QUEUE_SIZE 20 +#define CONFIG_FMB_CONTROLLER_STACK_SIZE 4096 +#define CONFIG_FMB_EVENT_QUEUE_TIMEOUT 20 +#define CONFIG_FMB_TIMER_PORT_ENABLED 1 +#define CONFIG_FMB_TIMER_GROUP 0 +#define CONFIG_FMB_TIMER_INDEX 0 +#define CONFIG_FREERTOS_NO_AFFINITY 0x7FFFFFFF +#define CONFIG_FREERTOS_CORETIMER_0 1 +#define CONFIG_FREERTOS_HZ 100 +#define CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION 1 +#define CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY 1 +#define CONFIG_FREERTOS_INTERRUPT_BACKTRACE 1 +#define CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS 1 +#define CONFIG_FREERTOS_IDLE_TASK_STACKSIZE 1536 +#define CONFIG_FREERTOS_ISR_STACKSIZE 1536 +#define CONFIG_FREERTOS_MAX_TASK_NAME_LEN 16 +#define CONFIG_FREERTOS_TIMER_TASK_PRIORITY 1 +#define CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH 2048 +#define CONFIG_FREERTOS_TIMER_QUEUE_LENGTH 10 +#define CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE 0 +#define CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER 1 +#define CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER 1 +#define CONFIG_FREERTOS_DEBUG_OCDAWARE 1 +#define CONFIG_HEAP_POISONING_DISABLED 1 +#define CONFIG_HEAP_TRACING_OFF 1 +#define CONFIG_LOG_DEFAULT_LEVEL_INFO 1 +#define CONFIG_LOG_DEFAULT_LEVEL 3 +#define CONFIG_LOG_MAXIMUM_LEVEL 3 +#define CONFIG_LOG_COLORS 1 +#define CONFIG_LOG_TIMESTAMP_SOURCE_RTOS 1 +#define CONFIG_LWIP_LOCAL_HOSTNAME "espressif" +#define CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES 1 +#define CONFIG_LWIP_TIMERS_ONDEMAND 1 +#define CONFIG_LWIP_MAX_SOCKETS 10 +#define CONFIG_LWIP_SO_REUSE 1 +#define CONFIG_LWIP_SO_REUSE_RXTOALL 1 +#define CONFIG_LWIP_IP_FRAG 1 +#define CONFIG_LWIP_ESP_GRATUITOUS_ARP 1 +#define CONFIG_LWIP_GARP_TMR_INTERVAL 60 +#define CONFIG_LWIP_TCPIP_RECVMBOX_SIZE 32 +#define CONFIG_LWIP_DHCP_DOES_ARP_CHECK 1 +#define CONFIG_LWIP_DHCPS_LEASE_UNIT 60 +#define CONFIG_LWIP_DHCPS_MAX_STATION_NUM 8 +#define CONFIG_LWIP_NETIF_LOOPBACK 1 +#define CONFIG_LWIP_LOOPBACK_MAX_PBUFS 8 +#define CONFIG_LWIP_MAX_ACTIVE_TCP 16 +#define CONFIG_LWIP_MAX_LISTENING_TCP 16 +#define CONFIG_LWIP_TCP_MAXRTX 12 +#define CONFIG_LWIP_TCP_SYNMAXRTX 6 +#define CONFIG_LWIP_TCP_MSS 1440 +#define CONFIG_LWIP_TCP_TMR_INTERVAL 250 +#define CONFIG_LWIP_TCP_MSL 60000 +#define CONFIG_LWIP_TCP_SND_BUF_DEFAULT 5744 +#define CONFIG_LWIP_TCP_WND_DEFAULT 5744 +#define CONFIG_LWIP_TCP_RECVMBOX_SIZE 6 +#define CONFIG_LWIP_TCP_QUEUE_OOSEQ 1 +#define CONFIG_LWIP_TCP_OVERSIZE_MSS 1 +#define CONFIG_LWIP_MAX_UDP_PCBS 16 +#define CONFIG_LWIP_UDP_RECVMBOX_SIZE 6 +#define CONFIG_LWIP_TCPIP_TASK_STACK_SIZE 3072 +#define CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY 1 +#define CONFIG_LWIP_TCPIP_TASK_AFFINITY 0x7FFFFFFF +#define CONFIG_LWIP_MAX_RAW_PCBS 16 +#define CONFIG_LWIP_DHCP_MAX_NTP_SERVERS 1 +#define CONFIG_LWIP_SNTP_UPDATE_DELAY 3600000 +#define CONFIG_LWIP_ESP_LWIP_ASSERT 1 +#define CONFIG_MBEDTLS_INTERNAL_MEM_ALLOC 1 +#define CONFIG_MBEDTLS_ASYMMETRIC_CONTENT_LEN 1 +#define CONFIG_MBEDTLS_SSL_IN_CONTENT_LEN 16384 +#define CONFIG_MBEDTLS_SSL_OUT_CONTENT_LEN 4096 +#define CONFIG_MBEDTLS_CERTIFICATE_BUNDLE 1 +#define CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL 1 +#define CONFIG_MBEDTLS_HARDWARE_AES 1 +#define CONFIG_MBEDTLS_HARDWARE_MPI 1 +#define CONFIG_MBEDTLS_HARDWARE_SHA 1 +#define CONFIG_MBEDTLS_HAVE_TIME 1 +#define CONFIG_MBEDTLS_ECDSA_DETERMINISTIC 1 +#define CONFIG_MBEDTLS_SHA512_C 1 +#define CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT 1 +#define CONFIG_MBEDTLS_TLS_SERVER 1 +#define CONFIG_MBEDTLS_TLS_CLIENT 1 +#define CONFIG_MBEDTLS_TLS_ENABLED 1 +#define CONFIG_MBEDTLS_KEY_EXCHANGE_RSA 1 +#define CONFIG_MBEDTLS_KEY_EXCHANGE_DHE_RSA 1 +#define CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE 1 +#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA 1 +#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA 1 +#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA 1 +#define CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA 1 +#define CONFIG_MBEDTLS_SSL_RENEGOTIATION 1 +#define CONFIG_MBEDTLS_SSL_PROTO_TLS1 1 +#define CONFIG_MBEDTLS_SSL_PROTO_TLS1_1 1 +#define CONFIG_MBEDTLS_SSL_PROTO_TLS1_2 1 +#define CONFIG_MBEDTLS_SSL_ALPN 1 +#define CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS 1 +#define CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS 1 +#define CONFIG_MBEDTLS_AES_C 1 +#define CONFIG_MBEDTLS_RC4_DISABLED 1 +#define CONFIG_MBEDTLS_CCM_C 1 +#define CONFIG_MBEDTLS_GCM_C 1 +#define CONFIG_MBEDTLS_PEM_PARSE_C 1 +#define CONFIG_MBEDTLS_PEM_WRITE_C 1 +#define CONFIG_MBEDTLS_X509_CRL_PARSE_C 1 +#define CONFIG_MBEDTLS_X509_CSR_PARSE_C 1 +#define CONFIG_MBEDTLS_ECP_C 1 +#define CONFIG_MBEDTLS_ECDH_C 1 +#define CONFIG_MBEDTLS_ECDSA_C 1 +#define CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED 1 +#define CONFIG_MBEDTLS_ECP_NIST_OPTIM 1 +#define CONFIG_MDNS_MAX_SERVICES 25 +#define CONFIG_MDNS_MAX_INTERFACES 3 +#define CONFIG_MDNS_TASK_PRIORITY 1 +#define CONFIG_MDNS_ACTION_QUEUE_LEN 16 +#define CONFIG_MDNS_TASK_STACK_SIZE 4096 +#define CONFIG_MDNS_TASK_AFFINITY_CPU0 1 +#define CONFIG_MDNS_TASK_AFFINITY 0x0 +#define CONFIG_MDNS_SERVICE_ADD_TIMEOUT_MS 1 +#define CONFIG_MDNS_TIMER_PERIOD_MS 100 +#define CONFIG_MQTT_PROTOCOL_311 1 +#define CONFIG_MQTT_TRANSPORT_SSL 1 +#define CONFIG_MQTT_TRANSPORT_WEBSOCKET 1 +#define CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE 1 +#define CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF 1 +#define CONFIG_NEWLIB_STDIN_LINE_ENDING_CR 1 +#define CONFIG_OPENSSL_ASSERT_EXIT 1 +#define CONFIG_PTHREAD_TASK_PRIO_DEFAULT 5 +#define CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT 3072 +#define CONFIG_PTHREAD_STACK_MIN 768 +#define CONFIG_PTHREAD_DEFAULT_CORE_NO_AFFINITY 1 +#define CONFIG_PTHREAD_TASK_CORE_DEFAULT -1 +#define CONFIG_PTHREAD_TASK_NAME_DEFAULT "pthread" +#define CONFIG_SPI_FLASH_ROM_DRIVER_PATCH 1 +#define CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS 1 +#define CONFIG_SPI_FLASH_YIELD_DURING_ERASE 1 +#define CONFIG_SPI_FLASH_ERASE_YIELD_DURATION_MS 20 +#define CONFIG_SPI_FLASH_ERASE_YIELD_TICKS 1 +#define CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP 1 +#define CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP 1 +#define CONFIG_SPI_FLASH_SUPPORT_GD_CHIP 1 +#define CONFIG_SPIFFS_MAX_PARTITIONS 3 +#define CONFIG_SPIFFS_CACHE 1 +#define CONFIG_SPIFFS_CACHE_WR 1 +#define CONFIG_SPIFFS_PAGE_CHECK 1 +#define CONFIG_SPIFFS_GC_MAX_RUNS 10 +#define CONFIG_SPIFFS_PAGE_SIZE 256 +#define CONFIG_SPIFFS_OBJ_NAME_LEN 32 +#define CONFIG_SPIFFS_USE_MAGIC 1 +#define CONFIG_SPIFFS_USE_MAGIC_LENGTH 1 +#define CONFIG_SPIFFS_META_LENGTH 4 +#define CONFIG_SPIFFS_USE_MTIME 1 +#define CONFIG_USB_DESC_CUSTOM_VID 0x1234 +#define CONFIG_USB_DESC_CUSTOM_PID 0x5678 +#define CONFIG_UNITY_ENABLE_FLOAT 1 +#define CONFIG_UNITY_ENABLE_DOUBLE 1 +#define CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER 1 +#define CONFIG_VFS_SUPPORT_IO 1 +#define CONFIG_VFS_SUPPORT_DIR 1 +#define CONFIG_VFS_SUPPORT_SELECT 1 +#define CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT 1 +#define CONFIG_VFS_SUPPORT_TERMIOS 1 +#define CONFIG_VFS_SEMIHOSTFS_MAX_MOUNT_POINTS 1 +#define CONFIG_VFS_SEMIHOSTFS_HOST_PATH_MAX_LEN 128 +#define CONFIG_WL_SECTOR_SIZE_4096 1 +#define CONFIG_WL_SECTOR_SIZE 4096 +#define CONFIG_WIFI_PROV_SCAN_MAX_ENTRIES 16 +#define CONFIG_WIFI_PROV_AUTOSTOP_TIMEOUT 30 +#define CONFIG_WPA_MBEDTLS_CRYPTO 1 + +/* List of deprecated options */ +#define CONFIG_ADC2_DISABLE_DAC CONFIG_ADC_DISABLE_DAC +#define CONFIG_BROWNOUT_DET CONFIG_ESP_BROWNOUT_DET +#define CONFIG_BROWNOUT_DET_LVL_SEL_0 CONFIG_ESP_BROWNOUT_DET_LVL_SEL_0 +#define CONFIG_COMPILER_OPTIMIZATION_LEVEL_DEBUG CONFIG_COMPILER_OPTIMIZATION_DEFAULT +#define CONFIG_CONSOLE_UART_BAUDRATE CONFIG_ESP_CONSOLE_UART_BAUDRATE +#define CONFIG_CONSOLE_UART_DEFAULT CONFIG_ESP_CONSOLE_UART_DEFAULT +#define CONFIG_CONSOLE_UART_RX_GPIO CONFIG_ESP_CONSOLE_UART_RX_GPIO +#define CONFIG_CONSOLE_UART_TX_GPIO CONFIG_ESP_CONSOLE_UART_TX_GPIO +#define CONFIG_ESP32S2_PANIC_PRINT_REBOOT CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT +#define CONFIG_ESP32_APPTRACE_DEST_NONE CONFIG_APPTRACE_DEST_NONE +#define CONFIG_ESP32_DEFAULT_PTHREAD_CORE_NO_AFFINITY CONFIG_PTHREAD_DEFAULT_CORE_NO_AFFINITY +#define CONFIG_ESP32_PANIC_PRINT_REBOOT CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT +#define CONFIG_ESP32_PTHREAD_STACK_MIN CONFIG_PTHREAD_STACK_MIN +#define CONFIG_ESP32_PTHREAD_TASK_NAME_DEFAULT CONFIG_PTHREAD_TASK_NAME_DEFAULT +#define CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT CONFIG_PTHREAD_TASK_PRIO_DEFAULT +#define CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT CONFIG_PTHREAD_TASK_STACK_SIZE_DEFAULT +#define CONFIG_ESP_GRATUITOUS_ARP CONFIG_LWIP_ESP_GRATUITOUS_ARP +#define CONFIG_FLASHMODE_DIO CONFIG_ESPTOOLPY_FLASHMODE_DIO +#define CONFIG_FOUR_UNIVERSAL_MAC_ADDRESS CONFIG_ESP32_UNIVERSAL_MAC_ADDRESSES_FOUR +#define CONFIG_GARP_TMR_INTERVAL CONFIG_LWIP_GARP_TMR_INTERVAL +#define CONFIG_INT_WDT CONFIG_ESP_INT_WDT +#define CONFIG_INT_WDT_CHECK_CPU1 CONFIG_ESP_INT_WDT_CHECK_CPU1 +#define CONFIG_INT_WDT_TIMEOUT_MS CONFIG_ESP_INT_WDT_TIMEOUT_MS +#define CONFIG_IPC_TASK_STACK_SIZE CONFIG_ESP_IPC_TASK_STACK_SIZE +#define CONFIG_LOG_BOOTLOADER_LEVEL_INFO CONFIG_BOOTLOADER_LOG_LEVEL_INFO +#define CONFIG_MAIN_TASK_STACK_SIZE CONFIG_ESP_MAIN_TASK_STACK_SIZE +#define CONFIG_MB_CONTROLLER_NOTIFY_QUEUE_SIZE CONFIG_FMB_CONTROLLER_NOTIFY_QUEUE_SIZE +#define CONFIG_MB_CONTROLLER_NOTIFY_TIMEOUT CONFIG_FMB_CONTROLLER_NOTIFY_TIMEOUT +#define CONFIG_MB_CONTROLLER_STACK_SIZE CONFIG_FMB_CONTROLLER_STACK_SIZE +#define CONFIG_MB_EVENT_QUEUE_TIMEOUT CONFIG_FMB_EVENT_QUEUE_TIMEOUT +#define CONFIG_MB_MASTER_DELAY_MS_CONVERT CONFIG_FMB_MASTER_DELAY_MS_CONVERT +#define CONFIG_MB_MASTER_TIMEOUT_MS_RESPOND CONFIG_FMB_MASTER_TIMEOUT_MS_RESPOND +#define CONFIG_MB_QUEUE_LENGTH CONFIG_FMB_QUEUE_LENGTH +#define CONFIG_MB_SERIAL_BUF_SIZE CONFIG_FMB_SERIAL_BUF_SIZE +#define CONFIG_MB_SERIAL_TASK_PRIO CONFIG_FMB_SERIAL_TASK_PRIO +#define CONFIG_MB_SERIAL_TASK_STACK_SIZE CONFIG_FMB_SERIAL_TASK_STACK_SIZE +#define CONFIG_MB_TIMER_GROUP CONFIG_FMB_TIMER_GROUP +#define CONFIG_MB_TIMER_INDEX CONFIG_FMB_TIMER_INDEX +#define CONFIG_MB_TIMER_PORT_ENABLED CONFIG_FMB_TIMER_PORT_ENABLED +#define CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE +#define CONFIG_OPTIMIZATION_LEVEL_DEBUG CONFIG_COMPILER_OPTIMIZATION_DEFAULT +#define CONFIG_POST_EVENTS_FROM_IRAM_ISR CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR +#define CONFIG_POST_EVENTS_FROM_ISR CONFIG_ESP_EVENT_POST_FROM_ISR +#define CONFIG_REDUCE_PHY_TX_POWER CONFIG_ESP32_REDUCE_PHY_TX_POWER +#define CONFIG_SEMIHOSTFS_HOST_PATH_MAX_LEN CONFIG_VFS_SEMIHOSTFS_HOST_PATH_MAX_LEN +#define CONFIG_SEMIHOSTFS_MAX_MOUNT_POINTS CONFIG_VFS_SEMIHOSTFS_MAX_MOUNT_POINTS +#define CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ABORTS CONFIG_SPI_FLASH_DANGEROUS_WRITE_ABORTS +#define CONFIG_STACK_CHECK_NONE CONFIG_COMPILER_STACK_CHECK_MODE_NONE +#define CONFIG_SUPPORT_TERMIOS CONFIG_VFS_SUPPORT_TERMIOS +#define CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT +#define CONFIG_SYSTEM_EVENT_QUEUE_SIZE CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE +#define CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE +#define CONFIG_TASK_WDT CONFIG_ESP_TASK_WDT +#define CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0 +#define CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1 +#define CONFIG_TASK_WDT_TIMEOUT_S CONFIG_ESP_TASK_WDT_TIMEOUT_S +#define CONFIG_TCPIP_RECVMBOX_SIZE CONFIG_LWIP_TCPIP_RECVMBOX_SIZE +#define CONFIG_TCPIP_TASK_AFFINITY_NO_AFFINITY CONFIG_LWIP_TCPIP_TASK_AFFINITY_NO_AFFINITY +#define CONFIG_TCPIP_TASK_STACK_SIZE CONFIG_LWIP_TCPIP_TASK_STACK_SIZE +#define CONFIG_TCP_MAXRTX CONFIG_LWIP_TCP_MAXRTX +#define CONFIG_TCP_MSL CONFIG_LWIP_TCP_MSL +#define CONFIG_TCP_MSS CONFIG_LWIP_TCP_MSS +#define CONFIG_TCP_OVERSIZE_MSS CONFIG_LWIP_TCP_OVERSIZE_MSS +#define CONFIG_TCP_QUEUE_OOSEQ CONFIG_LWIP_TCP_QUEUE_OOSEQ +#define CONFIG_TCP_RECVMBOX_SIZE CONFIG_LWIP_TCP_RECVMBOX_SIZE +#define CONFIG_TCP_SND_BUF_DEFAULT CONFIG_LWIP_TCP_SND_BUF_DEFAULT +#define CONFIG_TCP_SYNMAXRTX CONFIG_LWIP_TCP_SYNMAXRTX +#define CONFIG_TCP_WND_DEFAULT CONFIG_LWIP_TCP_WND_DEFAULT +#define CONFIG_TIMER_QUEUE_LENGTH CONFIG_FREERTOS_TIMER_QUEUE_LENGTH +#define CONFIG_TIMER_TASK_PRIORITY CONFIG_FREERTOS_TIMER_TASK_PRIORITY +#define CONFIG_TIMER_TASK_STACK_DEPTH CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH +#define CONFIG_TIMER_TASK_STACK_SIZE CONFIG_ESP_TIMER_TASK_STACK_SIZE +#define CONFIG_TOOLPREFIX CONFIG_SDK_TOOLPREFIX +#define CONFIG_UDP_RECVMBOX_SIZE CONFIG_LWIP_UDP_RECVMBOX_SIZE diff --git a/managed_components/espressif__mdns/tests/test_afl_fuzz_host/test.c b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/test.c new file mode 100644 index 0000000..d753dc9 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_afl_fuzz_host/test.c @@ -0,0 +1,263 @@ +/* + * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include +#include +#include +#include + +#include "esp32_mock.h" +#include "mdns.h" +#include "mdns_private.h" + +// +// Global stuctures containing packet payload, search +mdns_rx_packet_t g_packet; +struct pbuf mypbuf; +mdns_search_once_t *search = NULL; + +// +// Dependency injected test functions +void mdns_test_execute_action(void *action); +mdns_srv_item_t *mdns_test_mdns_get_service_item(const char *service, const char *proto); +mdns_search_once_t *mdns_test_search_init(const char *name, const char *service, const char *proto, uint16_t type, uint32_t timeout, uint8_t max_results); +esp_err_t mdns_test_send_search_action(mdns_action_type_t type, mdns_search_once_t *search); +void mdns_test_search_free(mdns_search_once_t *search); +void mdns_test_init_di(void); +extern mdns_server_t *_mdns_server; + +// +// mdns function wrappers for mdns setup in test mode +static int mdns_test_hostname_set(const char *mdns_hostname) +{ + for (int i = 0; i < MDNS_MAX_INTERFACES; i++) { + _mdns_server->interfaces[i].pcbs[MDNS_IP_PROTOCOL_V4].state = PCB_RUNNING; // mark the PCB running to exercise mdns in fully operational mode + _mdns_server->interfaces[i].pcbs[MDNS_IP_PROTOCOL_V6].state = PCB_RUNNING; + } + int ret = mdns_hostname_set(mdns_hostname); + mdns_action_t *a = NULL; + GetLastItem(&a); + mdns_test_execute_action(a); + return ret; +} + +static int mdns_test_add_delegated_host(const char *mdns_hostname) +{ + mdns_ip_addr_t addr = { .addr = { .u_addr = ESP_IPADDR_TYPE_V4 } }; + addr.addr.u_addr.ip4.addr = 0x11111111; + int ret = mdns_delegate_hostname_add(mdns_hostname, &addr); + mdns_action_t *a = NULL; + GetLastItem(&a); + mdns_test_execute_action(a); + return ret; +} + + +static int mdns_test_service_instance_name_set(const char *service, const char *proto, const char *instance) +{ + int ret = mdns_service_instance_name_set(service, proto, instance); + mdns_action_t *a = NULL; + GetLastItem(&a); + mdns_test_execute_action(a); + return ret; +} + +static int mdns_test_service_txt_set(const char *service, const char *proto, uint8_t num_items, mdns_txt_item_t txt[]) +{ + int ret = mdns_service_txt_set(service, proto, txt, num_items); + mdns_action_t *a = NULL; + GetLastItem(&a); + mdns_test_execute_action(a); + return ret; +} + +static int mdns_test_sub_service_add(const char *sub_name, const char *service_name, const char *proto, uint32_t port) +{ + if (mdns_service_add(NULL, service_name, proto, port, NULL, 0)) { + return ESP_FAIL; + } + + if (mdns_test_mdns_get_service_item(service_name, proto) == NULL) { + return ESP_FAIL; + } + return mdns_service_subtype_add_for_host(NULL, service_name, proto, NULL, sub_name); +} + +static int mdns_test_service_add(const char *service_name, const char *proto, uint32_t port) +{ + if (mdns_service_add(NULL, service_name, proto, port, NULL, 0)) { + return ESP_FAIL; + } + + if (mdns_test_mdns_get_service_item(service_name, proto) == NULL) { + return ESP_FAIL; + } + return ESP_OK; +} + +static mdns_result_t *mdns_test_query(const char *name, const char *service, const char *proto, uint16_t type) +{ + search = mdns_test_search_init(name, service, proto, type, 3000, 20); + if (!search) { + abort(); + } + + if (mdns_test_send_search_action(ACTION_SEARCH_ADD, search)) { + mdns_test_search_free(search); + abort(); + } + + mdns_action_t *a = NULL; + GetLastItem(&a); + mdns_test_execute_action(a); + return NULL; +} + +static void mdns_test_query_free(void) +{ + mdns_test_search_free(search); +} + +// +// function "under test" where afl-mangled packets passed +// +void mdns_parse_packet(mdns_rx_packet_t *packet); + +// +// Test starts here +// +int main(int argc, char **argv) +{ + int i; + const char *mdns_hostname = "minifritz"; + const char *mdns_instance = "Hristo's Time Capsule"; + mdns_txt_item_t arduTxtData[4] = { + {"board", "esp32"}, + {"tcp_check", "no"}, + {"ssh_upload", "no"}, + {"auth_upload", "no"} + }; + + const uint8_t mac[6] = {0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x32}; + + uint8_t buf[1460]; + char winstance[21 + strlen(mdns_hostname)]; + + sprintf(winstance, "%s [%02x:%02x:%02x:%02x:%02x:%02x]", mdns_hostname, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); + + // Init depencency injected methods + mdns_test_init_di(); + + if (mdns_init()) { + abort(); + } + + if (mdns_test_hostname_set(mdns_hostname)) { + abort(); + } + + if (mdns_test_add_delegated_host(mdns_hostname) || mdns_test_add_delegated_host("megafritz")) { + abort(); + } + +#ifndef MDNS_NO_SERVICES + + if (mdns_test_sub_service_add("_server", "_fritz", "_tcp", 22)) { + abort(); + } + + if (mdns_test_service_add("_telnet", "_tcp", 22)) { + abort(); + } + + if (mdns_test_service_add("_workstation", "_tcp", 9)) { + abort(); + } + if (mdns_test_service_instance_name_set("_workstation", "_tcp", winstance)) { + abort(); + } + + if (mdns_test_service_add("_arduino", "_tcp", 3232)) { + abort(); + } + + if (mdns_test_service_txt_set("_arduino", "_tcp", 4, arduTxtData)) { + abort(); + } + + if (mdns_test_service_add("_http", "_tcp", 80)) { + abort(); + } + + if (mdns_test_service_instance_name_set("_http", "_tcp", "ESP WebServer")) { + abort(); + } + + if ( + mdns_test_service_add("_afpovertcp", "_tcp", 548) + || mdns_test_service_add("_rfb", "_tcp", 885) + || mdns_test_service_add("_smb", "_tcp", 885) + || mdns_test_service_add("_adisk", "_tcp", 885) + || mdns_test_service_add("_airport", "_tcp", 885) + || mdns_test_service_add("_printer", "_tcp", 885) + || mdns_test_service_add("_airplay", "_tcp", 885) + || mdns_test_service_add("_raop", "_tcp", 885) + || mdns_test_service_add("_uscan", "_tcp", 885) + || mdns_test_service_add("_uscans", "_tcp", 885) + || mdns_test_service_add("_ippusb", "_tcp", 885) + || mdns_test_service_add("_scanner", "_tcp", 885) + || mdns_test_service_add("_ipp", "_tcp", 885) + || mdns_test_service_add("_ipps", "_tcp", 885) + || mdns_test_service_add("_pdl-datastream", "_tcp", 885) + || mdns_test_service_add("_ptp", "_tcp", 885) + || mdns_test_service_add("_sleep-proxy", "_udp", 885)) { + abort(); + } +#endif + mdns_result_t *results = NULL; + FILE *file; + size_t nread; + +#ifdef INSTR_IS_OFF + size_t len = 1460; + memset(buf, 0, 1460); + + if (argc != 2) { + printf("Non-instrumentation mode: please supply a file name created by AFL to reproduce crash\n"); + return 1; + } else { + // + // Note: parameter1 is a file (mangled packet) which caused the crash + file = fopen(argv[1], "r"); + assert(file >= 0); + len = fread(buf, 1, 1460, file); + fclose(file); + } + + for (i = 0; i < 1; i++) { +#else + while (__AFL_LOOP(1000)) { + memset(buf, 0, 1460); + size_t len = read(0, buf, 1460); +#endif + mypbuf.payload = malloc(len); + memcpy(mypbuf.payload, buf, len); + mypbuf.len = len; + g_packet.pb = &mypbuf; + mdns_test_query("minifritz", "_fritz", "_tcp", MDNS_TYPE_ANY); + mdns_test_query(NULL, "_fritz", "_tcp", MDNS_TYPE_PTR); + mdns_test_query(NULL, "_afpovertcp", "_tcp", MDNS_TYPE_PTR); + mdns_parse_packet(&g_packet); + free(mypbuf.payload); + } +#ifndef MDNS_NO_SERVICES + mdns_service_remove_all(); +#endif + ForceTaskDelete(); + mdns_free(); + return 0; +} diff --git a/managed_components/espressif__mdns/tests/test_apps/CMakeLists.txt b/managed_components/espressif__mdns/tests/test_apps/CMakeLists.txt new file mode 100644 index 0000000..62d1565 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_apps/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(mdns_test_app) diff --git a/managed_components/espressif__mdns/tests/test_apps/README.md b/managed_components/espressif__mdns/tests/test_apps/README.md new file mode 100644 index 0000000..96b76dc --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_apps/README.md @@ -0,0 +1,49 @@ +| Supported Targets | ESP32 | ESP32-S2 | ESP32-C3 | +| ----------------- | ----- | -------- | -------- | + +# mDNS test project + +Main purpose of this application is to test the mDNS library to correctly advertise, lookup services and hosts. +The "app_test.py" logically separated from two sets of test cases 1. "ESP32 board sends queries -> Host sends answers" and 2. "Host sends queries" -> "ESP32 board sends answers". +Two first sets of test cases are starting by 'test_query_' and the second ones by 'start_case'. + +## Runtime settings + +1. For first sets of test cases python creates and sends dns queries using "dpkt" library +2. For the second sets of test cases this app waits for user input to provide test case(e.g. CONFIG_TEST_QUERY_HOST, CONFIG_TEST_QUERY_HOST_ASYNC or CONFIG_TEST_QUERY_SERVICE) +In order to run both of them just needed to set up the project and run by 'python app_test.py' + +## Test app workflow + +- mDNS is initialized with hostname 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 tries to connect to the access point defined through the project configuration + +### 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` + +### Build and Flash + +Build the project and flash it to the board, then run the monitor tool to view the 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 +- 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. + +## Hardware Required +This test-app can be executed on any ESP32 board, the only required interface is WiFi and connection to a local network and tls server. diff --git a/managed_components/espressif__mdns/tests/test_apps/main/CMakeLists.txt b/managed_components/espressif__mdns/tests/test_apps/main/CMakeLists.txt new file mode 100644 index 0000000..b5902d5 --- /dev/null +++ b/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 ".") diff --git a/managed_components/espressif__mdns/tests/test_apps/main/Kconfig.projbuild b/managed_components/espressif__mdns/tests/test_apps/main/Kconfig.projbuild new file mode 100644 index 0000000..a1c0d72 --- /dev/null +++ b/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 diff --git a/managed_components/espressif__mdns/tests/test_apps/main/idf_component.yml b/managed_components/espressif__mdns/tests/test_apps/main/idf_component.yml new file mode 100644 index 0000000..e9277df --- /dev/null +++ b/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 diff --git a/managed_components/espressif__mdns/tests/test_apps/main/main.c b/managed_components/espressif__mdns/tests/test_apps/main/main.c new file mode 100644 index 0000000..1ff0cc1 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_apps/main/main.c @@ -0,0 +1,117 @@ +/* + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ +#include +#include +#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; + } +} diff --git a/managed_components/espressif__mdns/tests/test_apps/main/mdns_test.c b/managed_components/espressif__mdns/tests/test_apps/main/mdns_test.c new file mode 100644 index 0000000..06df424 --- /dev/null +++ b/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 +#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); + } +} diff --git a/managed_components/espressif__mdns/tests/test_apps/pytest_mdns_app.py b/managed_components/espressif__mdns/tests/test_apps/pytest_mdns_app.py new file mode 100644 index 0000000..2b04cb7 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_apps/pytest_mdns_app.py @@ -0,0 +1,320 @@ +# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD +# SPDX-License-Identifier: Apache-2.0 + +import re +import select +import socket +import struct +import time +from threading import Event, Thread + +import dpkt +import dpkt.dns +import pytest + +UDP_PORT = 5353 +MCAST_GRP = '224.0.0.251' + +# This service is created from esp board startup +SERVICE_NAME = u'ESP32-WebServer._http._tcp.local' +SUB_SERVICE_NAME = u'_server._sub._http._tcp.local' + +# This host name answer sent by host, when there is query from board +HOST_NAME = u'tinytester.local' + +# This servce answer sent by host, when there is query from board +MDNS_HOST_SERVICE = u'ESP32._http._tcp.local' + +# Number of retries to receive mdns answear +RETRY_COUNT = 10 + +stop_mdns_listener = Event() +start_mdns_listener = Event() +esp_service_answered = Event() +esp_sub_service_answered = Event() +esp_host_answered = Event() +esp_delegated_host_answered = Event() + + +@pytest.mark.skip +# Get query of ESP32-WebServer._http._tcp.local service +def get_mdns_service_query(service): # type:(str) -> dpkt.dns.Msg + dns = dpkt.dns.DNS() + 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_SRV + arr.name = service + arr.target = socket.inet_aton('127.0.0.1') + arr.srvname = service + dns.qd.append(arr) + print('Created mdns service query: {} '.format(dns.__repr__())) + return dns.pack() + + +@pytest.mark.skip +# Get query of _server_.sub._http._tcp.local sub service +def get_mdns_sub_service_query(sub_service): # type:(str) -> dpkt.dns.Msg + dns = dpkt.dns.DNS() + 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_PTR + arr.name = sub_service + arr.target = socket.inet_aton('127.0.0.1') + arr.ptrname = sub_service + dns.qd.append(arr) + print('Created mdns subtype service query: {} '.format(dns.__repr__())) + return dns.pack() + + +@pytest.mark.skip +# Get query for host resolution +def get_dns_query_for_esp(esp_host): # type:(str) -> dpkt.dns.Msg + dns = dpkt.dns.DNS() + arr = dpkt.dns.DNS.RR() + arr.cls = dpkt.dns.DNS_IN + arr.name = esp_host + u'.local' + dns.qd.append(arr) + print('Created query for esp host: {} '.format(dns.__repr__())) + return dns.pack() + + +@pytest.mark.skip +# Get mdns answer for host resoloution +def get_dns_answer_to_mdns(tester_host): # type:(str) -> dpkt.dns.Msg + dns = dpkt.dns.DNS() + 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) + print('Created answer to mdns query: {} '.format(dns.__repr__())) + return dns.pack() + + +@pytest.mark.skip +# Get mdns answer for service query +def get_dns_answer_to_service_query( + mdns_service): # type:(str) -> dpkt.dns.Msg + dns = dpkt.dns.DNS() + dns.op = dpkt.dns.DNS_QR | dpkt.dns.DNS_AA + dns.rcode = dpkt.dns.DNS_RCODE_NOERR + arr = dpkt.dns.DNS.RR() + arr.name = mdns_service + arr.cls = dpkt.dns.DNS_IN + arr.type = dpkt.dns.DNS_SRV + arr.priority = 0 + arr.weight = 0 + arr.port = 100 + arr.srvname = mdns_service + arr.ip = socket.inet_aton('127.0.0.1') + dns.an.append(arr) + print('Created answer to mdns query: {} '.format(dns.__repr__())) + return dns.pack() + + +@pytest.mark.skip +def mdns_listener(esp_host): # type:(str) -> None + print('mdns_listener thread started') + + UDP_IP = '0.0.0.0' + 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() + QUERY_TIMEOUT = 0.2 + while not stop_mdns_listener.is_set(): + try: + start_mdns_listener.set() + current_time = time.time() + if current_time - last_query_timepoint > QUERY_TIMEOUT: + last_query_timepoint = current_time + timeout = max( + 0, QUERY_TIMEOUT - (current_time - last_query_timepoint)) + read_socks, _, _ = select.select([sock], [], [], timeout) + if not read_socks: + continue + data, _ = sock.recvfrom(1024) + dns = dpkt.dns.DNS(data) + # Receives queries from esp board and sends answers + if len(dns.qd) > 0: + if dns.qd[0].name == HOST_NAME: + print('Received query: {} '.format(dns.__repr__())) + sock.sendto(get_dns_answer_to_mdns(HOST_NAME), + (MCAST_GRP, UDP_PORT)) + if dns.qd[0].name == HOST_NAME: + print('Received query: {} '.format(dns.__repr__())) + sock.sendto(get_dns_answer_to_mdns(HOST_NAME), + (MCAST_GRP, UDP_PORT)) + if dns.qd[0].name == MDNS_HOST_SERVICE: + print('Received query: {} '.format(dns.__repr__())) + sock.sendto( + get_dns_answer_to_service_query(MDNS_HOST_SERVICE), + (MCAST_GRP, UDP_PORT)) + # Receives answers from esp board and sets event flags for python test cases + if len(dns.an) == 1: + if dns.an[0].name.startswith(SERVICE_NAME): + print('Received answer to service query: {}'.format( + dns.__repr__())) + esp_service_answered.set() + if len(dns.an) > 1: + if dns.an[1].name.startswith(SUB_SERVICE_NAME): + print('Received answer for sub service query: {}'.format( + dns.__repr__())) + esp_sub_service_answered.set() + if len(dns.an) > 0 and dns.an[0].type == dpkt.dns.DNS_A: + if dns.an[0].name == esp_host + u'.local': + print('Received answer to esp32-mdns query: {}'.format( + dns.__repr__())) + esp_host_answered.set() + if dns.an[0].name == esp_host + u'-delegated.local': + print('Received answer to esp32-mdns-delegate query: {}'. + format(dns.__repr__())) + esp_delegated_host_answered.set() + except socket.timeout: + break + except dpkt.UnpackError: + continue + + +@pytest.mark.skip +def create_socket(): # type:() -> socket.socket + UDP_IP = '0.0.0.0' + 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) + return sock + + +@pytest.mark.skip +def test_query_dns_http_service(service): # type: (str) -> None + print('SRV: Query {}'.format(service)) + sock = create_socket() + packet = get_mdns_service_query(service) + for _ in range(RETRY_COUNT): + if esp_service_answered.wait(timeout=25): + break + sock.sendto(packet, (MCAST_GRP, UDP_PORT)) + else: + raise RuntimeError( + 'Test has failed: did not receive mdns answer within timeout') + + +@pytest.mark.skip +def test_query_dns_sub_service(sub_service): # type: (str) -> None + print('PTR: Query {}'.format(sub_service)) + sock = create_socket() + packet = get_mdns_sub_service_query(sub_service) + for _ in range(RETRY_COUNT): + if esp_sub_service_answered.wait(timeout=25): + break + sock.sendto(packet, (MCAST_GRP, UDP_PORT)) + else: + raise RuntimeError( + 'Test has failed: did not receive mdns answer within timeout') + + +@pytest.mark.skip +def test_query_dns_host(esp_host): # type: (str) -> None + print('A: {}'.format(esp_host)) + sock = create_socket() + packet = get_dns_query_for_esp(esp_host) + for _ in range(RETRY_COUNT): + if esp_host_answered.wait(timeout=25): + break + sock.sendto(packet, (MCAST_GRP, UDP_PORT)) + else: + raise RuntimeError( + 'Test has failed: did not receive mdns answer within timeout') + + +@pytest.mark.skip +def test_query_dns_host_delegated(esp_host): # type: (str) -> None + print('A: {}'.format(esp_host)) + sock = create_socket() + packet = get_dns_query_for_esp(esp_host + '-delegated') + for _ in range(RETRY_COUNT): + if esp_delegated_host_answered.wait(timeout=25): + break + sock.sendto(packet, (MCAST_GRP, UDP_PORT)) + else: + raise RuntimeError( + 'Test has failed: did not receive mdns answer within timeout') + + +@pytest.mark.esp32 +@pytest.mark.esp32s2 +@pytest.mark.esp32c3 +@pytest.mark.generic +def test_app_esp_mdns(dut): + + # 1. get the dut host name (and IP address) + specific_host = dut.expect( + re.compile(b'mdns hostname set to: \[([^\]]+)\]'), # noqa: W605 + timeout=30).group(1).decode() + + esp_ip = dut.expect( + re.compile( + b' IPv4 address: ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)'), # noqa: W605 + timeout=30).group(1).decode() + print('Got IP={}'.format(esp_ip)) + + mdns_responder = Thread(target=mdns_listener, args=(str(specific_host), )) + + def start_case(case, desc, result): # type: (str, str, str) -> None + print('Starting {}: {}'.format(case, desc)) + dut.write(case) + res = bytes(result, encoding='utf8') + dut.expect(re.compile(res), timeout=30) + + try: + # start dns listener thread + mdns_responder.start() + + # wait untill mdns listener thred started + if not start_mdns_listener.wait(timeout=5): + raise ValueError( + 'Test has failed: mdns listener thread did not start') + + # query dns service from host, answer should be received from esp board + test_query_dns_http_service(SERVICE_NAME) + + # query dns sub-service from host, answer should be received from esp board + test_query_dns_sub_service(SUB_SERVICE_NAME) + + # query dns host name, answer should be received from esp board + test_query_dns_host(specific_host) + + # query dns host name delegated, answer should be received from esp board + test_query_dns_host_delegated(specific_host) + + # query service from esp board, answer should be received from host + start_case('CONFIG_TEST_QUERY_SERVICE', + 'Query SRV ESP32._http._tcp.local', 'SRV:ESP32') + + # query dns-host from esp board, answer should be received from host + start_case('CONFIG_TEST_QUERY_HOST', 'Query tinytester.local', + 'tinytester.local resolved to: 127.0.0.1') + + # query dns-host aynchrounusely from esp board, answer should be received from host + start_case('CONFIG_TEST_QUERY_HOST_ASYNC', + 'Query tinytester.local async', + 'Async query resolved to A:127.0.0.1') + + finally: + stop_mdns_listener.set() + mdns_responder.join() diff --git a/managed_components/espressif__mdns/tests/test_apps/sdkconfig.ci b/managed_components/espressif__mdns/tests/test_apps/sdkconfig.ci new file mode 100644 index 0000000..d89171d --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_apps/sdkconfig.ci @@ -0,0 +1,13 @@ +CONFIG_IDF_TARGET="esp32" +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 diff --git a/managed_components/espressif__mdns/tests/test_apps/sdkconfig.defaults b/managed_components/espressif__mdns/tests/test_apps/sdkconfig.defaults new file mode 100644 index 0000000..0c4ffe9 --- /dev/null +++ b/managed_components/espressif__mdns/tests/test_apps/sdkconfig.defaults @@ -0,0 +1,2 @@ +CONFIG_TEST_MDNS_ADD_MAC_TO_HOSTNAME=y +CONFIG_TEST_MDNS_PUBLISH_DELEGATE_HOST=y diff --git a/managed_components/espressif__mdns/tests/unit_test/CMakeLists.txt b/managed_components/espressif__mdns/tests/unit_test/CMakeLists.txt new file mode 100644 index 0000000..32bdad8 --- /dev/null +++ b/managed_components/espressif__mdns/tests/unit_test/CMakeLists.txt @@ -0,0 +1,15 @@ +# This is the project CMakeLists.txt file for the test subproject +cmake_minimum_required(VERSION 3.16) + +include($ENV{IDF_PATH}/tools/cmake/project.cmake) + +if("${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR}" VERSION_GREATER_EQUAL "6.0") + set(test_component_dir $ENV{IDF_PATH}/tools/test_apps/components) +else() + set(test_component_dir $ENV{IDF_PATH}/tools/unit-test-app/components) +endif() + +set(EXTRA_COMPONENT_DIRS ../.. + ${test_component_dir}) + +project(mdns_test) diff --git a/managed_components/espressif__mdns/tests/unit_test/main/CMakeLists.txt b/managed_components/espressif__mdns/tests/unit_test/main/CMakeLists.txt new file mode 100644 index 0000000..d04d217 --- /dev/null +++ b/managed_components/espressif__mdns/tests/unit_test/main/CMakeLists.txt @@ -0,0 +1,5 @@ + +idf_component_register(SRCS "test_mdns.c" + REQUIRES test_utils + INCLUDE_DIRS "." + PRIV_REQUIRES unity mdns) diff --git a/managed_components/espressif__mdns/tests/unit_test/main/test_mdns.c b/managed_components/espressif__mdns/tests/unit_test/main/test_mdns.c new file mode 100644 index 0000000..6ad72d6 --- /dev/null +++ b/managed_components/espressif__mdns/tests/unit_test/main/test_mdns.c @@ -0,0 +1,339 @@ +/* + * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Unlicense OR CC0-1.0 + */ + +#include +#include "mdns.h" +#include "esp_event.h" +#include "unity.h" +#include "test_utils.h" + +#include "unity_fixture.h" +#include "memory_checks.h" + +#define MDNS_HOSTNAME "test-hostname" +#define MDNS_DELEGATE_HOSTNAME "delegate-hostname" +#define MDNS_INSTANCE "test-instance" +#define MDNS_SERVICE_NAME "_http" +#define MDNS_SERVICE_PROTO "_tcp" +#define MDNS_SERVICE_PORT 80 + +TEST_GROUP(mdns); + +TEST_SETUP(mdns) +{ + test_utils_record_free_mem(); + TEST_ESP_OK(test_utils_set_leak_level(0, ESP_LEAK_TYPE_CRITICAL, ESP_COMP_LEAK_GENERAL)); +} + +TEST_TEAR_DOWN(mdns) +{ + test_utils_finish_and_evaluate_leaks(32, 64); +} + +static void yield_to_all_priorities(void) +{ + // Lower the test-task priority before testing to ensure other tasks got executed on forced context switch + size_t test_task_prio_before = uxTaskPriorityGet(NULL); + vTaskPrioritySet(NULL, tskIDLE_PRIORITY); + taskYIELD(); // Let the RTOS to switch context + vTaskPrioritySet(NULL, test_task_prio_before); +} + + +TEST(mdns, api_fails_with_invalid_state) +{ + TEST_ASSERT_NOT_EQUAL(ESP_OK, mdns_init()); + TEST_ASSERT_NOT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME)); + TEST_ASSERT_NOT_EQUAL(ESP_OK, mdns_instance_name_set(MDNS_INSTANCE)); + TEST_ASSERT_NOT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0)); +} + +TEST(mdns, init_deinit) +{ + test_case_uses_tcpip(); + TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default()); + TEST_ASSERT_EQUAL(ESP_OK, mdns_init()); + yield_to_all_priorities(); // Make sure that mdns task has executed to complete initialization + mdns_free(); + esp_event_loop_delete_default(); +} + +TEST(mdns, boolean_txt_null_value) +{ + mdns_result_t *results = NULL; + test_case_uses_tcpip(); + TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default()); + TEST_ASSERT_EQUAL(ESP_OK, mdns_init()); + TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME)); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0)); + + mdns_txt_item_t txt_data[] = { + {"bool", NULL}, + {"key", "value"}, + }; + const size_t txt_data_count = sizeof(txt_data) / sizeof(txt_data[0]); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, txt_data, txt_data_count)); + yield_to_all_priorities(); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_NOT_EQUAL(NULL, results->txt); + TEST_ASSERT_EQUAL(txt_data_count, results->txt_count); + + bool found_bool = false; + for (size_t i = 0; i < results->txt_count; ++i) { + if (strcmp(results->txt[i].key, "bool") == 0) { + TEST_ASSERT_NOT_EQUAL(NULL, results->txt_value_len); + TEST_ASSERT_EQUAL_UINT8(0, results->txt_value_len[i]); + found_bool = true; + } + } + TEST_ASSERT_TRUE(found_bool); + mdns_query_results_free(results); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO)); + mdns_free(); + esp_event_loop_delete_default(); +} + +TEST(mdns, api_fails_with_expected_err) +{ + mdns_txt_item_t serviceTxtData[CONFIG_MDNS_MAX_SERVICES] = { {NULL, NULL}, + }; + mdns_ip_addr_t addr; + addr.addr.type = ESP_IPADDR_TYPE_V4; + addr.addr.u_addr.ip4.addr = esp_ip4addr_aton("127.0.0.1"); + addr.next = NULL; + for (int i = 0; i < CONFIG_MDNS_MAX_SERVICES; ++i) { + serviceTxtData[i].key = "Key"; + serviceTxtData[i].value = "Value"; + } + test_case_uses_tcpip(); + TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default()); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_init()); + TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_delegate_hostname_add(MDNS_DELEGATE_HOSTNAME, &addr)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_TRUE(mdns_hostname_exists(MDNS_DELEGATE_HOSTNAME)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_instance_name_set(MDNS_INSTANCE)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, serviceTxtData, CONFIG_MDNS_MAX_SERVICES)); + TEST_ASSERT_FALSE(mdns_service_exists(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add_for_host(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, + MDNS_SERVICE_PORT, serviceTxtData, CONFIG_MDNS_MAX_SERVICES)); + TEST_ASSERT_TRUE(mdns_service_exists(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, serviceTxtData, CONFIG_MDNS_MAX_SERVICES)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_item_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, "key1", "value1")); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_item_remove(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, "key1")); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_port_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 8080)); + yield_to_all_priorities(); // to remove the service with the updated txt records + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO)); + yield_to_all_priorities(); // Make sure that mdns task has executed to remove the service + + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_delegate_hostname_remove(MDNS_DELEGATE_HOSTNAME)); + yield_to_all_priorities(); // Make sure that mdns task has executed to remove the hostname + TEST_ASSERT_FALSE(mdns_service_exists(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove_all()); + yield_to_all_priorities(); // Make sure that mdns task has executed to remove all services + + TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, mdns_service_port_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 8080)); + + mdns_free(); + esp_event_loop_delete_default(); +} + +TEST(mdns, query_api_fails_with_expected_err) +{ + mdns_result_t *results = NULL; + esp_ip6_addr_t addr6; + esp_ip4_addr_t addr4; + test_case_uses_tcpip(); + TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default()); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_init()); + // check it is not possible to register a service or set an instance without configuring the hostname + TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0)); + TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, mdns_instance_name_set(MDNS_INSTANCE)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME)); + // hostname is set, now adding a service and instance should succeed + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_instance_name_set(MDNS_INSTANCE)); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_query_ptr(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 10, CONFIG_MDNS_MAX_SERVICES, &results)); + mdns_query_results_free(results); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_query_srv(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 10, &results)); + mdns_query_results_free(results); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_query_txt(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 10, &results)); + mdns_query_results_free(results); + + TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, mdns_query_a(MDNS_HOSTNAME, 10, &addr4)); + mdns_query_results_free(results); + + TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, mdns_query_aaaa(MDNS_HOSTNAME, 10, &addr6)); + mdns_query_results_free(results); + + mdns_free(); + esp_event_loop_delete_default(); +} + +TEST(mdns, add_remove_service) +{ + mdns_result_t *results = NULL; + test_case_uses_tcpip(); + TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default()); + TEST_ASSERT_EQUAL(ESP_OK, mdns_init()); + TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT, NULL, 0)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE, results->instance_name); + TEST_ASSERT_EQUAL_STRING(MDNS_SERVICE_NAME, results->service_type); + TEST_ASSERT_EQUAL(MDNS_SERVICE_PORT, results->port); + TEST_ASSERT_EQUAL(NULL, results->txt); + mdns_query_results_free(results); + + // Update service properties: port + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_port_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_SERVICE_PORT + 1)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_EQUAL(MDNS_SERVICE_PORT + 1, results->port); + mdns_query_results_free(results); + + // Update service properties: instance + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_instance_name_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_INSTANCE "1")); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(MDNS_INSTANCE "1", MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE "1", results->instance_name); + mdns_query_results_free(results); + + // Update service properties: txt + mdns_txt_item_t txt_data[] = { + {"key1", "esp32"}, + {"key2", "value"}, + {"key3", "value3"}, + }; + const size_t txt_data_cout = sizeof(txt_data) / sizeof(txt_data[0]); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_set(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, txt_data, txt_data_cout)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_NOT_EQUAL(NULL, results->txt); + TEST_ASSERT_EQUAL(txt_data_cout, results->txt_count); + // compare txt values by keys + size_t matches = 0; + for (int i = 0; i < results->txt_count; ++i) // iterates over the results we get from mdns_lookup() + for (int j = 0; j < txt_data_cout; ++j) // iterates over our test records + if (strcmp(results->txt[i].key, txt_data[j].key) == 0) { // we compare the value only if the key matches + TEST_ASSERT_EQUAL_STRING(results->txt[i].value, txt_data[j].value); + ++matches; + } + TEST_ASSERT_EQUAL(txt_data_cout, matches); // checks that we went over all our txt items + mdns_query_results_free(results); + + // Now remove the service + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove(MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_selfhosted_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_EQUAL(NULL, results); + + mdns_free(); + esp_event_loop_delete_default(); +} + +TEST(mdns, add_remove_deleg_service) +{ + mdns_ip_addr_t addr; + addr.addr.type = ESP_IPADDR_TYPE_V4; + addr.addr.u_addr.ip4.addr = esp_ip4addr_aton("127.0.0.1"); + addr.next = NULL; + mdns_result_t *results = NULL; + test_case_uses_tcpip(); + TEST_ASSERT_EQUAL(ESP_OK, esp_event_loop_create_default()); + TEST_ASSERT_EQUAL(ESP_OK, mdns_init()); + TEST_ASSERT_EQUAL(ESP_OK, mdns_hostname_set(MDNS_HOSTNAME)); + TEST_ASSERT_EQUAL(ESP_OK, mdns_delegate_hostname_add(MDNS_DELEGATE_HOSTNAME, &addr)); + + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_add_for_host(MDNS_INSTANCE, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, MDNS_SERVICE_PORT, NULL, 0)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE, results->instance_name); + TEST_ASSERT_EQUAL_STRING(MDNS_SERVICE_NAME, results->service_type); + TEST_ASSERT_EQUAL(MDNS_SERVICE_PORT, results->port); + TEST_ASSERT_EQUAL(NULL, results->txt); + mdns_query_results_free(results); + + // Update service properties: port + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_port_set_for_host(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, MDNS_SERVICE_PORT + 1)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_EQUAL(MDNS_SERVICE_PORT + 1, results->port); + mdns_query_results_free(results); + + // Update service properties: instance + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_instance_name_set_for_host(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, MDNS_INSTANCE "1")); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(MDNS_INSTANCE "1", MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_EQUAL_STRING(MDNS_INSTANCE "1", results->instance_name); + mdns_query_results_free(results); + + // Update service properties: txt + mdns_txt_item_t txt_data[] = { + {"key1", "esp32"}, + {"key2", "value"}, + }; + const size_t txt_data_cout = sizeof(txt_data) / sizeof(txt_data[0]); + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_txt_set_for_host(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME, txt_data, txt_data_cout)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_NOT_EQUAL(NULL, results); + TEST_ASSERT_NOT_EQUAL(NULL, results->txt); + TEST_ASSERT_EQUAL(txt_data_cout, results->txt_count); + // compare txt values by keys + size_t matches = 0; + for (int i = 0; i < results->txt_count; ++i) // iterates over the results we get from mdns_lookup() + for (int j = 0; j < txt_data_cout; ++j) // iterates over our test records + if (strcmp(results->txt[i].key, txt_data[j].key) == 0) { // we compare the value only if the key matches + TEST_ASSERT_EQUAL_STRING(results->txt[i].value, txt_data[j].value); + ++matches; + } + TEST_ASSERT_EQUAL(txt_data_cout, matches); // checks that we went over all our txt items + mdns_query_results_free(results); + + // Now remove the service + TEST_ASSERT_EQUAL(ESP_OK, mdns_service_remove_for_host(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, MDNS_DELEGATE_HOSTNAME)); + yield_to_all_priorities(); // Make sure that mdns task has executed to add the hostname + TEST_ASSERT_EQUAL(ESP_OK, mdns_lookup_delegated_service(NULL, MDNS_SERVICE_NAME, MDNS_SERVICE_PROTO, 1, &results)); + TEST_ASSERT_EQUAL(NULL, results); + + mdns_free(); + esp_event_loop_delete_default(); +} +TEST_GROUP_RUNNER(mdns) +{ + RUN_TEST_CASE(mdns, api_fails_with_invalid_state) + RUN_TEST_CASE(mdns, api_fails_with_expected_err) + RUN_TEST_CASE(mdns, query_api_fails_with_expected_err) + RUN_TEST_CASE(mdns, init_deinit) + RUN_TEST_CASE(mdns, add_remove_service) + RUN_TEST_CASE(mdns, add_remove_deleg_service) + RUN_TEST_CASE(mdns, boolean_txt_null_value) + +} + +void app_main(void) +{ + UNITY_MAIN(mdns); +} diff --git a/managed_components/espressif__mdns/tests/unit_test/pytest_app_mdns.py b/managed_components/espressif__mdns/tests/unit_test/pytest_app_mdns.py new file mode 100644 index 0000000..5106112 --- /dev/null +++ b/managed_components/espressif__mdns/tests/unit_test/pytest_app_mdns.py @@ -0,0 +1,8 @@ +# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD +# SPDX-License-Identifier: Apache-2.0 + +from pytest_embedded import Dut + + +def test_mdns(dut: Dut) -> None: + dut.expect_unity_test_output() diff --git a/managed_components/espressif__mdns/tests/unit_test/sdkconfig.ci b/managed_components/espressif__mdns/tests/unit_test/sdkconfig.ci new file mode 100644 index 0000000..9660719 --- /dev/null +++ b/managed_components/espressif__mdns/tests/unit_test/sdkconfig.ci @@ -0,0 +1,3 @@ +CONFIG_IDF_TARGET="esp32" +CONFIG_UNITY_ENABLE_FIXTURE=y +CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=n diff --git a/managed_components/espressif__mdns/tests/unit_test/sdkconfig.defaults b/managed_components/espressif__mdns/tests/unit_test/sdkconfig.defaults new file mode 100644 index 0000000..168e08d --- /dev/null +++ b/managed_components/espressif__mdns/tests/unit_test/sdkconfig.defaults @@ -0,0 +1,2 @@ +CONFIG_UNITY_ENABLE_FIXTURE=y +CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=n diff --git a/sdkconfig b/sdkconfig index cb24599..ce23047 100644 --- a/sdkconfig +++ b/sdkconfig @@ -1803,6 +1803,45 @@ CONFIG_I2CDEV_TIMEOUT=1000 # CONFIG_I2CDEV_NOLOCK is not set # end of I2C Device Library +# +# mDNS +# +CONFIG_MDNS_MAX_INTERFACES=3 +CONFIG_MDNS_MAX_SERVICES=10 +CONFIG_MDNS_TASK_PRIORITY=1 +CONFIG_MDNS_ACTION_QUEUE_LEN=16 +CONFIG_MDNS_TASK_STACK_SIZE=4096 +# CONFIG_MDNS_TASK_AFFINITY_NO_AFFINITY is not set +CONFIG_MDNS_TASK_AFFINITY_CPU0=y +# CONFIG_MDNS_TASK_AFFINITY_CPU1 is not set +CONFIG_MDNS_TASK_AFFINITY=0x0 + +# +# MDNS Memory Configuration +# +CONFIG_MDNS_TASK_CREATE_FROM_INTERNAL=y +CONFIG_MDNS_MEMORY_ALLOC_INTERNAL=y +# CONFIG_MDNS_MEMORY_CUSTOM_IMPL is not set +# end of MDNS Memory Configuration + +CONFIG_MDNS_SERVICE_ADD_TIMEOUT_MS=2000 +CONFIG_MDNS_TIMER_PERIOD_MS=100 +# CONFIG_MDNS_NETWORKING_SOCKET is not set +# CONFIG_MDNS_SKIP_SUPPRESSING_OWN_QUERIES is not set +# CONFIG_MDNS_ENABLE_DEBUG_PRINTS is not set +CONFIG_MDNS_ENABLE_CONSOLE_CLI=y +# CONFIG_MDNS_RESPOND_REVERSE_QUERIES is not set +CONFIG_MDNS_MULTIPLE_INSTANCE=y + +# +# MDNS Predefined interfaces +# +CONFIG_MDNS_PREDEF_NETIF_STA=y +CONFIG_MDNS_PREDEF_NETIF_AP=y +CONFIG_MDNS_PREDEF_NETIF_ETH=y +# end of MDNS Predefined interfaces +# end of mDNS + # # LittleFS #