feat: Add optional Perfect Forward Secrecy for direct messages

.gitignore

@@ -50,3 +50,4 @@ idf_component.yml
 CMakeLists.txt
 sdkconfig.*
 .dummy/*
+CONTEXT.md

src/DebugConfiguration.cpp

@@ -112,6 +112,13 @@ bool Syslog::isEnabled()
     return this->_enabled;
 }
 
+bool Syslog::isConnected()
+{
+    // For UDP syslog, "connected" means enabled and properly configured
+    // (UDP is connectionless, so we check if we could potentially send)
+    return this->_enabled && this->_port != 0 && (this->_server != NULL || this->_ip != INADDR_NONE);
+}
+
 bool Syslog::vlogf(uint16_t pri, const char *fmt, va_list args)
 {
     return this->vlogf(pri, this->_appName, fmt, args);

src/DebugConfiguration.h

@@ -190,6 +190,7 @@ class Syslog
     void enable();
     void disable();
     bool isEnabled();
+    bool isConnected();
 
     bool vlogf(uint16_t pri, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));
     bool vlogf(uint16_t pri, const char *appName, const char *fmt, va_list args) __attribute__((format(printf, 3, 0)));

src/concurrency/BinarySemaphorePosix.cpp

@@ -3,6 +3,79 @@
 
 #ifndef HAS_FREE_RTOS
 
+#ifdef ARCH_PORTDUINO
+// Full pthread implementation for Linux/native builds
+#include <errno.h>
+#include <sys/time.h>
+
+namespace concurrency
+{
+
+BinarySemaphorePosix::BinarySemaphorePosix() : signaled(false)
+{
+    pthread_mutex_init(&mutex, NULL);
+    pthread_cond_init(&cond, NULL);
+}
+
+BinarySemaphorePosix::~BinarySemaphorePosix()
+{
+    pthread_cond_destroy(&cond);
+    pthread_mutex_destroy(&mutex);
+}
+
+/**
+ * Block until signaled or timeout expires.
+ * Returns true if we were signaled, false if we timed out.
+ */
+bool BinarySemaphorePosix::take(uint32_t msec)
+{
+    struct timespec ts;
+    struct timeval tv;
+
+    gettimeofday(&tv, NULL);
+    ts.tv_sec = tv.tv_sec + (msec / 1000);
+    ts.tv_nsec = (tv.tv_usec * 1000) + ((msec % 1000) * 1000000);
+    if (ts.tv_nsec >= 1000000000) {
+        ts.tv_sec++;
+        ts.tv_nsec -= 1000000000;
+    }
+
+    pthread_mutex_lock(&mutex);
+
+    while (!signaled) {
+        int rc = pthread_cond_timedwait(&cond, &mutex, &ts);
+        if (rc == ETIMEDOUT) {
+            pthread_mutex_unlock(&mutex);
+            return false;
+        }
+    }
+
+    signaled = false;
+    pthread_mutex_unlock(&mutex);
+    return true;
+}
+
+void BinarySemaphorePosix::give()
+{
+    pthread_mutex_lock(&mutex);
+    signaled = true;
+    pthread_cond_signal(&cond);
+    pthread_mutex_unlock(&mutex);
+}
+
+IRAM_ATTR void BinarySemaphorePosix::giveFromISR(BaseType_t *pxHigherPriorityTaskWoken)
+{
+    // POSIX doesn't distinguish ISR context; delegate to regular give()
+    give();
+    if (pxHigherPriorityTaskWoken) {
+        *pxHigherPriorityTaskWoken = 1; // Equivalent to pdTRUE in FreeRTOS
+    }
+}
+
+} // namespace concurrency
+
+#else
+// Stub implementation for non-FreeRTOS, non-POSIX platforms (e.g., STM32)
 namespace concurrency
 {
 
@@ -15,7 +88,7 @@ BinarySemaphorePosix::~BinarySemaphorePosix() {}
  */
 bool BinarySemaphorePosix::take(uint32_t msec)
 {
-    delay(msec); // FIXME
+    delay(msec); // FIXME - proper implementation needs platform-specific support
     return false;
 }
 
@@ -25,4 +98,6 @@ IRAM_ATTR void BinarySemaphorePosix::giveFromISR(BaseType_t *pxHigherPriorityTas
 
 } // namespace concurrency
 
-#endif
+#endif // ARCH_PORTDUINO
+
+#endif // !HAS_FREE_RTOS

src/concurrency/BinarySemaphorePosix.h

@@ -2,14 +2,22 @@
 
 #include "../freertosinc.h"
 
+#ifdef ARCH_PORTDUINO
+#include <pthread.h>
+#endif
+
 namespace concurrency
 {
 
 #ifndef HAS_FREE_RTOS
 
 class BinarySemaphorePosix
 {
-    // SemaphoreHandle_t semaphore;
+#ifdef ARCH_PORTDUINO
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    bool signaled;
+#endif
 
   public:
     BinarySemaphorePosix();