misc fixes

Author: jaylikesbunda

CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## v1.7.0
+
+- Fixed cancel button in confirmation dialogs returning to main menu instead of the correct sub-menu
+- Fixed `clear_pcap_files` not resetting the `HasOpenedFile` flag after closing the file handle, causing silent write failures on active captures
+- Fixed app crashing the entire device on SD card mkdir failure, now exits gracefully instead
+- Removed dead null check in `settings_storage_init` that could never be reached
+- Fixed sync timing counters never resetting between capture sessions
+- Fixed IR universals list query failing on slow UART connections due to using a fixed 200ms delay instead of a proper timeout loop
+- Fixed app info dialog showing empty text
+- Removed unreachable return statement in `settings_custom_event_callback`
+- Fixed critical resource leak on text_box allocation failure, early return now properly cleans up UART context, expansion protocol, OTG state and all allocated memory
+- Fixed NULL pointer dereference in `uart_storage_rx_callback` when `app` is NULL
+- Fixed memory leak in `show_app_info`, confirmation context now tracked in `active_confirm_context`
+- Fixed `SETTING_SHOW_INFO` event handler returning `false` instead of `true`
+- Fixed `show_confirmation_dialog_ex` overwriting `active_confirm_context` without freeing previous allocation
+- Fixed memory leak in `get_latest_log_file` on `realloc` failure
+- Fixed race condition in UART cleanup, capture streams now cleaned after thread join
+- Fixed missing NULL checks on `storage_file_alloc` in file clearing functions
+- Fixed missing NULL check on `context` in `show_app_info`
+- Fixed error path in core UI allocation leaking `RECORD_DIALOGS`, expansion protocol and OTG power state
+
 ## v1.6.3
 
 - Fixed an issue where the text view would be empty

src/callbacks.c

