local libs

lib/async-mqtt-client/src/AsyncMqttClient/Packets/ConnAckPacket.cpp

@@ -0,0 +1,30 @@
+#include "ConnAckPacket.hpp"
+
+using AsyncMqttClientInternals::ConnAckPacket;
+
+ConnAckPacket::ConnAckPacket(ParsingInformation* parsingInformation, OnConnAckInternalCallback callback)
+: _parsingInformation(parsingInformation)
+, _callback(callback)
+, _bytePosition(0)
+, _sessionPresent(false)
+, _connectReturnCode(0) {
+}
+
+ConnAckPacket::~ConnAckPacket() {
+}
+
+void ConnAckPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  char currentByte = data[(*currentBytePosition)++];
+  if (_bytePosition++ == 0) {
+    _sessionPresent = (currentByte << 7) >> 7;
+  } else {
+    _connectReturnCode = currentByte;
+    _parsingInformation->bufferState = BufferState::NONE;
+    _callback(_sessionPresent, _connectReturnCode);
+  }
+}
+
+void ConnAckPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  (void)data;
+  (void)currentBytePosition;
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/ConnAckPacket.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class ConnAckPacket : public Packet {
+ public:
+  explicit ConnAckPacket(ParsingInformation* parsingInformation, OnConnAckInternalCallback callback);
+  ~ConnAckPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnConnAckInternalCallback _callback;
+
+  uint8_t _bytePosition;
+  bool _sessionPresent;
+  uint8_t _connectReturnCode;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/Packet.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace AsyncMqttClientInternals {
+class Packet {
+ public:
+  virtual ~Packet() {}
+
+  virtual void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) = 0;
+  virtual void parsePayload(char* data, size_t len, size_t* currentBytePosition) = 0;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PingRespPacket.cpp

@@ -0,0 +1,21 @@
+#include "PingRespPacket.hpp"
+
+using AsyncMqttClientInternals::PingRespPacket;
+
+PingRespPacket::PingRespPacket(ParsingInformation* parsingInformation, OnPingRespInternalCallback callback)
+: _parsingInformation(parsingInformation)
+, _callback(callback) {
+}
+
+PingRespPacket::~PingRespPacket() {
+}
+
+void PingRespPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  (void)data;
+  (void)currentBytePosition;
+}
+
+void PingRespPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  (void)data;
+  (void)currentBytePosition;
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PingRespPacket.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class PingRespPacket : public Packet {
+ public:
+  explicit PingRespPacket(ParsingInformation* parsingInformation, OnPingRespInternalCallback callback);
+  ~PingRespPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnPingRespInternalCallback _callback;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PubAckPacket.cpp

@@ -0,0 +1,30 @@
+#include "PubAckPacket.hpp"
+
+using AsyncMqttClientInternals::PubAckPacket;
+
+PubAckPacket::PubAckPacket(ParsingInformation* parsingInformation, OnPubAckInternalCallback callback)
+: _parsingInformation(parsingInformation)
+, _callback(callback)
+, _bytePosition(0)
+, _packetIdMsb(0)
+, _packetId(0) {
+}
+
+PubAckPacket::~PubAckPacket() {
+}
+
+void PubAckPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  char currentByte = data[(*currentBytePosition)++];
+  if (_bytePosition++ == 0) {
+    _packetIdMsb = currentByte;
+  } else {
+    _packetId = currentByte | _packetIdMsb << 8;
+    _parsingInformation->bufferState = BufferState::NONE;
+    _callback(_packetId);
+  }
+}
+
+void PubAckPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  (void)data;
+  (void)currentBytePosition;
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PubAckPacket.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class PubAckPacket : public Packet {
+ public:
+  explicit PubAckPacket(ParsingInformation* parsingInformation, OnPubAckInternalCallback callback);
+  ~PubAckPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnPubAckInternalCallback _callback;
+
+  uint8_t _bytePosition;
+  char _packetIdMsb;
+  uint16_t _packetId;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PubCompPacket.cpp

@@ -0,0 +1,30 @@
+#include "PubCompPacket.hpp"
+
+using AsyncMqttClientInternals::PubCompPacket;
+
+PubCompPacket::PubCompPacket(ParsingInformation* parsingInformation, OnPubCompInternalCallback callback)
+: _parsingInformation(parsingInformation)
+, _callback(callback)
+, _bytePosition(0)
+, _packetIdMsb(0)
+, _packetId(0) {
+}
+
+PubCompPacket::~PubCompPacket() {
+}
+
+void PubCompPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  char currentByte = data[(*currentBytePosition)++];
+  if (_bytePosition++ == 0) {
+    _packetIdMsb = currentByte;
+  } else {
+    _packetId = currentByte | _packetIdMsb << 8;
+    _parsingInformation->bufferState = BufferState::NONE;
+    _callback(_packetId);
+  }
+}
+
+void PubCompPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  (void)data;
+  (void)currentBytePosition;
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PubCompPacket.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class PubCompPacket : public Packet {
+ public:
+  explicit PubCompPacket(ParsingInformation* parsingInformation, OnPubCompInternalCallback callback);
+  ~PubCompPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnPubCompInternalCallback _callback;
+
+  uint8_t _bytePosition;
+  char _packetIdMsb;
+  uint16_t _packetId;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PubRecPacket.cpp

@@ -0,0 +1,30 @@
+#include "PubRecPacket.hpp"
+
+using AsyncMqttClientInternals::PubRecPacket;
+
+PubRecPacket::PubRecPacket(ParsingInformation* parsingInformation, OnPubRecInternalCallback callback)
+: _parsingInformation(parsingInformation)
+, _callback(callback)
+, _bytePosition(0)
+, _packetIdMsb(0)
+, _packetId(0) {
+}
+
+PubRecPacket::~PubRecPacket() {
+}
+
+void PubRecPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  char currentByte = data[(*currentBytePosition)++];
+  if (_bytePosition++ == 0) {
+    _packetIdMsb = currentByte;
+  } else {
+    _packetId = currentByte | _packetIdMsb << 8;
+    _parsingInformation->bufferState = BufferState::NONE;
+    _callback(_packetId);
+  }
+}
+
+void PubRecPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  (void)data;
+  (void)currentBytePosition;
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PubRecPacket.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class PubRecPacket : public Packet {
+ public:
+  explicit PubRecPacket(ParsingInformation* parsingInformation, OnPubRecInternalCallback callback);
+  ~PubRecPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnPubRecInternalCallback _callback;
+
+  uint8_t _bytePosition;
+  char _packetIdMsb;
+  uint16_t _packetId;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PubRelPacket.cpp

@@ -0,0 +1,30 @@
+#include "PubRelPacket.hpp"
+
+using AsyncMqttClientInternals::PubRelPacket;
+
+PubRelPacket::PubRelPacket(ParsingInformation* parsingInformation, OnPubRelInternalCallback callback)
+: _parsingInformation(parsingInformation)
+, _callback(callback)
+, _bytePosition(0)
+, _packetIdMsb(0)
+, _packetId(0) {
+}
+
+PubRelPacket::~PubRelPacket() {
+}
+
+void PubRelPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  char currentByte = data[(*currentBytePosition)++];
+  if (_bytePosition++ == 0) {
+    _packetIdMsb = currentByte;
+  } else {
+    _packetId = currentByte | _packetIdMsb << 8;
+    _parsingInformation->bufferState = BufferState::NONE;
+    _callback(_packetId);
+  }
+}
+
+void PubRelPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  (void)data;
+  (void)currentBytePosition;
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PubRelPacket.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class PubRelPacket : public Packet {
+ public:
+  explicit PubRelPacket(ParsingInformation* parsingInformation, OnPubRelInternalCallback callback);
+  ~PubRelPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnPubRelInternalCallback _callback;
+
+  uint8_t _bytePosition;
+  char _packetIdMsb;
+  uint16_t _packetId;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PublishPacket.cpp

@@ -0,0 +1,114 @@
+#include "PublishPacket.hpp"
+
+using AsyncMqttClientInternals::PublishPacket;
+
+PublishPacket::PublishPacket(ParsingInformation* parsingInformation, OnMessageInternalCallback dataCallback, OnPublishInternalCallback completeCallback)
+: _parsingInformation(parsingInformation)
+, _dataCallback(dataCallback)
+, _completeCallback(completeCallback)
+, _dup(false)
+, _qos(0)
+, _retain(0)
+, _bytePosition(0)
+, _topicLengthMsb(0)
+, _topicLength(0)
+, _ignore(false)
+, _packetIdMsb(0)
+, _packetId(0)
+, _payloadLength(0)
+, _payloadBytesRead(0)
+, _ptempbuff(0) {
+    _dup = _parsingInformation->packetFlags & HeaderFlag.PUBLISH_DUP;
+    _retain = _parsingInformation->packetFlags & HeaderFlag.PUBLISH_RETAIN;
+    char qosMasked = _parsingInformation->packetFlags & 0x06;
+    switch (qosMasked) {
+      case HeaderFlag.PUBLISH_QOS0:
+        _qos = 0;
+        break;
+      case HeaderFlag.PUBLISH_QOS1:
+        _qos = 1;
+        break;
+      case HeaderFlag.PUBLISH_QOS2:
+        _qos = 2;
+        break;
+    }
+}
+
+PublishPacket::~PublishPacket() {
+}
+
+void PublishPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  char currentByte = data[(*currentBytePosition)++];
+  if (_bytePosition == 0) {
+    _topicLengthMsb = currentByte;
+  } else if (_bytePosition == 1) {
+    _topicLength = currentByte | _topicLengthMsb << 8;
+    if (_topicLength > _parsingInformation->maxTopicLength) {
+      _ignore = true;
+    } else {
+      _parsingInformation->topicBuffer[_topicLength] = '\0';
+    }
+  } else if (_bytePosition >= 2 && _bytePosition < 2 + _topicLength) {
+    // Starting from here, _ignore might be true
+    if (!_ignore) _parsingInformation->topicBuffer[_bytePosition - 2] = currentByte;
+    if (_bytePosition == 2 + _topicLength - 1 && _qos == 0) {
+      _preparePayloadHandling(_parsingInformation->remainingLength - (_bytePosition + 1));
+      return;
+    }
+  } else if (_bytePosition == 2 + _topicLength) {
+    _packetIdMsb = currentByte;
+  } else {
+    _packetId = currentByte | _packetIdMsb << 8;
+    _preparePayloadHandling(_parsingInformation->remainingLength - (_bytePosition + 1));
+  }
+  _bytePosition++;
+}
+
+void PublishPacket::_preparePayloadHandling(uint32_t payloadLength) {
+  _payloadLength = payloadLength;
+  if (payloadLength == 0) {
+    _parsingInformation->bufferState = BufferState::NONE;
+    if (!_ignore) {
+      _dataCallback(_parsingInformation->topicBuffer, nullptr, _qos, _dup, _retain, 0, 0, 0, _packetId);
+      _completeCallback(_packetId, _qos);
+    }
+  } else {
+    _parsingInformation->bufferState = BufferState::PAYLOAD;
+  }
+}
+
+void PublishPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  size_t remainToRead = len - (*currentBytePosition);
+  if (_payloadBytesRead + remainToRead > _payloadLength)
+    remainToRead = _payloadLength - _payloadBytesRead;
+  if (!_ignore) {
+    if (remainToRead < _payloadLength) {
+      if (!_ptempbuff) {
+        _ptempbuff = new char[_payloadLength + 1];
+        if (_ptempbuff == nullptr) {
+          _ignore = true;
+          return;
+        }
+        memset(_ptempbuff, 0, _payloadLength + 1);
+        memcpy(&_ptempbuff[_payloadBytesRead], &data[(*currentBytePosition)], remainToRead);
+      } else {
+        memcpy(&_ptempbuff[_payloadBytesRead], &data[(*currentBytePosition)], remainToRead);
+        if ((_payloadBytesRead + remainToRead) == _payloadLength) {
+          _dataCallback(_parsingInformation->topicBuffer, _ptempbuff, _qos, _dup, _retain, _payloadLength, 0, _payloadLength, _packetId);
+          delete[] _ptempbuff;
+          _ptempbuff = NULL;
+        }
+      }
+    } else {
+      _dataCallback(_parsingInformation->topicBuffer, &data[(*currentBytePosition)], _qos, _dup, _retain, remainToRead, _payloadBytesRead, _payloadLength, _packetId);
+    }
+  }
+  _payloadBytesRead += remainToRead;
+  (*currentBytePosition) += remainToRead;
+
+  if (_payloadBytesRead == _payloadLength) {
+    _parsingInformation->bufferState = BufferState::NONE;
+    if (!_ignore)
+      _completeCallback(_packetId, _qos);
+  }
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/PublishPacket.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../Flags.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class PublishPacket : public Packet {
+ public:
+  explicit PublishPacket(ParsingInformation* parsingInformation, OnMessageInternalCallback dataCallback, OnPublishInternalCallback completeCallback);
+  ~PublishPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnMessageInternalCallback _dataCallback;
+  OnPublishInternalCallback _completeCallback;
+
+  void _preparePayloadHandling(uint32_t payloadLength);
+
+  bool _dup;
+  uint8_t _qos;
+  bool _retain;
+
+  uint8_t _bytePosition;
+  char _topicLengthMsb;
+  uint16_t _topicLength;
+  bool _ignore;
+  char _packetIdMsb;
+  uint16_t _packetId;
+  uint32_t _payloadLength;
+  uint32_t _payloadBytesRead;
+  char*    _ptempbuff;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/SubAckPacket.cpp

@@ -0,0 +1,46 @@
+#include "SubAckPacket.hpp"
+
+using AsyncMqttClientInternals::SubAckPacket;
+
+SubAckPacket::SubAckPacket(ParsingInformation* parsingInformation, OnSubAckInternalCallback callback)
+: _parsingInformation(parsingInformation)
+, _callback(callback)
+, _bytePosition(0)
+, _packetIdMsb(0)
+, _packetId(0) {
+}
+
+SubAckPacket::~SubAckPacket() {
+}
+
+void SubAckPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  char currentByte = data[(*currentBytePosition)++];
+  if (_bytePosition++ == 0) {
+    _packetIdMsb = currentByte;
+  } else {
+    _packetId = currentByte | _packetIdMsb << 8;
+    _parsingInformation->bufferState = BufferState::PAYLOAD;
+  }
+}
+
+void SubAckPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  char status = data[(*currentBytePosition)++];
+
+  /* switch (status) {
+    case 0:
+      Serial.println("Success QoS 0");
+      break;
+    case 1:
+      Serial.println("Success QoS 1");
+      break;
+    case 2:
+      Serial.println("Success QoS 2");
+      break;
+    case 0x80:
+      Serial.println("Failure");
+      break;
+  } */
+
+  _parsingInformation->bufferState = BufferState::NONE;
+  _callback(_packetId, status);
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/SubAckPacket.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class SubAckPacket : public Packet {
+ public:
+  explicit SubAckPacket(ParsingInformation* parsingInformation, OnSubAckInternalCallback callback);
+  ~SubAckPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnSubAckInternalCallback _callback;
+
+  uint8_t _bytePosition;
+  char _packetIdMsb;
+  uint16_t _packetId;
+};
+}  // namespace AsyncMqttClientInternals

