@alteriom/painlessmesh 1.6.1

package/src/painlessmesh/base64.hpp

@@ -0,0 +1,111 @@
+#ifndef _PAINLESS_MESH_BASE64_HPP_
+#define _PAINLESS_MESH_BASE64_HPP_
+
+#include <string>
+
+#include "painlessmesh/configuration.hpp"
+
+namespace painlessmesh {
+namespace base64 {
+
+static inline bool is_base64(unsigned char c) {
+  return (isalnum(c) || (c == '+') || (c == '/'));
+}
+
+static const TSTRING chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz"
+    "0123456789+/";
+
+inline TSTRING encode(unsigned char const* bytes_to_encode,
+                      unsigned int in_len) {
+  TSTRING ret;
+  int i = 0;
+  int j = 0;
+  unsigned char char_array_3[3];
+  unsigned char char_array_4[4];
+
+  while (in_len--) {
+    char_array_3[i++] = *(bytes_to_encode++);
+    if (i == 3) {
+      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+      char_array_4[1] =
+          ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+      char_array_4[2] =
+          ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+      char_array_4[3] = char_array_3[2] & 0x3f;
+
+      for (i = 0; (i < 4); i++) ret += chars[char_array_4[i]];
+      i = 0;
+    }
+  }
+
+  if (i) {
+    for (j = i; j < 3; j++) char_array_3[j] = '\0';
+
+    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+    char_array_4[1] =
+        ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+    char_array_4[2] =
+        ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+    char_array_4[3] = char_array_3[2] & 0x3f;
+    for (j = 0; (j < i + 1); j++) ret += chars[char_array_4[j]];
+    while ((i++ < 3)) ret += '=';
+  }
+
+  return ret;
+}
+
+inline TSTRING encode(const TSTRING& str64) {
+  return encode((unsigned char*)str64.c_str(), str64.length());
+}
+
+static const int B64index[256] = {
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  0,  0,  0,  0,  0,  62, 63, 62, 62, 63, 52, 53, 54, 55, 56, 57,
+    58, 59, 60, 61, 0,  0,  0,  0,  0,  0,  0,  0,  1,  2,  3,  4,  5,  6,
+    7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+    25, 0,  0,  0,  0,  63, 0,  26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+    37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51};
+
+inline const TSTRING decode(const void* data, const size_t& len) {
+  if (len == 0) return "";
+
+  unsigned char* p = (unsigned char*)data;
+  size_t j = 0, pad1 = len % 4 || p[len - 1] == '=',
+         pad2 = pad1 && (len % 4 > 2 || p[len - 2] != '=');
+  const size_t last = (len - pad1) / 4 << 2;
+#ifdef PAINLESSMESH_ENABLE_STD_STRING
+  TSTRING result(last / 4 * 3 + pad1 + pad2, '\0');
+#else
+  TSTRING result;
+  result.reserve(last / 4 * 3 + pad1 + pad2);
+  for (size_t i = 0; i < last / 4 * 3 + pad1 + pad2; ++i) result.concat('\0');
+#endif
+  unsigned char* str = (unsigned char*)&result[0];
+
+  for (size_t i = 0; i < last; i += 4) {
+    int n = B64index[p[i]] << 18 | B64index[p[i + 1]] << 12 |
+            B64index[p[i + 2]] << 6 | B64index[p[i + 3]];
+    str[j++] = n >> 16;
+    str[j++] = n >> 8 & 0xFF;
+    str[j++] = n & 0xFF;
+  }
+  if (pad1) {
+    int n = B64index[p[last]] << 18 | B64index[p[last + 1]] << 12;
+    str[j++] = n >> 16;
+    if (pad2) {
+      n |= B64index[p[last + 2]] << 6;
+      str[j++] = n >> 8 & 0xFF;
+    }
+  }
+  return result;
+}
+
+inline TSTRING decode(const TSTRING& str64) {
+  return decode(str64.c_str(), str64.length());
+}
+}  // namespace base64
+}  // namespace painlessmesh
+#endif

package/src/painlessmesh/buffer.hpp