@@ -199,12 +199,18 @@ void nvs_clear_cancelled_callback(void* context) {
     }
 }
 void show_app_info(void* context) {
+    if(!context) return;
     SettingsUIContext* settings_context = (SettingsUIContext*)context;
     AppState* app = (AppState*)settings_context->context;
 
     FURI_LOG_D("AppInfo", "Show app info called, context: %p", app);
 
-    const char* info_text = "";
+    const char* info_text = "Created by: Spooky\n"
+                            "Updated by:\n"
+                            "@jaylikesbunda\n"
+                            "@tototo31\n"
+                            "Built with <3\n"
+                            "github.com/jaylikesbunda/ghost_esp\n\n";
 
     if(app && app->confirmation_view) {
         // Create a new context for the confirmation dialog
@@ -214,6 +220,7 @@ void show_app_info(void* context) {
             return;
         }
         confirm_ctx->state = app;
+        app->active_confirm_context = confirm_ctx;
 
         // Save current view before switching
         app->previous_view = app->current_view;

src/log_manager.c

@@ -75,7 +75,9 @@ bool get_latest_log_file(Storage* storage, const char* dir, const char* prefix,
             files_capacity *= 2;
             LogFile* new_files = realloc(files, sizeof(LogFile) * files_capacity);
             if(!new_files) {
-                // Handle realloc failure
+                for(size_t j = 0; j < files_count; j++) {
+                    free(files[j].filename);
+                }
                 free(files);
                 free(filename);
                 storage_dir_close(dir_handle);

src/main.c

@@ -26,7 +26,6 @@
 #include "app_state.h"
 
 // Include the header where settings_custom_event_callback is declared
-#include "settings_ui.h"
 
 #define UART_INIT_STACK_SIZE 2048
 #define UART_INIT_TIMEOUT_MS 1500 // ms
@@ -89,12 +88,17 @@ int32_t ghost_esp_app(void* p) {
     state->view_dispatcher = view_dispatcher_alloc();
     state->main_menu = main_menu_alloc();
     if(!state->view_dispatcher || !state->main_menu) {
-        // Clean up and exit if core components fail
         if(state->view_dispatcher) view_dispatcher_free(state->view_dispatcher);
         if(state->main_menu) main_menu_free(state->main_menu);
+        if(state->dialogs) furi_record_close(RECORD_DIALOGS);
         free(state->textBoxBuffer);
         free(state->input_buffer);
         free(state);
+        expansion_enable(expansion);
+        furi_record_close(RECORD_EXPANSION);
+        if(furi_hal_power_is_otg_enabled() && !otg_was_enabled) {
+            furi_hal_power_disable_otg();
+        }
         return -1;
     }
 
@@ -247,7 +251,7 @@ int32_t ghost_esp_app(void* p) {
 
     if(!state->text_box) {
         FURI_LOG_E("Main", "Text box allocation failed!");
-        return -1; // Don't try to fuck with broken UI
+        goto cleanup;
     }
 
     text_view_attach_input_handler(state);
@@ -268,6 +272,7 @@ int32_t ghost_esp_app(void* p) {
         view_dispatcher_run(state->view_dispatcher);
     }
 
+cleanup:
     // ---- Start Cleanup Sequence ----
     FURI_LOG_I("Ghost_ESP", "Starting cleanup sequence...");
 
@@ -291,7 +296,6 @@ int32_t ghost_esp_app(void* p) {
     // Clean up UART context (this will also handle storage cleanup)
     if(state && state->uart_context) {
         FURI_LOG_I("Ghost_ESP", "Freeing UART context...");
-        uart_cleanup_capture_streams(state->uart_context); // Ensure capture streams are freed
         uart_free(state->uart_context);
         state->uart_context = NULL;
         FURI_LOG_I("Ghost_ESP", "UART context freed.");

src/menu.c

@@ -1714,13 +1714,24 @@ static bool ir_query_and_parse_universals(AppState* state) {
 
     uart_reset_text_buffers(state->uart_context);
     send_uart_command("ir universals list\n", state);
-    furi_delay_ms(200);
 
     char buffer[IR_UART_PARSE_BUF_SIZE];
 
     size_t len = 0;
-    if(!uart_copy_text_buffer_tail(state->uart_context, buffer, IR_UART_PARSE_BUF_SIZE, &len) ||
-       len == 0) {
+    uint32_t start = furi_get_tick();
+    const uint32_t timeout_ms = 3000;
+    while(furi_get_tick() - start < timeout_ms) {
+        furi_delay_ms(100);
+        if(uart_copy_text_buffer_tail(state->uart_context, buffer, IR_UART_PARSE_BUF_SIZE, &len) &&
+           len > 0) {
+            if(strstr(buffer, "Universal Files in ") || strstr(buffer, "Built-in") ||
+               strstr(buffer, "(none)") || strchr(buffer, '.')) {
+                break;
+            }
+        }
+    }
+
+    if(len == 0) {
         return false;
     }
 
@@ -2026,19 +2037,64 @@ static void confirmation_ok_callback(void* context) {
 static void confirmation_cancel_callback(void* context) {
     MenuCommandContext* cmd_ctx = context;
     if(cmd_ctx && cmd_ctx->state) {
-        cmd_ctx->state->active_confirm_context = NULL;
-        switch(cmd_ctx->state->previous_view) {
+        AppState* s = cmd_ctx->state;
+        s->active_confirm_context = NULL;
+        uint32_t pv = s->previous_view;
+        switch(pv) {
         case 1:
-            show_wifi_menu(cmd_ctx->state);
+            show_wifi_menu(s);
+            submenu_set_selected_item(s->wifi_menu, s->last_wifi_category_index);
+            break;
+        case 10:
+            show_wifi_scanning_menu(s);
+            submenu_set_selected_item(s->wifi_scanning_menu, s->last_wifi_scanning_index);
+            break;
+        case 11:
+            show_wifi_capture_menu(s);
+            submenu_set_selected_item(s->wifi_capture_menu, s->last_wifi_capture_index);
+            break;
+        case 12:
+            show_wifi_attack_menu(s);
+            submenu_set_selected_item(s->wifi_attack_menu, s->last_wifi_attack_index);
+            break;
+        case 13:
+            show_wifi_network_menu(s);
+            submenu_set_selected_item(s->wifi_network_menu, s->last_wifi_network_index);
+            break;
+        case 14:
+            show_wifi_settings_menu(s);
+            submenu_set_selected_item(s->wifi_settings_menu, s->last_wifi_settings_index);
             break;
         case 2:
-            show_ble_menu(cmd_ctx->state);
+            show_ble_menu(s);
+            submenu_set_selected_item(s->ble_menu, s->last_ble_category_index);
+            break;
+        case 20:
+            show_ble_scanning_menu(s);
+            submenu_set_selected_item(s->ble_scanning_menu, s->last_ble_scanning_index);
+            break;
+        case 21:
+            show_ble_capture_menu(s);
+            submenu_set_selected_item(s->ble_capture_menu, s->last_ble_capture_index);
+            break;
+        case 22:
+            show_ble_attack_menu(s);
+            submenu_set_selected_item(s->ble_attack_menu, s->last_ble_attack_index);
             break;
         case 3:
-            show_gps_menu(cmd_ctx->state);
+            show_gps_menu(s);
+            submenu_set_selected_item(s->gps_menu, s->last_gps_index);
+            break;
+        case 15:
+            show_aerial_menu(s);
+            submenu_set_selected_item(s->aerial_menu, s->last_aerial_category_index);
+            break;
+        case 30:
+            show_ir_menu(s);
+            submenu_set_selected_item(s->ir_menu, s->last_ir_index);
             break;
         default:
-            show_main_menu(cmd_ctx->state);
+            show_main_menu(s);
             break;
         }
     }

src/settings_storage.c

@@ -24,18 +24,16 @@ bool settings_storage_init() {
 
     // Attempt to create directory without checking if it exists
     if(!storage_simply_mkdir(storage, GHOST_ESP_APP_FOLDER)) {
-        furi_crash("Can't mkdir! Fuck this SD card!");
+        FURI_LOG_E("SettingsStorage", "Failed to create app directory");
+        furi_record_close(RECORD_STORAGE);
+        storage = NULL;
+        return false;
     }
 
     uint32_t duration = furi_get_tick() - start_time;
     FURI_LOG_I(
         "SettingsStorage", "Storage initialization complete (Time taken: %lu ms)", duration);
 
-    if(!storage) {
-        FURI_LOG_E("Storage", "Storage system failure!");
-        furi_crash("Storage fucked");
-    }
-
     return true;
 }
 

src/settings_ui.c

@@ -49,6 +49,11 @@ void clear_log_files(void* context) {
     // Open storage once
     Storage* storage = furi_record_open(RECORD_STORAGE);
     File* dir = storage_file_alloc(storage);
+    if(!dir) {
+        furi_record_close(RECORD_STORAGE);
+        create_new_log(app);
+        return;
+    }
 
     if(!storage_dir_open(dir, GHOST_ESP_APP_FOLDER_LOGS)) {
         FURI_LOG_E("ClearLogs", "Failed to open logs directory");
@@ -87,7 +92,11 @@ void clear_pcap_files(void* context) {
     // Close current file if open
     if(app->uart_context && app->uart_context->storageContext &&
        app->uart_context->storageContext->current_file) {
-        storage_file_close(app->uart_context->storageContext->current_file);
+        if(storage_file_is_open(app->uart_context->storageContext->current_file)) {
+            storage_file_sync(app->uart_context->storageContext->current_file);
+            storage_file_close(app->uart_context->storageContext->current_file);
+        }
+        app->uart_context->storageContext->HasOpenedFile = false;
     }
 
     // Stack allocation for better performance
@@ -99,6 +108,10 @@ void clear_pcap_files(void* context) {
     // Open storage once
     Storage* storage = furi_record_open(RECORD_STORAGE);
     File* dir = storage_file_alloc(storage);
+    if(!dir) {
+        furi_record_close(RECORD_STORAGE);
+        return;
+    }
 
     if(!storage_dir_open(dir, GHOST_ESP_APP_FOLDER_PCAPS)) {
         FURI_LOG_E("ClearPCAPs", "Failed to open pcaps directory");
@@ -137,6 +150,10 @@ void clear_wardrive_files(void* context) {
     // Open storage once
     Storage* storage = furi_record_open(RECORD_STORAGE);
     File* dir = storage_file_alloc(storage);
+    if(!dir) {
+        furi_record_close(RECORD_STORAGE);
+        return;
+    }
 
     if(!storage_dir_open(dir, GHOST_ESP_APP_FOLDER_WARDRIVE)) {
         FURI_LOG_E("ClearWardrive", "Failed to open wardrive directory");
@@ -581,13 +598,12 @@ bool settings_custom_event_callback(void* context, uint32_t event_id) {
 
         view_dispatcher_switch_to_view(app_state->view_dispatcher, 7);
         app_state->current_view = 7;
-        break;
+        return true;
     }
 
     default:
         return false;
     }
-    return false;
 }
 
 // 6675636B796F7564656B69

src/uart_storage.c

@@ -205,7 +205,7 @@ void uart_storage_rx_callback(uint8_t* buf, size_t len, void* context) {
             "Storage",
             "Invalid parameters in storage callback: app=%p, storageContext=%p, buf=%p, len=%zu",
             (void*)app,
-            (void*)app->storageContext,
+            app ? (void*)app->storageContext : NULL,
             (void*)buf,
             len);
         return;
@@ -247,8 +247,14 @@ void uart_storage_rx_callback(uint8_t* buf, size_t len, void* context) {
     }
     FURI_LOG_D("Storage", "Data Checksum (XOR): 0x%02X", checksum);
 
-    // Periodic sync every ~8KB to balance between safety and performance with detailed logging
+    // Periodic sync every ~8KB to balance between safety and performance
     static size_t bytes_since_sync = 0;
+
+    // Reset counter if this is the first write to a new file session
+    if(bytes_since_sync > 8192 && app->storageContext->HasOpenedFile) {
+        bytes_since_sync = 0;
+    }
+
     bytes_since_sync += len;
     FURI_LOG_D("Storage", "Accumulated %zu bytes since last sync", bytes_since_sync);
     if(bytes_since_sync >= 8192) {

src/uart_utils.c

@@ -367,6 +367,10 @@ void handle_uart_rx_data(uint8_t* buf, size_t len, void* context) {
        state->uart_context->storageContext->HasOpenedFile) {
         static size_t bytes_since_sync = 0;
 
+        if(bytes_since_sync > 1024 && state->uart_context->storageContext->HasOpenedFile) {
+            bytes_since_sync = 0;
+        }
+
         size_t written =
             storage_file_write(state->uart_context->storageContext->log_file, buf, len);
 

src/utils.c

@@ -48,6 +48,9 @@ void show_confirmation_dialog_ex(
     }
 
     confirm_ctx->state = state;
+    if(state->active_confirm_context) {
+        free(state->active_confirm_context);
+    }
     state->active_confirm_context = confirm_ctx;
 
     // Set up the confirmation dialog