bug-fix: introduced an infinite loop of message sending in 2-node-long circuits

Author: MaximeFoucart

src/LoRaCommunication/TorCell.h

@@ -23,6 +23,7 @@ enum CellCommand {
 
 enum RelayCellCommand {
     DATA,
+    DATA_ACK,
     BEGIN,
     END,
     TEARDOWN,

src/LoRaCommunication/circuit.cpp

@@ -276,16 +276,15 @@ static void forwardCreated(Circuit* circuit, ControlCell cell) {
 
 //Sends data towards the other end of the circuit. If the data is larger than 
 //the maximum payload size, it will be split into multiple cells and sent sequentially.
-static void sendData(Circuit* circuit, uint16_t nextNodeID, uint16_t circID, uint8_t* data, size_t length, bool direction) {
+static void sendData(Circuit* circuit, uint16_t nextNodeID, uint16_t circID, uint8_t* data, 
+                    size_t length, bool direction, RelayCellCommand command = DATA) {
     uint16_t maxPayload = CELL_SIZE - RELAY_HEADER_SIZE - HASH_SIZE;
     uint16_t offset = 0; //keep track of how much of the data has been sent
-    printf("after entry check\n");
     while (offset < length) {
-        printf("loop, offset: %d, total: %zu, max space: %d\n", offset, length, maxPayload);
         uint16_t size = (length - offset) < maxPayload ? (length - offset) : maxPayload; //payload size
         //fill the information cell
         RelayCell dataCell;
-        fillRelayCell(dataCell, circID, RelayCellCommand::DATA, nodeID, nextNodeID, size);
+        fillRelayCell(dataCell, circID, command, nodeID, nextNodeID, size);
         memcpy(dataCell.payload, data + offset, size);
         // write zeroes to remaining payload, prevent leakage of previous data if payload is smaller than max
         memset(dataCell.payload + size, 0, maxPayload - size);
@@ -326,9 +325,10 @@ void sendDataForwards(Circuit* circuit, uint8_t* data, size_t length) {
 }
 
 //function to send a RELAY DATA cell towards the origin.
-void sendDataBackwards(Circuit* circuit, uint16_t prevNodeID, uint16_t prevCircID, uint8_t* data, size_t length) {
+void sendDataBackwards(Circuit* circuit, uint16_t prevNodeID, uint16_t prevCircID, 
+                        uint8_t* data, size_t length, RelayCellCommand command = DATA) {
     printf("sendDataBackwards\n");
-    sendData(circuit, prevNodeID, prevCircID, data, length, false);
+    sendData(circuit, prevNodeID, prevCircID, data, length, false, command);
 }
 
 //checks the validity of the digest, and returns a buffer with the content of the message.
@@ -359,9 +359,9 @@ static void handleDataAtExit(Circuit* circuit, RelayCell cell) {
     uint8_t buffer[CELL_SIZE - RELAY_HEADER_SIZE - HASH_SIZE];
     uint8_t* result = handleData(circuit, cell, buffer);
     if (result != nullptr) {
-        printf("Received data: %s\n", result);
+        printf("Circuit %d: Received data: %s\n", circuit->circID ,result);
         const char* msg = "Data received successfully!";
-        sendDataBackwards(circuit, cell.srcNodeID, cell.circID, (uint8_t*)msg, strlen(msg) + 1);
+        sendDataBackwards(circuit, cell.srcNodeID, cell.circID, (uint8_t*)msg, strlen(msg) + 1, DATA_ACK);
     }
 }
 
@@ -645,6 +645,9 @@ static void dispatchRelay(Circuit* circuit, uint8_t* data, uint16_t circID) {
         case DATA:
             handleDataAtExit(circuit, cell);
             break;
+        case DATA_ACK:
+            handleDataAtOrigin(circuit, copy);
+            break;
         default:
             break;
     }

src/LoRaCommunication/main.cpp

@@ -72,27 +72,24 @@ int main(int argc, char* argv[]) {
 
         const char* hello = "Hello World!";
 
-        /*
+        const char* incoming = "Third message incoming... It arrived!";
+
+
         printf("------------------------ build Circuit A - B - C - D -----------------------\n");
         Circuit* circuit = buildCircuit(444, 3, LocalPeers, nodeRole);
 
         while (circuit->state != CircuitState::READY) {
             std::this_thread::sleep_for(std::chrono::milliseconds(50));
         }
-        */
 
-        /*
+
         printf("------------------------ build Circuit A - B - C -----------------------\n");
         Circuit* circuit2 = buildCircuit(333, 2, LocalPeers, nodeRole);
 
         while (circuit2->state != CircuitState::READY) {
             std::this_thread::sleep_for(std::chrono::milliseconds(50));
         }
-
-        const char* msg = longmsg;
-        //sendDataForwards(circuit, (uint8_t*)hello, strlen(msg) + 1);
-        sendDataForwards(circuit2, (uint8_t*)msg, strlen(hello) + 1);
-        */
+    
 
         printf("------------------------ build Circuit A - B -----------------------\n");
         Circuit* circuit3 = buildCircuit(222, 1, LocalPeers, nodeRole);
@@ -102,8 +99,9 @@ int main(int argc, char* argv[]) {
         }
 
         const char* msg = longmsg;
-        //sendDataForwards(circuit, (uint8_t*)hello, strlen(msg) + 1);
-        sendDataForwards(circuit3, (uint8_t*)msg, strlen(hello) + 1);
+        sendDataForwards(circuit, (uint8_t*)hello, strlen(hello) + 1);
+        sendDataForwards(circuit, (uint8_t*)longmsg, strlen(longmsg) + 1);
+        sendDataForwards(circuit, (uint8_t*)incoming, strlen(incoming) + 1);
 
         /*
         printf("------------------------ Destroy Circuit A - B - C - D -----------------------\n");