@@ -0,0 +1,229 @@
+#ifndef _PAINLESS_MESH_BUFFER_HPP_
+#define _PAINLESS_MESH_BUFFER_HPP_
+
+#include <list>
+
+#include "Arduino.h"
+#include "painlessmesh/configuration.hpp"
+
+#ifndef TCP_MSS
+#define TCP_MSS 1024
+#endif
+
+namespace painlessmesh {
+namespace buffer {
+
+// Temporary buffer used by ReceiveBuffer and SentBuffer
+struct temp_buffer_t {
+  size_t length = TCP_MSS;
+  char buffer[TCP_MSS];
+};
+
+/**
+ * \brief ReceivedBuffer handles cstrings and stores them as strings
+ */
+template <class T>
+class ReceiveBuffer {
+ public:
+  ReceiveBuffer() { buffer = T(); }
+
+  /**
+   * Push a message into the buffer
+   */
+  void push(const char *cstr, size_t length, temp_buffer_t &buf) {
+    auto data_ptr = cstr;
+    do {
+      auto len = strnlen(data_ptr, length);
+      do {
+        auto read_len = std::min(len, buf.length);
+        memcpy(buf.buffer, data_ptr, read_len);
+        buf.buffer[read_len] = '\0';
+        auto newBuffer = T(buf.buffer);
+        stringAppend(buffer, newBuffer);
+        len -= newBuffer.length();
+        length -= newBuffer.length();
+        data_ptr += newBuffer.length() * sizeof(char);
+      } while (len > 0);
+      if (length > 0) {
+        // Skip/remove the '\0' between the messages
+        length -= 1;
+        data_ptr += 1 * sizeof(char);
+        if (buffer.length() > 0) {  // skip empty buffers
+          jsonStrings.push_back(buffer);
+          buffer = T();
+        }
+      }
+    } while (length > 0);
+  }
+
+  /**
+   * Get the oldest message from the buffer
+   */
+  T front() {
+    if (!empty()) return jsonStrings.front();
+    return T();
+  }
+
+  /**
+   * Remove the oldest message from the buffer
+   */
+  void pop_front() { jsonStrings.pop_front(); }
+
+  /**
+   * Is the buffer empty
+   */
+  bool empty() { return jsonStrings.empty(); }
+
+  /**
+   * Clear the buffer
+   */
+  void clear() {
+    jsonStrings.clear();
+    buffer = T();
+  }
+
+ private:
+  T buffer;
+  std::list<T> jsonStrings;
+
+  /**
+   * Helper function to deal with difference Arduino String
+   * and std::string
+   */
+  inline void stringAppend(T &buffer, T &newBuffer) {
+    buffer.concat(newBuffer);
+  };
+};
+
+#ifdef PAINLESSMESH_ENABLE_STD_STRING
+template <>
+inline void ReceiveBuffer<std::string>::stringAppend(std::string &buffer,
+                                                     std::string &newBuffer) {
+  buffer.append(newBuffer);
+}
+#endif
+
+/**
+ * \brief SentBuffer stores messages (strings) and allows them to be read in any
+ * length
+ */
+template <class T>
+class SentBuffer {
+ public:
+  SentBuffer() {};
+
+  /**
+   * push a message into the buffer.
+   *
+   * \param priority Whether this is a high priority message.
+   *
+   * High priority messages will be sent to the front of the buffer
+   */
+  void push(const T &message, bool priority = false) {
+    if (priority) {
+      if (clean)
+        jsonStrings.push_front(message);
+      else
+        jsonStrings.insert((++jsonStrings.begin()), message);
+    } else
+      jsonStrings.push_back(message);
+  }
+
+  /**
+   * Request whether the passed length is readable
+   *
+   * Returns the actual length available (<= the requested length
+   */
+  size_t requestLength(size_t buffer_length) {
+    if (jsonStrings.empty())
+      return 0;
+    else
+      // String.toCharArray automatically turns the last character into
+      // a \0, we need the extra space to deal with that annoyance
+      return std::min(buffer_length - 1, jsonStrings.begin()->length() + 1);
+  }
+
+  /**
+   * Read the given length into the passed buffer (copy mode)
+   *
+   * Note the user should first make sure the requested length is available
+   * using `SentBuffer.requestLength()`, otherwise this function might fail.
+   * Note that if multiple messages are read then they are separated using '\0'.
+   * 
+   * Performance note: Consider using readPtr() for zero-copy access when possible.
+   */
+  void read(size_t length, temp_buffer_t &buf) {
+    // Note that toCharrArray always null terminates
+    // independent of whether the whole string was read so we use one extra
+    // space
+    jsonStrings.front().toCharArray(buf.buffer, length + 1);
+    last_read_size = length;
+  }
+
+  /**
+   * Returns a pointer directly to the oldest message
+   *
+   * Note the user should first make sure the requested length is available
+   * using `SentBuffer.requestLength()`, otherwise this function might fail.
+   * Note that if multiple messages are read then they are separated using '\0'.
+   */
+  const char *readPtr(size_t length) {
+    last_read_size = length;
+    return jsonStrings.front().c_str();
+  }
+
+  /**
+   * Clear the previously read messages from the buffer.
+   *
+   * Should be called after a call of read() to clear the buffer.
+   */
+  void freeRead() {
+    if (last_read_size == jsonStrings.begin()->length() + 1) {
+      jsonStrings.pop_front();
+      clean = true;
+    } else {
+      // jsonStrings.begin()->remove(0, last_read_size);
+      stringEraseFront((*jsonStrings.begin()), last_read_size);
+      clean = false;
+    }
+    last_read_size = 0;
+  }
+
+  bool empty() { return jsonStrings.empty(); }
+
+  void clear() { jsonStrings.clear(); }
+
+  size_t size() { return jsonStrings.size(); }
+
+ private:
+  size_t last_read_size = 0;
+  bool clean = true;
+  std::list<T> jsonStrings;
+
+  inline void stringEraseFront(T &string, size_t length) {
+    string.remove(0, length);
+  };
+};
+
+#ifdef PAINLESSMESH_ENABLE_STD_STRING
+template <>
+inline void SentBuffer<std::string>::read(size_t length, temp_buffer_t &buf) {
+  jsonStrings.front().copy(buf.buffer, length);
+  // Mimic String.toCharArray behaviour, which will insert
+  // null termination at the end of original string and the last
+  // character
+  if (length == jsonStrings.front().length() + 1) buf.buffer[length - 1] = '\0';
+  buf.buffer[length] = '\0';
+  last_read_size = length;
+}
+
+template <>
+inline void SentBuffer<std::string>::stringEraseFront(std::string &string,
+                                                      size_t length) {
+  string.erase(0, length);
+};
+#endif
+
+}  // namespace buffer
+}  // namespace painlessmesh
+#endif

