new upgrade

2025-12-21 23:28:26 +00:00
parent 82fa194bd8
commit 023644a887
99 changed files with 7457 additions and 7079 deletions
--- a/components/logger/include/logger.h
+++ b/components/logger/include/logger.h
@@ -3,56 +3,45 @@

 #include <stdint.h>
 #include <stdbool.h>
+#include <stdarg.h>
+
 #include "freertos/FreeRTOS.h"
 #include "freertos/event_groups.h"

-#define LOGGER_SERIAL_BIT       BIT0
+#ifdef __cplusplus
+extern "C"
+{
+#endif

-/**
- * @brief Logger event group LOGGER_SERIAL_BIT
- * 
- */
-extern EventGroupHandle_t logger_event_group;
+#define LOGGER_SERIAL_BIT BIT0

-/**
- * @brief Initialize logger
- * 
- */
-void logger_init(void);
+    extern EventGroupHandle_t logger_event_group;

-/**
- * @brief Print
- * 
- * @param str 
- */
-void logger_print(const char* str);
+    void logger_init(void);

-/**
- * @brief Print va
- * 
- * @param str 
- * @param l 
- * @return int 
- */
-int logger_vprintf(const char* str, va_list l);
+    void logger_print(const char *str);

-/**
- * @brief Get entries count
- * 
- * @return uint16_t 
- */
-uint16_t logger_count(void);
+    int logger_vprintf(const char *fmt, va_list args);

-/**
- * @brief Read line from index, set index for reading next entry
- * 
- * @param index 
- * @param str 
- * @param v 
- * @return true When has next entry
- * @return false When no entry left
- */
-bool logger_read(uint16_t *index, char **str, uint16_t* len);
+    uint16_t logger_count(void);

+    // opcional: quantas mensagens foram dropadas por contenção de mutex
+    uint32_t logger_dropped_count(void);

-#endif /* LOGGER_H_ */
+    /**
+     * ⚠️ API antiga (não recomendada): devolve ponteiro interno.
+     * Pode ficar inválido se houver novas escritas/rotação.
+     */
+    bool logger_read(uint16_t *index, char **str, uint16_t *len);
+
+    /**
+     * ✅ API recomendada: copia a entrada para buffer do caller (safe).
+     * out é sempre terminado com '\0' (se out_sz > 0).
+     */
+    bool logger_read_copy(uint16_t *index, char *out, uint16_t out_sz, uint16_t *out_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOGGER_H_ */
--- a/components/logger/include/output_buffer.h
+++ b/components/logger/include/output_buffer.h
@@ -4,21 +4,31 @@
 #include <stdint.h>
 #include <stdbool.h>

-typedef struct {
-    uint16_t size;
-    uint16_t count;    
-    uint8_t* data;    
-    uint8_t* append;
-} output_buffer_t;
+#ifdef __cplusplus
+extern "C"
+{
+#endif

-output_buffer_t* output_buffer_create(uint16_t size);
+    typedef struct
+    {
+        uint16_t size;
+        uint16_t count;
+        uint8_t *data;
+        uint8_t *append;
+    } output_buffer_t;

-void output_buffer_delete(output_buffer_t* buffer);
+    output_buffer_t *output_buffer_create(uint16_t size);

-void output_buffer_append_buf(output_buffer_t* buffer, const char* buf, uint16_t len);
+    void output_buffer_delete(output_buffer_t *buffer);

-void output_buffer_append_str(output_buffer_t* buffer, const char* str);
+    void output_buffer_append_buf(output_buffer_t *buffer, const char *buf, uint16_t len);

-bool output_buffer_read(output_buffer_t* buffer, uint16_t *index, char **str, uint16_t* len);
+    void output_buffer_append_str(output_buffer_t *buffer, const char *str);

-#endif /* OUTPUT_BUFFER_H_ */
+    bool output_buffer_read(output_buffer_t *buffer, uint16_t *index, char **str, uint16_t *len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OUTPUT_BUFFER_H_ */
--- a/components/logger/src/logger.c
+++ b/components/logger/src/logger.c
@@ -1,66 +1,155 @@
 #include <stdio.h>
-#include <memory.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
 #include <sys/param.h>
+
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"

 #include "logger.h"
 #include "output_buffer.h"

-#define LOG_BUFFER_SIZE     6096 //4096
-#define MAX_LOG_SIZE        512
+#define LOG_BUFFER_SIZE 6096 // tamanho total do buffer circular
+#define MAX_LOG_SIZE    256  // ✅ reduzir stack/CPU; era 512

-
-static SemaphoreHandle_t mutex;
-
-static output_buffer_t * buffer = NULL;
+static SemaphoreHandle_t mutex = NULL;
+static output_buffer_t *buffer = NULL;

 EventGroupHandle_t logger_event_group = NULL;

+// opcional: contador de mensagens dropadas quando mutex está ocupado
+static volatile uint32_t s_dropped = 0;
+
 void logger_init(void)
 {
+    // Permitir múltiplas chamadas seguras
+    if (mutex != NULL)
+    {
+        return;
+    }
+
    mutex = xSemaphoreCreateMutex();
+    configASSERT(mutex != NULL);
+
    logger_event_group = xEventGroupCreate();
+    configASSERT(logger_event_group != NULL);

    buffer = output_buffer_create(LOG_BUFFER_SIZE);
+    configASSERT(buffer != NULL);
 }

 uint16_t logger_count(void)
 {
-    return buffer->count;
+    if (!mutex || !buffer)
+    {
+        return 0;
+    }
+
+    // ✅ não bloquear para sempre (mas aqui pode bloquear sem stress)
+    xSemaphoreTake(mutex, portMAX_DELAY);
+    uint16_t c = buffer->count;
+    xSemaphoreGive(mutex);
+
+    return c;
 }

-void logger_print(const char* str)
+uint32_t logger_dropped_count(void)
 {
-    xSemaphoreTake(mutex, portMAX_DELAY);
+    return s_dropped;
+}
+
+void logger_print(const char *str)
+{
+    if (!str || !mutex || !buffer)
+    {
+        return;
+    }
+
+    // Limitar comprimento para evitar entradas enormes
+    size_t len = strlen(str);
+    if (len > (MAX_LOG_SIZE - 1))
+    {
+        len = MAX_LOG_SIZE - 1;
+    }
+
+    // ✅ NÃO bloquear aqui: se o mutex estiver ocupado, dropa
+    if (xSemaphoreTake(mutex, 0) != pdTRUE)
+    {
+        s_dropped++;
+        return;
+    }
+
+    output_buffer_append_buf(buffer, str, (uint16_t)len);
+    xEventGroupSetBits(logger_event_group, LOGGER_SERIAL_BIT);

-    output_buffer_append_str(buffer, str);
-    xEventGroupSetBits(logger_event_group, 0xFF);
-  
    xSemaphoreGive(mutex);
 }

-int logger_vprintf(const char* str, va_list l)
+int logger_vprintf(const char *fmt, va_list args)
 {
+    char log_buf[MAX_LOG_SIZE];
+
 #ifdef CONFIG_ESP_CONSOLE_UART
-    vprintf(str, l);
+    // Duplicar va_list para ecoar na UART sem consumir o original
+    va_list args_copy;
+    va_copy(args_copy, args);
+    vprintf(fmt, args_copy);
+    va_end(args_copy);
 #endif

-    xSemaphoreTake(mutex, portMAX_DELAY);
+    // Se ainda não inicializado, apenas formatar para devolver comprimento
+    if (!mutex || !buffer)
+    {
+        int len = vsnprintf(log_buf, MAX_LOG_SIZE, fmt, args);
+        if (len < 0)
+        {
+            len = 0;
+        }
+        else if (len >= MAX_LOG_SIZE)
+        {
+            len = MAX_LOG_SIZE - 1;
+        }
+        return len;
+    }

-    static char log[MAX_LOG_SIZE];
-    int len = vsnprintf(log, MAX_LOG_SIZE, str, l);
+    int len = vsnprintf(log_buf, MAX_LOG_SIZE, fmt, args);
+    if (len < 0)
+    {
+        len = 0;
+    }
+    else if (len >= MAX_LOG_SIZE)
+    {
+        len = MAX_LOG_SIZE - 1;
+    }

-    output_buffer_append_buf(buffer, log, len);
-    xEventGroupSetBits(logger_event_group, 0xFF);
+    // ✅ NÃO bloquear o sistema (sys_evt/httpd/wifi/etc) por causa de log
+    if (xSemaphoreTake(mutex, 0) != pdTRUE)
+    {
+        s_dropped++;
+        return len;
+    }
+
+    output_buffer_append_buf(buffer, log_buf, (uint16_t)len);
+    xEventGroupSetBits(logger_event_group, LOGGER_SERIAL_BIT);

    xSemaphoreGive(mutex);

    return len;
 }

-bool logger_read(uint16_t* index, char** str, uint16_t* len)
+/**
+ * ⚠️ API antiga: devolve ponteiro interno do buffer.
+ * Só é segura se o caller COPIAR imediatamente e garantir que não há novas escritas.
+ * Recomendo usar logger_read_copy().
+ */
+bool logger_read(uint16_t *index, char **str, uint16_t *len)
 {
+    if (!mutex || !buffer || !index || !str || !len)
+    {
+        return false;
+    }
+
    xSemaphoreTake(mutex, portMAX_DELAY);

    bool has_next = output_buffer_read(buffer, index, str, len);
@@ -68,4 +157,36 @@ bool logger_read(uint16_t* index, char** str, uint16_t* len)
    xSemaphoreGive(mutex);

    return has_next;
-}
+}
+
+// ✅ API segura: copia a linha para buffer do caller (evita ponteiro ficar inválido após rotação)
+bool logger_read_copy(uint16_t *index, char *out, uint16_t out_sz, uint16_t *out_len)
+{
+    if (!mutex || !buffer || !index || !out || out_sz == 0)
+    {
+        return false;
+    }
+
+    xSemaphoreTake(mutex, portMAX_DELAY);
+
+    char *ptr = NULL;
+    uint16_t len = 0;
+    bool ok = output_buffer_read(buffer, index, &ptr, &len);
+    if (!ok)
+    {
+        xSemaphoreGive(mutex);
+        return false;
+    }
+
+    uint16_t n = (len < (out_sz - 1)) ? len : (out_sz - 1);
+    memcpy(out, ptr, n);
+    out[n] = '\0';
+
+    if (out_len)
+    {
+        *out_len = n;
+    }
+
+    xSemaphoreGive(mutex);
+    return true;
+}
--- a/components/logger/src/output_buffer.c
+++ b/components/logger/src/output_buffer.c
@@ -1,86 +1,217 @@
-#include <memory.h>
+#include <stdlib.h>
+#include <string.h>

 #include "output_buffer.h"

-
-output_buffer_t* output_buffer_create(uint16_t size)
+output_buffer_t *output_buffer_create(uint16_t size)
 {
-    output_buffer_t* buffer = (output_buffer_t*)malloc(sizeof(output_buffer_t));
+    if (size == 0)
+    {
+        return NULL;
+    }
+
+    output_buffer_t *buffer = (output_buffer_t *)malloc(sizeof(output_buffer_t));
+    if (!buffer)
+    {
+        return NULL;
+    }
+
+    buffer->data = (uint8_t *)malloc((size_t)size);
+    if (!buffer->data)
+    {
+        free(buffer);
+        return NULL;
+    }

    buffer->size = size;
    buffer->count = 0;
-    buffer->data = (uint8_t*)malloc(sizeof(uint8_t) * size);
    buffer->append = buffer->data;

    return buffer;
 }

-void output_buffer_delete(output_buffer_t* buffer)
+void output_buffer_delete(output_buffer_t *buffer)
 {
-    free((void*)buffer->data);
-    free((void*)buffer);
+    if (!buffer)
+    {
+        return;
+    }
+
+    if (buffer->data)
+    {
+        free((void *)buffer->data);
+        buffer->data = NULL;
+    }
+
+    free((void *)buffer);
 }

-void output_buffer_append_buf(output_buffer_t* buffer, const char* str, uint16_t len)
+void output_buffer_append_buf(output_buffer_t *buffer, const char *str, uint16_t len)
 {
-    if (((buffer->append - buffer->data) + sizeof(uint16_t) + len) >= buffer->size) {
-        //rotate buffer
-        uint8_t* pos = buffer->data;
+    if (!buffer || !buffer->data || !str || len == 0)
+    {
+        return;
+    }
+
+    // Garantir que nunca escrevemos entradas absurdamente grandes
+    if (len > buffer->size / 2)
+    {
+        // Tamanho de entrada demasiado grande para a lógica de rotação;
+        // corta-a para caber de forma segura.
+        len = buffer->size / 2;
+    }
+
+    size_t used = (size_t)(buffer->append - buffer->data);
+    if (used > buffer->size)
+    {
+        // Estado incoerente: reset defensivo
+        buffer->append = buffer->data;
+        buffer->count = 0;
+        used = 0;
+    }
+
+    // Se não couber mais esta entrada, rodar o buffer
+    if (used + sizeof(uint16_t) + len > buffer->size)
+    {
+        uint8_t *pos = buffer->data;
        uint16_t rotate_count = 0;
-        while ((pos - buffer->data) < buffer->size / 2) {
-            //seek first half
+        uint8_t *end = buffer->data + buffer->size;
+
+        // Avança entradas até aproximadamente metade do buffer
+        while ((pos + sizeof(uint16_t)) < end &&
+               (size_t)(pos - buffer->data) < buffer->size / 2)
+        {
+
            uint16_t entry_len;
-            memcpy((void*)&entry_len, (void*)pos, sizeof(uint16_t));
-            pos += entry_len + sizeof(uint16_t);
+            memcpy(&entry_len, pos, sizeof(uint16_t));
+
+            // Sanitizar entry_len para evitar corrupções
+            if (entry_len == 0 || entry_len > buffer->size)
+            {
+                // Corrompido → reset defensivo
+                pos = buffer->data;
+                rotate_count = 0;
+                buffer->count = 0;
+                break;
+            }
+
+            if (pos + sizeof(uint16_t) + entry_len > end)
+            {
+                // Entrada incompleta na cauda → para por aqui
+                break;
+            }
+
+            pos += sizeof(uint16_t) + entry_len;
            rotate_count++;
        }

-        memmove((void*)buffer->data, (void*)pos, buffer->size - (pos - buffer->data));
-        buffer->count -= rotate_count;
-        buffer->append -= (pos - buffer->data);
+        // Compacta o que sobrou para o início
+        size_t remaining = (size_t)(end - pos);
+        memmove(buffer->data, pos, remaining);
+
+        buffer->count = (buffer->count >= rotate_count) ? (buffer->count - rotate_count) : 0;
+        buffer->append = buffer->data + remaining;
+
+        used = (size_t)(buffer->append - buffer->data);
    }

-    memcpy((void*)buffer->append, (void*)&len, sizeof(uint16_t));
+    // Escreve [len][dados]
+    memcpy(buffer->append, &len, sizeof(uint16_t));
    buffer->append += sizeof(uint16_t);

-    memcpy((void*)buffer->append, (void*)str, len);
+    memcpy(buffer->append, str, len);
    buffer->append += len;

    buffer->count++;
 }

-void output_buffer_append_str(output_buffer_t* buffer, const char* str)
+void output_buffer_append_str(output_buffer_t *buffer, const char *str)
 {
-    output_buffer_append_buf(buffer, str, strlen(str));
+    if (!buffer || !str)
+    {
+        return;
+    }
+
+    size_t len = strlen(str);
+    if (len == 0)
+    {
+        return;
+    }
+
+    // A API pública em logger.c já limita o tamanho, mas aqui fazemos
+    // um clamp defensivo para o caso de uso direto.
+    if (len > UINT16_MAX)
+    {
+        len = UINT16_MAX;
+    }
+
+    output_buffer_append_buf(buffer, str, (uint16_t)len);
 }

-bool output_buffer_read(output_buffer_t* buffer, uint16_t* index, char** str, uint16_t* len)
+bool output_buffer_read(output_buffer_t *buffer, uint16_t *index, char **str, uint16_t *len)
 {
-    if (*index > buffer->count) {
+    if (!buffer || !buffer->data || !index || !str || !len)
+    {
+        return false;
+    }
+
+    if (*index > buffer->count)
+    {
        *index = buffer->count;
    }

-    bool has_next = false;
-
-    if (*index < buffer->count) {
-        uint8_t* pos = buffer->data;
-        uint16_t current = 0;
-
-        while (current != *index) {
-            uint16_t entry_len;
-            memcpy((void*)&entry_len, (void*)pos, sizeof(uint16_t));
-            pos += entry_len + sizeof(uint16_t);
-            current++;
-        }
-
-        memcpy((void*)len, (void*)pos, sizeof(uint16_t));
-        pos += sizeof(uint16_t);
-        *str = (char*)pos;
-
-        (*index)++;
-
-        has_next = true;
+    if (*index >= buffer->count)
+    {
+        return false;
    }

-    return has_next;
-}
+    uint8_t *pos = buffer->data;
+    uint8_t *end = buffer->data + buffer->size;
+    uint16_t current = 0;
+
+    // Avança até à entrada [*index]
+    while (current < *index)
+    {
+        if (pos + sizeof(uint16_t) > end)
+        {
+            // Dados corrompidos ou índice fora → fail-safe
+            return false;
+        }
+
+        uint16_t entry_len;
+        memcpy(&entry_len, pos, sizeof(uint16_t));
+
+        if (entry_len == 0 || entry_len > buffer->size)
+        {
+            // Corrompido → aborta
+            return false;
+        }
+
+        if (pos + sizeof(uint16_t) + entry_len > end)
+        {
+            return false;
+        }
+
+        pos += sizeof(uint16_t) + entry_len;
+        current++;
+    }
+
+    // Agora pos aponta para o len da entrada desejada
+    if (pos + sizeof(uint16_t) > end)
+    {
+        return false;
+    }
+
+    memcpy(len, pos, sizeof(uint16_t));
+    pos += sizeof(uint16_t);
+
+    if (pos + *len > end)
+    {
+        return false;
+    }
+
+    *str = (char *)pos;
+    (*index)++;
+
+    return true;
+}