initial version

Author: Guihgo

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Guilherme Henrique Gregorini Oliveira (Guihgo)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,89 @@
+# IoT Procotol
+
+IoT Protocol is a protocol over TCP based on HTTP for light data traffic.
+
+## Preamble Version 1
+
+```js
+VERSION\n
+METHOD+ID\n
+PATH\n
+[HEADERS\n]
+[B\n BODY]
+```
+
+### VERSION
+
+Version is the version of iot protocol. Used for compatibility.
+
+- Type: `byte` | `uint8_t`. **REQUIRED**
+- Example: `1`
+
+### METHOD_ID
+
+Method ID: METHOD+ID. 
+
+Methods: 
+
+* Type: `char`. **REQUIRED**
+* Example: `R`
+
+- `R` | `0x82`: *Request* method used to do calls needs a response
+- `S` | `0x83`: *Signal* method used to send signals like events
+
+
+ID: 
+
+Ramdom number with up to 2^16 
+
+* Type: `uint16_t` as Big Endian format. **REQUIRED**
+* Example: `1822`
+
+### PATH
+
+The path component contains data, usually organized in hierarchical
+form, that, serves to identify a resource [URI > 3.3 Path](https://www.rfc-editor.org/info/rfc3986).
+
+* Type: `uint8_t[]`. **REQUIRED**
+* Example: 
+  * `0xA` (10)
+  * `/foo/bar` 
+* Default: `/`
+
+### HEADERS
+
+Key Value Pair joined by `:` char, that, serves to set an attribute value for the request. Multiple headers must be separate para SEPARATOR char (`\n`).
+
+* Type: `Map<string, string>`. **OPTIONAL** 
+* Example: 
+  * Single header: `foo:bar`
+  * Multiple headers: `foo:bar\nlorem:ipsum`
+
+### BODY
+
+The final data to be used for request receiver. Starts with `B\n`. 
+
+* Type: `uint8_t[]`
+* Example:
+  * Message: `B\nlorem ipsum message`
+  * Buffer: `['B', '\n', 0x1, 0x2, 0x3, 0x4]`
+
+
+## Middlewares
+
+@TODO Explains what is a middleware and how its works
+
+## Listen
+
+@TODO Explains what listener method does
+
+## Examples
+
+@TODO List of examples on `/examples`
+
+## References 
+
+- `HTTP/1.1` Fielding, R., Ed., Nottingham, M., Ed., and J. Reschke, Ed., "HTTP/1.1", STD 99, RFC 9112, DOI 10.17487/RFC9112, June 2022, <https://www.rfc-editor.org/info/rfc9112>.
+  
+- `URI` Berners-Lee, T. Fielding, R. L. Masinter "Uniform Resource Identifier (URI): Generic Syntax" STD 66 RFC 3986 DOI 10.17487/RFC3986 <https://www.rfc-editor.org/info/rfc3986>.
+

iot_helpers.cpp

@@ -0,0 +1,14 @@
+#include "iot_helpers.h"
+
+
+int indexOf(uint8_t * buffer, size_t bufLen, char c, size_t start) {
+    int index = -1;
+
+    for(size_t i = start; (i<bufLen && index == -1); i++) {
+        if(buffer[i] == c) {
+            index = i;
+        }
+    }
+
+    return index;
+}

iot_helpers.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#ifndef __IOT_HELPERS_H__
+#define __IOT_HELPERS_H__
+
+#include "Arduino.h"
+
+int indexOf(uint8_t * buffer, size_t bufLen, char find, size_t start = (size_t)0);
+
+#endif

iot_protocol.cpp

@@ -0,0 +1,161 @@
+#include "iot_protocol.h"
+
+void IoTApp::use(IoTMiddleware middleware)
+{
+    this->middlewares.push_back(middleware);
+}
+
+void IoTApp::runMiddleware(IoTRequest *request, int index = 0)
+{
+    if (index >= this->middlewares.size())
+    {
+        return;
+    }
+
+    Next _next = [this, request, index]()
+    {
+        this->runMiddleware(request, (index + 1));
+    };
+
+    this->middlewares.at(index)(request, &_next);
+
+    /* If is the last middleware */
+    if(index == this->middlewares.size()-1) {
+        /* Free memory */
+        free(request->path);
+        free(request->body);
+    }
+}
+
+void IoTApp::listen(Client *client)
+{
+    this->clients.push_back(client);
+}
+
+void IoTApp::resetClients() {
+    this->clients.clear();
+}
+
+void IoTApp::onData(Client *client, uint8_t *buffer, size_t bufLen)
+{
+
+    IoTRequest request = {
+        1,
+        EIoTMethod::SIGNAL,
+        NULL,
+        std::map<String, String>(),
+        std::map<String, String>(),
+        NULL,
+        0,
+        client};
+
+    int foundN = 0;
+    int indexStart = 0; // 9
+    int indexN = -1;
+    bool isBody = false;
+
+    bool invalidRequest = false;
+
+    do
+    {
+        indexN = indexOf(buffer, bufLen, '\n', indexStart);
+
+        uint8_t *bufferPartStart = buffer + indexStart;
+        size_t bufferPartLength = ((indexN == -1 || isBody) ? (bufLen + 1) : indexN) - indexStart;
+
+        uint8_t bufferPart[bufferPartLength];
+        for (size_t i = 0; i < bufferPartLength; i++)
+        {
+            bufferPart[i] = bufferPartStart[i];
+        }
+
+        // [ 0 \n 1 2 \n 3 4 5 \n 6 7 8 9]
+        switch (foundN)
+        {
+        case 0:
+            if(bufferPartLength > 1) {
+                invalidRequest = true;
+                continue;
+            }
+            request.version = static_cast<byte>((char)bufferPart[0]);
+            break;
+        case 1:
+            request.method = static_cast<EIoTMethod>((char)bufferPart[0]);
+            break;
+        case 2:
+            request.path = static_cast<char *>(malloc(bufferPartLength * sizeof(char) + 1));
+            memcpy(request.path, bufferPartStart, bufferPartLength);
+            request.path[bufferPartLength] = '\0';
+            /* @TODO: define params */
+            break;
+        default:
+
+            /* Headers */
+            //  const indexKeyValue = bufferPart.indexOf(":");
+            int indexKeyValue = indexOf(bufferPart, bufferPartLength, ':');
+            if (indexKeyValue > 0 && isBody == false)
+            {
+                char cBufferPart[bufferPartLength];
+                memcpy(cBufferPart, bufferPart, bufferPartLength);
+
+                String allHeader = String(cBufferPart, bufferPartLength);
+
+                String key = allHeader.substring(0, indexKeyValue);
+                key.trim();
+                String value = allHeader.substring(indexKeyValue + 1);
+                value.trim();
+
+                request.headers.insert(std::make_pair(key, value));
+
+                break;
+            }
+
+            /* Body */
+            if (isBody == false && bufferPartLength == 1 && static_cast<EIoTRequestPart>((char)bufferPart[0]) == EIoTRequestPart::BODY)
+            {
+                isBody = true;
+                break;
+            }
+
+            if (isBody)
+            {
+                request.body = (uint8_t *)(malloc(bufferPartLength * sizeof(uint8_t) + 1));
+                memcpy(request.body, bufferPartStart, bufferPartLength);
+                request.body[bufferPartLength] = '\0';
+                request.bodyLength = bufferPartLength;
+                isBody = false;
+                break;
+            }
+        }
+
+        foundN++;
+        indexStart = indexN + 1;
+
+    } while (indexN >= 0 && invalidRequest == false);
+
+    if (invalidRequest) return;
+
+
+    this->runMiddleware(&request);
+}
+
+void IoTApp::loop()
+{
+
+    for (auto client : this->clients)
+    {
+        uint8_t buffer[IOT_PROTOCOL_MAX_READ_LENGTH];
+        int indexBuffer = 0;
+        while (client->available())
+        {
+            buffer[indexBuffer] = client->read();
+            indexBuffer++;
+        }
+
+        if (indexBuffer > 0)
+        {
+            buffer[indexBuffer] = '\0';
+            this->onData(client, buffer, (indexBuffer - 1));
+        }
+    }
+}

iot_protocol.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#ifndef __IOT_PROTOCOL_H__
+#define __IOT_PROTOCOL_H__
+
+// #ifdef __cplusplus
+// extern "C"
+// {
+// #endif
+
+#include "Arduino.h"
+#include <vector>
+#include <functional>
+#include <map>
+#include <algorithm>
+
+#include "iot_helpers.h"
+
+#define IOT_PROTOCOL_MAX_READ_LENGTH 1024
+
+    enum class EIoTMethod : char
+    {
+        SIGNAL = 'S',
+        REQUEST = 'R'
+    };
+
+    enum class EIoTRequestPart : char
+    {
+        BODY = 'B',
+    };
+
+    struct IoTRequest
+    {
+        byte version;
+        EIoTMethod method;
+        char* path;
+        std::map<String, String> params;
+        std::map<String, String> headers;
+        uint8_t * body;
+        size_t bodyLength;
+        Client * client;
+    };
+
+    typedef std::function<void(void)> Next;
+    
+    typedef void (*IoTMiddleware)(IoTRequest *, Next*);
+
+    class IoTApp
+    {
+    private: 
+        std::vector<Client *> clients;
+        void onData(Client* client, uint8_t* buffer, size_t bufLen);
+    public:
+        std::vector<IoTMiddleware> middlewares;
+
+        void use(IoTMiddleware middleware);
+
+        void runMiddleware(IoTRequest *request, int index);
+
+        void listen(Client *client);
+        
+        void resetClients();
+
+        void loop();
+
+    };
+
+// #ifdef __cplusplus
+// }
+// #endif
+
+#endif

library.properties

@@ -0,0 +1,9 @@
+name=iot_protocol
+version=1.0.0
+author=Guihgo
+maintainer=Guihgo <guihgo100milha@gmail.com>
+sentence=IoT Protocol is a protocol over TCP based on HTTP for light data traffic.
+paragraph=IoT Protocol is a protocol over TCP based on HTTP for light data traffic.
+category=iot protocol http tcp
+url=
+architectures=*