package/src/painlessmesh/callback.hpp

@@ -0,0 +1,91 @@
+#ifndef _PAINLESS_MESH_CALLBACK_HPP_
+#define _PAINLESS_MESH_CALLBACK_HPP_
+
+#include <map>
+#include <memory>
+
+#include "painlessmesh/configuration.hpp"
+
+#include "painlessmesh/protocol.hpp"
+
+namespace painlessmesh {
+
+/**
+ * Helper functions to work with multiple callbacks
+ */
+namespace callback {
+template <typename... Args>
+class List {
+ public:
+  int execute(Args... args) {
+    for (auto&& f : callbacks) {
+      f(args...);
+    }
+    return callbacks.size();
+  }
+
+  size_t size() { return callbacks.size(); }
+
+  void clear() { return callbacks.clear(); }
+
+  /*
+   * Needs to be wrapped into semaphore
+   *
+  int executeWithScheduler(Scheduler& scheduler, Args... args) {
+    scheduler.execute();
+    for (auto&& f : callbacks) {
+      f(args...);
+      scheduler.execute();
+    }
+    return callbacks.size();
+  }*/
+
+  /** Add callbacks to the end of the list.
+   */
+  void push_back(std::function<void(Args...)> func) {
+    callbacks.push_back(func);
+  }
+
+ protected:
+  std::list<std::function<void(Args...)>> callbacks;
+};
+
+/**
+ * Manage callbacks for receiving packages
+ */
+template <typename... Args>
+class PackageCallbackList {
+ public:
+  /**
+   * Add a callback for specific package id
+   */
+  void onPackage(int id, std::function<void(Args...)> func) {
+    callbackMap[id].push_back(func);
+  }
+
+  size_t size() {
+    size_t size = 0;
+    for (auto&& key_value : callbackMap) {
+      size += key_value.second.size();
+    }
+    return size;
+  }
+
+  void clear() { callbackMap.clear(); }
+
+  /**
+   * Execute all the callbacks associated with a certain package
+   */
+  int execute(int id, Args... args) { return callbackMap[id].execute(args...); }
+
+ protected:
+  std::map<int, List<Args...>> callbackMap;
+};
+
+template <typename T>
+using MeshPackageCallbackList =
+    PackageCallbackList<protocol::Variant&, std::shared_ptr<T>, uint32_t>;
+}  // namespace callback
+}  // namespace painlessmesh
+
+#endif

