[feaure] multipart body: sender ok

Author: Guihgo

.gitignore

@@ -0,0 +1 @@
+.vscode

README.md

@@ -19,13 +19,14 @@ IOT PROTOCOL uses middlewares and router's filtering features based on [express
   - Minimum request size is 2 bytes
   - Request-response model like HTTP protocol
   - Adaptive requests methods for optimizing data length
+  - Multipart (Send large data)
 
 ---
 
 ## Preamble Version 1
 
 ```
-<MCB + LCB>
+<MSCB + LSCB>
 [ID]
 [PATH + ETX]
 [HEADER + ETX]
@@ -36,8 +37,34 @@ IOT PROTOCOL uses middlewares and router's filtering features based on [express
 
 > `[...]` OPTIONAL
 
+> `[PATH + ETX] + [HEADER + ETX]` **MUST NOT BE MORE THAN 1016 Bytes** 
+> 
+>       + 1024 Bytes : IOT_PROTOCOL_BUFFER_SIZE
+>          - 1 Byte  : MSCB_SIZE 
+>          - 1 Byte  : LSCB_SIZE 
+>          - 2 Bytes : ID_SIZE 
+>          - 4 Bytes : BODY_LENGTH_MAXIMUM_SIZE (Streaming)
+>        ----------------
+>          + 1016 Bytes : [PATH + ETX]_SIZE + [HEADER + ETX]_SIZE
+> 
+>     |-----------------------------------------IOT_PROTOCOL_BUFFER_SIZE(1024)-----------------------------------|
+>
+>     |--MSCB(1)--|
+>  
+>                 |--LSCB(1)--| 
+>  
+>                             |--ID_SIZE(2)--| 
+>
+>                                            |--[PATH + ETX]--|
+>
+>                                                             |--[HEADER + ETX]--|
+>
+>                                                                                |--BODY_LENGTH_MAXIMUM_SIZE(4)--|
+> 
+> 
+
 ---
-### [0] **MCB**: MSB_CONTROL_BYTE
+### [0] **MSCB**: MSB_CONTROL_BYTE
 
 The Most Significant Control Byte.  **REQUIRED**
 
@@ -54,7 +81,7 @@ The Most Significant Control Byte.  **REQUIRED**
   - Range: `from 1 up to 63`. Zero is reserved.
 
 ---
-### [1] **LCB**: LSB_CONTROL_BYTE
+### [1] **LSCB**: LSB_CONTROL_BYTE
 
 The Least Significant Control Byte. **REQUIRED**
   * Size: `1 byte`
@@ -73,7 +100,7 @@ The Least Significant Control Byte. **REQUIRED**
 
 Methods Types
 
-|Name                 | Description                     | MCB::ID   | MCB::PATH | LCB::METHOD | LCB::HEADER | LCB::BODY | BODY::LENGTH            | Minimum Total Length  |
+|Name                 | Description                     | MSCB::ID   | MSCB::PATH | LSCB::METHOD | LSCB::HEADER | LSCB::BODY | BODY::LENGTH            | Minimum Total Length  |
 |:--                  | :--                             | :--:      | :--:      | :--:        | :--:      | :--:        | :--                     | :--:                  |
 | *Signal*            | Ligthweight signals like events | 0         | 0/1       | `0b000001`  | 0/1       | 0/1         | *up to 255 bytes*       | 2 bytes               |
 | *Request*           | Request that needs response     | 1         | 0/1       | `0b000010`  | 0/1       | 0/1         | *up to 65535 bytes*     | 4 bytes               |

iot_protocol.cpp

@@ -1,7 +1,7 @@
 #include "iot_protocol.h"
 
-IoTApp::IoTApp(uint32_t delay = 300)
-{   
+IoTApp::IoTApp(uint32_t delay)
+{
     this->delay = delay;
 }
 
@@ -54,6 +54,7 @@ void IoTApp::onData(Client *client, uint8_t *buffer, size_t bufLen)
         std::map<char *, char *>(),
         NULL,
         0,
+        0,
         client};
 
     size_t offset = 0;
@@ -274,14 +275,24 @@ IoTRequest *IoTApp::send(IoTRequest *request, IoTRequestResponse *requestRespons
         dataLength += headersLength;
     }
 
-    if((pathLength + headersLength) > IOT_PROTOCOL_BUFFER_SIZE - 8) {
+    if ((pathLength + headersLength) > IOT_PROTOCOL_BUFFER_SIZE - 8)
+    {
         throw "Path and Headers too big";
     }
 
     if (LSCB & IOT_LSCB_BODY)
     {
         dataLength += bodyLengthSize + request->bodyLength;
     }
+    else
+    {
+        bodyLengthSize = 0;
+    }
+
+    if (dataLength > IOT_PROTOCOL_BUFFER_SIZE)
+    {
+        dataLength = IOT_PROTOCOL_BUFFER_SIZE;
+    }
 
     /* Record Data */
 
@@ -343,14 +354,43 @@ IoTRequest *IoTApp::send(IoTRequest *request, IoTRequestResponse *requestRespons
         {
             data[++nextIndex] = (request->bodyLength >> ((i - 1) * 8)) & 255;
         }
+    }
+
+    size_t prefixDataIndex = nextIndex;
+
+    std::function<size_t(size_t, size_t)> writeBodyPart = [&writeBodyPart, this, request, prefixDataIndex, &data](size_t i = 0, size_t parts = 0)
+    {
+        size_t indexData = prefixDataIndex + 1; //42 
         /* Body */
-        for (size_t i = 0; i < request->bodyLength; i++)
+        if (request->bodyLength > 0) //1060 > 0
         {
-            data[++nextIndex] = *(request->body + i);
+            size_t bodyBufferRemain = (request->bodyLength - i);  //1984  //                                                                                                      
+            size_t bodyUntilIndex = ((bodyBufferRemain + indexData) > IOT_PROTOCOL_BUFFER_SIZE) ? i + (IOT_PROTOCOL_BUFFER_SIZE - indexData) : i + bodyBufferRemain; // 1004 //1060
+            for (; i <= bodyUntilIndex; i++) //[0-1004] //[1005 - 1060]
+            {
+                //i = 1005 indexData = 21 ... i = 1060  indexData = 76
+                *(data + (indexData++)) = *(request->body + i);
+                //i = 1006 indexData = 22 ... i = 1061  indexData = 77
+            }
         }
-    }
 
-    data[++nextIndex] = '\0';
+        *(data + (indexData)) = '\0';
+        request->client->write(data, indexData-1);
+        request->client->flush();
+        vTaskDelay(this->delay);
+
+        parts++;
+        if (i >= request->bodyLength)
+        {
+            return parts;
+        }
+        else
+        {
+            return writeBodyPart(i,parts);
+        }
+    };
+
+    request->parts = writeBodyPart(0, 0);
 
     if (requestResponse != NULL)
     {
@@ -364,11 +404,6 @@ IoTRequest *IoTApp::send(IoTRequest *request, IoTRequestResponse *requestRespons
         this->requestResponse.insert(std::make_pair(request->id, *requestResponse));
     }
 
-
-    vTaskDelay(this->delay);
-
-    request->client->write(data, dataLength);
-
     return request;
 }
 
@@ -396,7 +431,8 @@ void IoTApp::readClient(Client *client)
         this->onData(client, buffer, (bufferLength));
     }
 
-    if(bufferLength >= IOT_PROTOCOL_BUFFER_SIZE) {
+    if (bufferLength >= IOT_PROTOCOL_BUFFER_SIZE)
+    {
         return this->readClient(client);
     }
 }

iot_protocol.h

@@ -44,6 +44,7 @@ struct IoTRequest
     std::map<char *, char *> headers;
     uint8_t *body;
     size_t bodyLength;
+    size_t parts;
     Client *client;
 };