/* * iperf.c * * Copyright (c) 2025 Umber Networks & Robert McMahon * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the copyright holder nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /** * @file iperf.c * @brief ESP32 iPerf Traffic Generator (UDP Client Only) * * This module implements a lightweight UDP traffic generator compatible with iPerf2. * It features: * - Precise packet pacing (PPS) using monotonic timers (drift-free). * - Finite State Machine (FSM) to detect stalls and slow links. * - Non-Volatile Storage (NVS) for persistent configuration. * - Detailed error tracking (ENOMEM vs Route errors). * - GPS Timestamp integration for status reporting. */ #include #include #include #include #include #include #include #include #include #include #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "freertos/event_groups.h" #include "esp_log.h" #include "esp_err.h" #include "esp_timer.h" #include "nvs_flash.h" #include "nvs.h" #include "esp_event.h" #include "esp_netif.h" #include "esp_wifi.h" #include "iperf.h" #include "status_led.h" #include "gps_sync.h" static const char *TAG = "iperf"; // --- NVS Keys --- #define NVS_KEY_IPERF_ENABLE "iperf_enabled" #define NVS_KEY_IPERF_PPS "iperf_pps" #define NVS_KEY_IPERF_ROLE "iperf_role" #define NVS_KEY_IPERF_DST_IP "iperf_dst_ip" #define NVS_KEY_IPERF_PORT "iperf_port" #define NVS_KEY_IPERF_PROTO "iperf_proto" #define NVS_KEY_IPERF_BURST "iperf_burst" #define NVS_KEY_IPERF_LEN "iperf_len" // --- Global Config State --- static iperf_cfg_t s_staging_cfg = {0}; static bool s_staging_initialized = false; static EventGroupHandle_t s_iperf_event_group = NULL; #define IPERF_IP_READY_BIT (1 << 0) #define IPERF_STOP_REQ_BIT (1 << 1) #define RATE_CHECK_INTERVAL_US 500000 #define MIN_PACING_INTERVAL_US 100 // --- Runtime Control --- typedef struct { iperf_cfg_t cfg; bool finish; uint32_t buffer_len; uint8_t *buffer; } iperf_ctrl_t; static iperf_ctrl_t s_iperf_ctrl = {0}; static TaskHandle_t s_iperf_task_handle = NULL; static bool s_reload_req = false; // Global Stats Tracker static iperf_stats_t s_stats = {0}; static int64_t s_session_start_time = 0; static int64_t s_session_end_time = 0; // --- FSM State & Stats --- typedef enum { IPERF_STATE_IDLE = 0, IPERF_STATE_TX, IPERF_STATE_TX_SLOW, IPERF_STATE_TX_STALLED } iperf_fsm_state_t; static iperf_fsm_state_t s_current_fsm_state = IPERF_STATE_IDLE; static int64_t s_time_tx_us = 0; static int64_t s_time_slow_us = 0; static int64_t s_time_stalled_us = 0; static uint32_t s_edge_tx = 0; static uint32_t s_edge_slow = 0; static uint32_t s_edge_stalled = 0; static esp_event_handler_instance_t instance_any_id; static esp_event_handler_instance_t instance_got_ip; // --- Packet Structures --- typedef struct { int32_t id; uint32_t tv_sec; uint32_t tv_usec; int32_t id2; } udp_datagram; typedef struct { int32_t flags; int32_t numThreads; int32_t mPort; int32_t mBufLen; int32_t mWinBand; int32_t mAmount; } client_hdr_v1; // --- Helper: Defaults --- static void set_defaults(iperf_cfg_t *cfg) { memset(cfg, 0, sizeof(iperf_cfg_t)); cfg->flag = IPERF_FLAG_CLIENT | IPERF_FLAG_UDP; cfg->dip = 0; cfg->dport = IPERF_DEFAULT_PORT; cfg->target_pps = 100; cfg->burst_count = 1; cfg->send_len = IPERF_UDP_TX_LEN; } // --- Parameter Management --- static void trim_whitespace(char *str) { char *end = str + strlen(str) - 1; while(end > str && isspace((unsigned char)*end)) end--; *(end+1) = 0; } void iperf_param_clear(void) { nvs_handle_t h; if (nvs_open("storage", NVS_READWRITE, &h) == ESP_OK) { nvs_erase_key(h, NVS_KEY_IPERF_PPS); nvs_erase_key(h, NVS_KEY_IPERF_BURST); nvs_erase_key(h, NVS_KEY_IPERF_LEN); nvs_erase_key(h, NVS_KEY_IPERF_PORT); nvs_erase_key(h, NVS_KEY_IPERF_DST_IP); nvs_commit(h); nvs_close(h); ESP_LOGI(TAG, "iPerf NVS configuration cleared."); } set_defaults(&s_staging_cfg); } void iperf_param_init(void) { if (s_staging_initialized) return; set_defaults(&s_staging_cfg); nvs_handle_t h; if (nvs_open("storage", NVS_READONLY, &h) == ESP_OK) { ESP_LOGI(TAG, "Loading saved config from NVS..."); uint32_t val; if (nvs_get_u32(h, NVS_KEY_IPERF_PPS, &val) == ESP_OK && val > 0) s_staging_cfg.target_pps = val; if (nvs_get_u32(h, NVS_KEY_IPERF_BURST, &val) == ESP_OK) s_staging_cfg.burst_count = val; if (nvs_get_u32(h, NVS_KEY_IPERF_LEN, &val) == ESP_OK) s_staging_cfg.send_len = val; if (nvs_get_u32(h, NVS_KEY_IPERF_PORT, &val) == ESP_OK) s_staging_cfg.dport = (uint16_t)val; size_t req; if (nvs_get_str(h, NVS_KEY_IPERF_DST_IP, NULL, &req) == ESP_OK) { char *ip_str = malloc(req); if (ip_str) { nvs_get_str(h, NVS_KEY_IPERF_DST_IP, ip_str, &req); trim_whitespace(ip_str); s_staging_cfg.dip = inet_addr(ip_str); free(ip_str); } } nvs_close(h); } s_staging_initialized = true; } void iperf_param_get(iperf_cfg_t *out_cfg) { if (!s_staging_initialized) iperf_param_init(); *out_cfg = s_staging_cfg; } void iperf_param_set(const iperf_cfg_t *new_cfg) { if (!s_staging_initialized) iperf_param_init(); s_staging_cfg = *new_cfg; if (s_iperf_task_handle) { ESP_LOGI(TAG, "Hot reloading parameters..."); s_iperf_ctrl.cfg = s_staging_cfg; s_reload_req = true; if (s_iperf_event_group) xEventGroupSetBits(s_iperf_event_group, IPERF_STOP_REQ_BIT); } } bool iperf_param_is_unsaved(void) { if (!s_staging_initialized) return false; nvs_handle_t h; if (nvs_open("storage", NVS_READONLY, &h) != ESP_OK) return false; uint32_t val; bool match = true; if (nvs_get_u32(h, NVS_KEY_IPERF_PPS, &val) == ESP_OK) { if (s_staging_cfg.target_pps != val) match = false; } else if (s_staging_cfg.target_pps != 100) match = false; // ... nvs_close(h); return !match; } esp_err_t iperf_param_save(bool *out_changed) { if (out_changed) *out_changed = false; nvs_handle_t h; if (nvs_open("storage", NVS_READWRITE, &h) != ESP_OK) return ESP_FAIL; nvs_set_u32(h, NVS_KEY_IPERF_PPS, s_staging_cfg.target_pps); nvs_set_u32(h, NVS_KEY_IPERF_BURST, s_staging_cfg.burst_count); nvs_set_u32(h, NVS_KEY_IPERF_LEN, s_staging_cfg.send_len); nvs_set_u32(h, NVS_KEY_IPERF_PORT, s_staging_cfg.dport); char ip_str[32]; struct in_addr daddr; daddr.s_addr = s_staging_cfg.dip; inet_ntop(AF_INET, &daddr, ip_str, sizeof(ip_str)); nvs_set_str(h, NVS_KEY_IPERF_DST_IP, ip_str); esp_err_t err = nvs_commit(h); if (err == ESP_OK && out_changed) *out_changed = true; nvs_close(h); return err; } // --- Status --- void iperf_get_stats(iperf_stats_t *stats) { if (stats) { s_stats.config_pps = s_iperf_ctrl.cfg.target_pps; *stats = s_stats; } } void iperf_print_status(void) { iperf_get_stats(&s_stats); gps_timestamp_t ts = gps_get_timestamp(); if (ts.synced && ts.gps_us > 0) { time_t now_sec = ts.gps_us / 1000000; struct tm tm_info; gmtime_r(&now_sec, &tm_info); char time_buf[64]; strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S UTC", &tm_info); printf("TIME: %s\n", time_buf); } else { printf("TIME: \n"); } char dst_ip[32] = "0.0.0.0"; struct in_addr daddr; if (s_stats.running) daddr.s_addr = s_iperf_ctrl.cfg.dip; else daddr.s_addr = s_staging_cfg.dip; inet_ntop(AF_INET, &daddr, dst_ip, sizeof(dst_ip)); double total_us = (double)(s_time_tx_us + s_time_slow_us + s_time_stalled_us); if (total_us < 1.0) total_us = 1.0; double pct_tx = ((double)s_time_tx_us / total_us) * 100.0; double pct_slow = ((double)s_time_slow_us / total_us) * 100.0; double pct_stalled = ((double)s_time_stalled_us / total_us) * 100.0; float avg_bw_mbps = 0.0f; if (s_session_start_time > 0) { int64_t end_t = (s_stats.running) ? esp_timer_get_time() : s_session_end_time; if (end_t > s_session_start_time) { double duration_sec = (double)(end_t - s_session_start_time) / 1000000.0; if (duration_sec > 0.001) { double total_bits = (double)s_stats.total_packets * (double)s_iperf_ctrl.cfg.send_len * 8.0; avg_bw_mbps = (float)(total_bits / duration_sec / 1000000.0); } } } printf("IPERF: Dest=%s:%u, Pkts=%llu, BW=%.2f Mbps, Running=%d\n", dst_ip, s_stats.running ? s_iperf_ctrl.cfg.dport : s_staging_cfg.dport, s_stats.total_packets, avg_bw_mbps, s_stats.running); printf("STATES: TX=%.2fs/%.1f%% (%lu), SLOW=%.2fs/%.1f%% (%lu), STALLED=%.2fs/%.1f%% (%lu)\n", (double)s_time_tx_us/1000000.0, pct_tx, (unsigned long)s_edge_tx, (double)s_time_slow_us/1000000.0, pct_slow, (unsigned long)s_edge_slow, (double)s_time_stalled_us/1000000.0, pct_stalled, (unsigned long)s_edge_stalled); if (s_stats.err_mem > 0 || s_stats.err_route > 0 || s_stats.err_other > 0) { printf("ERRORS: ENOMEM=%lu, EHOST=%lu, OTHER=%lu\n", (unsigned long)s_stats.err_mem, (unsigned long)s_stats.err_route, (unsigned long)s_stats.err_other); } } // --- Core Logic --- static void iperf_pattern(uint8_t *buf, uint32_t len) { for (uint32_t i = 0; i < len; i++) buf[i] = (i % 10) + '0'; } static void iperf_generate_client_hdr(iperf_cfg_t *cfg, client_hdr_v1 *hdr) { memset(hdr, 0, sizeof(client_hdr_v1)); hdr->flags = htonl(0x08000000); // HEADER_SEQNO64B } static void iperf_network_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) { if (s_iperf_event_group == NULL) return; if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) { xEventGroupSetBits(s_iperf_event_group, IPERF_IP_READY_BIT); } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) { xEventGroupClearBits(s_iperf_event_group, IPERF_IP_READY_BIT); // --- ADDED: Set Yellow on Disconnect --- status_led_set_state(LED_STATE_NO_CONFIG); } } static bool iperf_wait_for_ip(void) { if (!s_iperf_event_group) s_iperf_event_group = xEventGroupCreate(); esp_netif_t *netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF"); if (netif) { esp_netif_ip_info_t ip_info; if (esp_netif_get_ip_info(netif, &ip_info) == ESP_OK && ip_info.ip.addr != 0) return true; } ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &iperf_network_event_handler, NULL, &instance_any_id)); ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &iperf_network_event_handler, NULL, &instance_got_ip)); // --- ADDED: Set Blue Blink while waiting --- status_led_set_state(LED_STATE_WAITING); ESP_LOGI(TAG, "Waiting for IP..."); EventBits_t bits = xEventGroupWaitBits(s_iperf_event_group, IPERF_IP_READY_BIT | IPERF_STOP_REQ_BIT, pdFALSE, pdFALSE, portMAX_DELAY); esp_event_handler_instance_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, instance_any_id); esp_event_handler_instance_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, instance_got_ip); if (bits & IPERF_STOP_REQ_BIT) return false; return true; } static esp_err_t iperf_start_udp_client(iperf_ctrl_t *ctrl) { // Note: status_led_set_state(LED_STATE_WAITING) happens inside if needed if (!iperf_wait_for_ip()) return ESP_OK; struct sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_port = htons(ctrl->cfg.dport); addr.sin_addr.s_addr = ctrl->cfg.dip; int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (sockfd < 0) { ESP_LOGE(TAG, "Socket failed: %d", errno); status_led_set_state(LED_STATE_FAILED); // Red Blink on Error return ESP_FAIL; } // --- Set Purple Slow Pulse (Starting) --- status_led_set_state(LED_STATE_TRANSMITTING_SLOW); udp_datagram *udp_hdr = (udp_datagram *)ctrl->buffer; client_hdr_v1 *client_hdr = (client_hdr_v1 *)(ctrl->buffer + sizeof(udp_datagram)); iperf_generate_client_hdr(&ctrl->cfg, client_hdr); s_stats.running = true; s_stats.err_mem = 0; s_stats.err_route = 0; s_stats.err_other = 0; s_stats.total_packets = 0; s_session_start_time = esp_timer_get_time(); s_time_tx_us = 0; s_time_slow_us = 0; s_time_stalled_us = 0; s_edge_tx = 0; s_edge_slow = 0; s_edge_stalled = 0; s_current_fsm_state = IPERF_STATE_IDLE; ESP_LOGI(TAG, "UDP Started. Target: %s", inet_ntoa(addr.sin_addr)); int64_t next_send_time = esp_timer_get_time(); int64_t last_rate_check = esp_timer_get_time(); uint32_t packets_since_check = 0; int64_t packet_id = 0; struct timespec ts; uint32_t period_us = (ctrl->cfg.target_pps > 0) ? (1000000 / ctrl->cfg.target_pps) : 10000; if (period_us < MIN_PACING_INTERVAL_US) period_us = MIN_PACING_INTERVAL_US; while (!ctrl->finish && !s_reload_req) { int64_t now = esp_timer_get_time(); int64_t wait = next_send_time - now; if (wait > 2000) vTaskDelay(pdMS_TO_TICKS(wait / 1000)); while (esp_timer_get_time() < next_send_time) taskYIELD(); if (xEventGroupGetBits(s_iperf_event_group) & IPERF_STOP_REQ_BIT) break; for (int k = 0; k < ctrl->cfg.burst_count; k++) { int64_t current_id = packet_id++; udp_hdr->id = htonl((uint32_t)(current_id & 0xFFFFFFFF)); udp_hdr->id2 = htonl((uint32_t)((current_id >> 32) & 0xFFFFFFFF)); clock_gettime(CLOCK_REALTIME, &ts); udp_hdr->tv_sec = htonl((uint32_t)ts.tv_sec); udp_hdr->tv_usec = htonl(ts.tv_nsec / 1000); int ret = sendto(sockfd, ctrl->buffer, ctrl->cfg.send_len, 0, (struct sockaddr *)&addr, sizeof(addr)); if (ret > 0) { s_stats.total_packets++; packets_since_check++; } else { if (errno == ENOMEM) s_stats.err_mem++; else { if (errno == EHOSTUNREACH) s_stats.err_route++; else s_stats.err_other++; vTaskDelay(pdMS_TO_TICKS(10)); } } } now = esp_timer_get_time(); if (now - last_rate_check > RATE_CHECK_INTERVAL_US) { uint32_t interval_us = (uint32_t)(now - last_rate_check); if (interval_us > 0) { s_stats.actual_pps = (uint32_t)((uint64_t)packets_since_check * 1000000 / interval_us); uint32_t threshold = (ctrl->cfg.target_pps * 3) / 4; iperf_fsm_state_t next_state; if (s_stats.actual_pps == 0) next_state = IPERF_STATE_TX_STALLED; else if (s_stats.actual_pps >= threshold) next_state = IPERF_STATE_TX; else next_state = IPERF_STATE_TX_SLOW; switch (next_state) { case IPERF_STATE_TX: s_time_tx_us += interval_us; break; case IPERF_STATE_TX_SLOW: s_time_slow_us += interval_us; break; case IPERF_STATE_TX_STALLED: s_time_stalled_us += interval_us; break; default: break; } if (next_state != s_current_fsm_state) { switch (next_state) { case IPERF_STATE_TX: s_edge_tx++; break; case IPERF_STATE_TX_SLOW: s_edge_slow++; break; case IPERF_STATE_TX_STALLED: s_edge_stalled++; break; default: break; } s_current_fsm_state = next_state; } led_state_t led_target = LED_STATE_TRANSMITTING; if (next_state == IPERF_STATE_TX_SLOW) led_target = LED_STATE_TRANSMITTING_SLOW; if (next_state == IPERF_STATE_TX_STALLED) led_target = LED_STATE_STALLED; status_led_set_state(led_target); } last_rate_check = now; packets_since_check = 0; } next_send_time += period_us; } int64_t final_id = -packet_id; udp_hdr->id = htonl((uint32_t)(final_id & 0xFFFFFFFF)); udp_hdr->id2 = htonl((uint32_t)((final_id >> 32) & 0xFFFFFFFF)); clock_gettime(CLOCK_REALTIME, &ts); udp_hdr->tv_sec = htonl((uint32_t)ts.tv_sec); udp_hdr->tv_usec = htonl(ts.tv_nsec / 1000); for (int i=0; i<10; i++) { sendto(sockfd, ctrl->buffer, ctrl->cfg.send_len, 0, (struct sockaddr *)&addr, sizeof(addr)); vTaskDelay(pdMS_TO_TICKS(2)); } ESP_LOGI(TAG, "Sent termination (ID: %" PRId64 ")", final_id); close(sockfd); s_stats.running = false; s_session_end_time = esp_timer_get_time(); status_led_set_state(LED_STATE_CONNECTED); return ESP_OK; } static void iperf_task(void *arg) { iperf_ctrl_t *ctrl = (iperf_ctrl_t *)arg; while (1) { s_reload_req = false; ctrl->finish = false; xEventGroupClearBits(s_iperf_event_group, IPERF_STOP_REQ_BIT); iperf_start_udp_client(ctrl); if (s_reload_req) { ESP_LOGI(TAG, "Task reloading config..."); if (ctrl->buffer_len < ctrl->cfg.send_len + 128) { free(ctrl->buffer); ctrl->buffer_len = ctrl->cfg.send_len + 128; ctrl->buffer = calloc(1, ctrl->buffer_len); iperf_pattern(ctrl->buffer, ctrl->buffer_len); } } else { break; } } free(ctrl->buffer); s_iperf_task_handle = NULL; vTaskDelete(NULL); } void iperf_start(void) { if (!s_staging_initialized) iperf_param_init(); if (s_iperf_task_handle) { ESP_LOGW(TAG, "Already running. Use 'set' to update parameters."); return; } s_iperf_ctrl.cfg = s_staging_cfg; s_iperf_ctrl.finish = false; s_iperf_ctrl.buffer_len = s_iperf_ctrl.cfg.send_len + 128; s_iperf_ctrl.buffer = calloc(1, s_iperf_ctrl.buffer_len); if (s_iperf_ctrl.buffer) { iperf_pattern(s_iperf_ctrl.buffer, s_iperf_ctrl.buffer_len); } if (s_iperf_event_group == NULL) s_iperf_event_group = xEventGroupCreate(); xTaskCreate(iperf_task, "iperf", 4096, &s_iperf_ctrl, 5, &s_iperf_task_handle); } void iperf_stop(void) { if (s_iperf_task_handle) { s_iperf_ctrl.finish = true; if (s_iperf_event_group) xEventGroupSetBits(s_iperf_event_group, IPERF_STOP_REQ_BIT); } }