package/src/painlessmesh/configuration.hpp

@@ -0,0 +1,77 @@
+#ifndef _PAINLESS_MESH_CONFIGURATION_HPP_
+#define _PAINLESS_MESH_CONFIGURATION_HPP_
+
+// Include Arduino.h in test environment to ensure TSTRING is defined
+#if defined(PAINLESSMESH_BOOST) || defined(ARDUINO_ARCH_ESP8266) || \
+    defined(ARDUINO_ARCH_ESP32)
+#ifndef ARDUINO
+#include "Arduino.h"
+#endif
+#endif
+
+#include <list>
+
+#include "painlessTaskOptions.h"
+
+#include <TaskSchedulerDeclarations.h>
+
+#define ARDUINOJSON_USE_LONG_LONG 1
+#undef ARDUINOJSON_ENABLE_STD_STRING
+#include <ArduinoJson.h>
+#undef ARDUINOJSON_ENABLE_STD_STRING
+
+// Enable (arduino) wifi support
+#define PAINLESSMESH_ENABLE_ARDUINO_WIFI
+
+// Enable OTA support
+#define PAINLESSMESH_ENABLE_OTA
+
+// Minimum free memory, besides here all packets in queue are discarded.
+#define MIN_FREE_MEMORY 4000
+// MAX number of unsent messages in queue. Newer messages are discarded
+#define MAX_MESSAGE_QUEUE 50
+
+#define NODE_TIMEOUT 10 * TASK_SECOND
+#define SCAN_INTERVAL 30 * TASK_SECOND  // AP scan period in ms
+
+#ifdef ESP32
+#include <AsyncTCP.h>
+#include <WiFi.h>
+#if ESP_ARDUINO_VERSION_MAJOR >= 3
+#include "esp_mac.h"  // required for core 3.x - exposes esp_mac_type_t values
+#endif
+#elif defined(ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>
+#endif  // ESP32
+
+// Define TSTRING - use std::string in test environment, Arduino String
+// otherwise
+#if defined(PAINLESSMESH_BOOST)
+// Test environment - TSTRING already defined in test Arduino.h as std::string
+#else
+typedef String TSTRING;
+#endif
+
+// backward compatibility
+template <typename T>
+using SimpleList = std::list<T>;
+
+namespace painlessmesh {
+namespace wifi {
+class Mesh;
+};
+};  // namespace painlessmesh
+
+/** A convenience typedef to access the mesh class*/
+#ifdef PAINLESSMESH_ENABLE_ARDUINO_WIFI
+using painlessMesh = painlessmesh::wifi::Mesh;
+#endif
+
+#ifdef ESP32
+#define MAX_CONN 10
+#else
+#define MAX_CONN 4
+#endif  // DEBUG
+
+#endif

package/src/painlessmesh/connection.hpp