lib/async-mqtt-client/src/AsyncMqttClient/Packets/UnsubAckPacket.cpp

@@ -0,0 +1,30 @@
+#include "UnsubAckPacket.hpp"
+
+using AsyncMqttClientInternals::UnsubAckPacket;
+
+UnsubAckPacket::UnsubAckPacket(ParsingInformation* parsingInformation, OnUnsubAckInternalCallback callback)
+: _parsingInformation(parsingInformation)
+, _callback(callback)
+, _bytePosition(0)
+, _packetIdMsb(0)
+, _packetId(0) {
+}
+
+UnsubAckPacket::~UnsubAckPacket() {
+}
+
+void UnsubAckPacket::parseVariableHeader(char* data, size_t len, size_t* currentBytePosition) {
+  char currentByte = data[(*currentBytePosition)++];
+  if (_bytePosition++ == 0) {
+    _packetIdMsb = currentByte;
+  } else {
+    _packetId = currentByte | _packetIdMsb << 8;
+    _parsingInformation->bufferState = BufferState::NONE;
+    _callback(_packetId);
+  }
+}
+
+void UnsubAckPacket::parsePayload(char* data, size_t len, size_t* currentBytePosition) {
+  (void)data;
+  (void)currentBytePosition;
+}

lib/async-mqtt-client/src/AsyncMqttClient/Packets/UnsubAckPacket.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Arduino.h"
+#include "Packet.hpp"
+#include "../ParsingInformation.hpp"
+#include "../Callbacks.hpp"
+
+namespace AsyncMqttClientInternals {
+class UnsubAckPacket : public Packet {
+ public:
+  explicit UnsubAckPacket(ParsingInformation* parsingInformation, OnUnsubAckInternalCallback callback);
+  ~UnsubAckPacket();
+
+  void parseVariableHeader(char* data, size_t len, size_t* currentBytePosition);
+  void parsePayload(char* data, size_t len, size_t* currentBytePosition);
+
+ private:
+  ParsingInformation* _parsingInformation;
+  OnUnsubAckInternalCallback _callback;
+
+  uint8_t _bytePosition;
+  char _packetIdMsb;
+  uint16_t _packetId;
+};
+}  // namespace AsyncMqttClientInternals