@@ -0,0 +1,192 @@
+#ifndef _PAINLESS_MESH_CONNECTION_HPP_
+#define _PAINLESS_MESH_CONNECTION_HPP_
+
+#include <memory>
+
+#include "Arduino.h"
+#include "painlessmesh/configuration.hpp"
+
+#include "painlessmesh/buffer.hpp"
+#include "painlessmesh/logger.hpp"
+
+extern painlessmesh::logger::LogClass Log;
+
+namespace painlessmesh {
+namespace tcp {
+
+// Shared buffer for reading/writing to the buffer
+static painlessmesh::buffer::temp_buffer_t shared_buffer;
+
+/**
+ * Class that performs buffered read and write to the tcp connection
+ * (asyncclient)
+ *
+ * Note that the class expects to be wrapped in a shared_ptr to ensure proper
+ * lifetime management. Objects generally will only be destroyed after close is
+ * called (and the reading and writing tasks are stopped).
+ */
+class BufferedConnection
+    : public std::enable_shared_from_this<BufferedConnection> {
+ public:
+  /**
+   * Create a buffered connection around the client
+   *
+   *
+   * BufferedConnection takes ownership of the client  and will delete the
+   * pointer at the end.
+   *
+   * One should always call initialize after construction
+   */
+  BufferedConnection(AsyncClient *client) : client(client) {}
+
+  ~BufferedConnection() {
+    Log.remote("~BufferedConnection");
+    this->close();
+    if (!client->freeable()) {
+      client->close(true);
+    }
+    client->abort();
+    delete client;
+  }
+
+  void initialize(Scheduler *scheduler) {
+    auto self = this->shared_from_this();
+    sentBufferTask.set(TASK_SECOND, TASK_FOREVER, [self]() {
+      if (!self->sentBuffer.empty() && self->client->canSend()) {
+        auto ret = self->writeNext();
+        if (ret)
+          self->sentBufferTask.forceNextIteration();
+        else
+          self->sentBufferTask.delay(100 * TASK_MILLISECOND);
+      }
+    });
+    scheduler->addTask(sentBufferTask);
+    sentBufferTask.enableDelayed();
+
+    readBufferTask.set(TASK_SECOND, TASK_FOREVER, [self]() {
+      if (!self->receiveBuffer.empty()) {
+        TSTRING frnt = self->receiveBuffer.front();
+        self->receiveBuffer.pop_front();
+        if (!self->receiveBuffer.empty())
+          self->readBufferTask.forceNextIteration();
+        if (self->receiveCallback) self->receiveCallback(frnt);
+      }
+    });
+    scheduler->addTask(readBufferTask);
+    readBufferTask.enableDelayed();
+
+    client->onAck(
+        [self](void *arg, AsyncClient *client, size_t len, uint32_t time) {
+          self->sentBufferTask.forceNextIteration();
+        },
+        NULL);
+
+    client->onData(
+        [self](void *arg, AsyncClient *client, void *data, size_t len) {
+          self->receiveBuffer.push(static_cast<const char *>(data), len,
+                                   shared_buffer);
+          // Signal that we are done
+          self->client->ack(len);
+          self->readBufferTask.forceNextIteration();
+        },
+        NULL);
+
+    client->onDisconnect(
+        [self](void *arg, AsyncClient *client) { self->close(); }, NULL);
+  }
+
+  void close() {
+    if (!mConnected) return;
+
+    // Disable tasks and callbacks
+    this->sentBufferTask.setCallback(NULL);
+    this->sentBufferTask.disable();
+    this->readBufferTask.setCallback(NULL);
+    this->readBufferTask.disable();
+
+    this->client->onData(NULL, NULL);
+    this->client->onAck(NULL, NULL);
+    this->client->onDisconnect(NULL, NULL);
+    this->client->onError(NULL, NULL);
+
+    if (client->connected()) {
+      client->close();
+    }
+
+    receiveBuffer.clear();
+    sentBuffer.clear();
+
+    if (disconnectCallback) disconnectCallback();
+
+    receiveCallback = NULL;
+    disconnectCallback = NULL;
+
+    mConnected = false;
+  }
+
+  bool write(const TSTRING &data, bool priority = false) {
+    sentBuffer.push(data, priority);
+    sentBufferTask.forceNextIteration();
+    return true;
+  }
+
+  void onDisconnect(std::function<void()> callback) {
+    disconnectCallback = callback;
+  }
+
+  void onReceive(std::function<void(TSTRING)> callback) {
+    receiveCallback = callback;
+  }
+
+  bool connected() { return mConnected; }
+
+ protected:
+  bool mConnected = true;
+
+  AsyncClient *client;
+
+  std::function<void(TSTRING)> receiveCallback;
+  std::function<void()> disconnectCallback;
+
+  painlessmesh::buffer::ReceiveBuffer<TSTRING> receiveBuffer;
+  painlessmesh::buffer::SentBuffer<TSTRING> sentBuffer;
+
+  bool writeNext() {
+    if (sentBuffer.empty()) {
+      return false;
+    }
+    auto len = sentBuffer.requestLength(shared_buffer.length);
+    auto snd_len = client->space();
+    if (len > snd_len) len = snd_len;
+    if (len > 0) {
+      // sentBuffer.read(len, shared_buffer);
+      // auto written = client->write(shared_buffer.buffer, len, 1);
+      auto data_ptr = sentBuffer.readPtr(len);
+      auto written = client->write(data_ptr, len, 1);
+      if (written == len) {
+        client->send();  // TODO only do this for priority messages
+        sentBuffer.freeRead();
+        sentBufferTask.forceNextIteration();
+        return true;
+      } else if (written == 0) {
+        return false;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  Task sentBufferTask;
+  Task readBufferTask;
+
+  template <typename T>
+  std::shared_ptr<T> shared_from(T *derived) {
+    return std::static_pointer_cast<T>(shared_from_this());
+  }
+};  // namespace tcp
+};  // namespace tcp
+};  // namespace painlessmesh
+
+#endif