// matth-x/ArduinoOcpp

// Copyright Matthias Akstaller 2019 - 2021

// MIT License

#include <ArduinoOcpp/Core/OcppConnection.h>

#include <ArduinoOcpp/SimpleOcppOperationFactory.h>

#include <ArduinoOcpp/Core/OcppError.h>

#include <Variants.h>

#define HEAP_GUARD 2000UL //will not accept JSON messages if it will result in less than HEAP_GUARD free bytes in heap

size_t removePayload(const char *src, size_t src_size, char *dst, size_t dst_size);

using namespace ArduinoOcpp;

OcppConnection::OcppConnection(OcppSocket *ocppSock) : ocppSock(ocppSock) {

ReceiveTXTcallback callback = [this] (const char *payload, size_t length) {

return this->processOcppSocketInputTXT(payload, length);

};

ocppSock->setReceiveTXTcallback(callback);

}

void OcppConnection::loop() {

/**

* Work through the initiatedOcppOperations queue. Start with the first element by calling req() on it. If

* the operation is (still) pending, it will return false and therefore each other queued element must

* wait until this operation is over. If an ocppOperation is finished, it returns true on a req() call,

* can be dequeued and the following ocppOperation is processed.

*/

auto operation = initiatedOcppOperations.begin();

while (operation != initiatedOcppOperations.end()){

boolean timeout = (*operation)->sendReq(ocppSock); //The only reason to dequeue elements here is when a timeout occurs. Normally

if (timeout){ //the Conf msg processing routine dequeues finished elements

delete *operation;

operation = initiatedOcppOperations.erase(operation);

//TODO Review: are all recources freed here?

//go on with the next element in the queue, which is now at initiatedOcppOperations[0]

} else {

//there is one operation pending right now, so quit this while-loop.

break;

}

}

/*

* Activate timeout detection on the msgs other than the first in the queue.

*/

operation = initiatedOcppOperations.begin();

while (operation != initiatedOcppOperations.end()) {

if (operation == initiatedOcppOperations.begin()){ //jump over the first element

++operation;

continue;

}

Timeout *timer = (*operation)->getTimeout();

if (!timer) {

++operation; //no timeouts, nothing to do in this iteration

continue;

}

timer->tick(false); //false: did not send a frame prior to calling tick

if (timer->isExceeded()) {

Serial.print(F("[OcppEngine] Discarding operation due to timeout: "));

(*operation)->print_debug();

delete *operation;

operation = initiatedOcppOperations.erase(operation);

} else {

++operation;

}

}

/**

* Work through the receivedOcppOperations queue. Start with the first element by calling conf() on it.

* If an ocppOperation is finished, it returns true on a conf() call, and is dequeued.

*/

operation = receivedOcppOperations.begin();

while (operation != receivedOcppOperations.end()){

boolean success = (*operation)->sendConf(ocppSock);

if (success){

delete *operation;

operation = receivedOcppOperations.erase(operation);

//TODO Review: are all recources freed here?

//go on with the next element in the queue, which is now at receivedOcppOperations[i]

} else {

//There will be another attempt to send this conf message in a future loop call.

//Go on with the next element in the queue, which is now at receivedOcppOperations[i+1]

++operation; //TODO review: this makes conf's out-of-order. But if the first Op fails because of lacking RAM, this could save the device.

}

}

}

void OcppConnection::initiateOcppOperation(OcppOperation *o){

if (!o->isFullyConfigured()){

Serial.printf("[OcppEngine] initiateOcppOperation(op) was called without the operation being configured and ready to send. Discard operation!\n");

delete o;

return;

}

initiatedOcppOperations.push_back(o);

o->setInitiated();

}

bool OcppConnection::processOcppSocketInputTXT(const char* payload, size_t length) {

boolean deserializationSuccess = false;

DynamicJsonDocument *doc = NULL;

size_t capacity = length + 100;

DeserializationError err = DeserializationError::NoMemory;

while (capacity + HEAP_GUARD < ESP.getFreeHeap() && err == DeserializationError::NoMemory) {

if (doc){

delete doc;

doc = NULL;

}

doc = new DynamicJsonDocument(capacity);

err = deserializeJson(*doc, payload, length);

capacity /= 2;

capacity *= 3;

}

//TODO insert validateRpcHeader at suitable position

switch (err.code()) {

case DeserializationError::Ok:

if (doc != NULL){

int messageTypeId = (*doc)[0];

switch(messageTypeId) {

case MESSAGE_TYPE_CALL:

handleReqMessage(doc);

deserializationSuccess = true;

break;

case MESSAGE_TYPE_CALLRESULT:

handleConfMessage(doc);

deserializationSuccess = true;

break;

case MESSAGE_TYPE_CALLERROR:

handleErrMessage(doc);

deserializationSuccess = true;

break;

default:

Serial.print(F("[OcppEngine] Invalid OCPP message! (though JSON has successfully been deserialized)\n"));

break;

}

} else { //unlikely corner case

Serial.print(F("[OcppEngine] Deserialization is okay but doc is Null\n"));

}

break;

case DeserializationError::InvalidInput:

Serial.print(F("[OcppEngine] Invalid input! Not a JSON\n"));

break;

case DeserializationError::NoMemory:

{

if (DEBUG_OUT) Serial.print(F("[OcppEngine] Error: Not enough memory in heap! Input length = "));

if (DEBUG_OUT) Serial.print(length);

if (DEBUG_OUT) Serial.print(F(", free heap = "));

if (DEBUG_OUT) Serial.println(ESP.getFreeHeap());

/*

* If websocket input is of message type MESSAGE_TYPE_CALL, send back a message of type MESSAGE_TYPE_CALLERROR.

* Then the communication counterpart knows that this operation failed.

* If the input type is MESSAGE_TYPE_CALLRESULT, it can be ignored. This controller will automatically resend the corresponding requirement message.

*/

if (doc){

delete doc;

doc = NULL;

}

doc = new DynamicJsonDocument(200);

char onlyRpcHeader[200];

size_t onlyRpcHeader_len = removePayload(payload, length, onlyRpcHeader, 200);

DeserializationError err2 = deserializeJson(*doc, onlyRpcHeader, onlyRpcHeader_len);

if (err2.code() == DeserializationError::Ok) {

int messageTypeId2 = (*doc)[0] | -1;

if (messageTypeId2 == MESSAGE_TYPE_CALL) {

deserializationSuccess = true;

OcppOperation *op = makeOcppOperation(new OutOfMemory(ESP.getFreeHeap(), length));

handleReqMessage(doc, op);

}

}

}

break;

default:

Serial.print(F("[OcppEngine] Deserialization failed: "));

Serial.println(err.c_str());

break;

}

if (doc) {

delete doc;

}

return deserializationSuccess;

}

/**

* call conf() on each element of the queue. Start with first element. On successful message delivery,

* delete the element from the list. Try all the pending OCPP Operations until the right one is found.

*

* This function could result in improper behavior in Charging Stations, because messages are not

* guaranteed to be received and therefore processed in the right order.

*/

void OcppConnection::handleConfMessage(JsonDocument *json) {

for (auto operation = initiatedOcppOperations.begin(); operation != initiatedOcppOperations.end(); ++operation) {

boolean success = (*operation)->receiveConf(json); //maybe rename to "consumed"?

if (success) {

delete *operation;

initiatedOcppOperations.erase(operation);

return;

}

}

//didn't find matching OcppOperation

Serial.print(F("[OcppEngine] Received CALLRESULT doesn't match any pending operation!\n"));

}

void OcppConnection::handleReqMessage(JsonDocument *json) {

OcppOperation *req = makeFromJson(json);

if (req == NULL) {

Serial.print(F("[OcppEngine] Couldn't make OppOperation from Request. Ignore request.\n"));

return;

}

handleReqMessage(json, req);

}

void OcppConnection::handleReqMessage(JsonDocument *json, OcppOperation *op) {

if (op == NULL) {

Serial.print(F("[OcppEngine] handleReqMessage: invalid argument\n"));

return;

}

receivedOcppOperations.push_back(op);; //enqueue so loop() plans conf sending

op->receiveReq(json); //"fire" the operation

}

void OcppConnection::handleErrMessage(JsonDocument *json) {

for (auto operation = initiatedOcppOperations.begin(); operation != initiatedOcppOperations.end(); ++operation){

boolean discardOperation = (*operation)->receiveError(json); //maybe rename to "consumed"?

if (discardOperation){

//TODO Review: are all recources freed here?

delete *operation;

initiatedOcppOperations.erase(operation);

return;

}

}

//No OcppOperation was aborted because of the error message

if (DEBUG_OUT) Serial.print(F("[OcppEngine] Received CALLERROR did not abort a pending operation\n"));

}

/*

* Tries to recover the Ocpp-Operation header from a broken message.

*

* Example input:

* [2, "75705e50-682d-404e-b400-1bca33d41e19", "ChangeConfiguration", {"key":"now the msg breaks...

*

* The Json library returns an error code when trying to deserialize that broken message. This

* function searches for the first occurence of the character '{' and writes "}]" after it.

*

* Example output:

* [2, "75705e50-682d-404e-b400-1bca33d41e19", "ChangeConfiguration", {}]

*

*/

size_t removePayload(const char *src, size_t src_size, char *dst, size_t dst_size) {

size_t res_len = 0;

for (size_t i = 0; i < src_size && i < dst_size-3; i++) {

if (src[i] == '\0'){

//no payload found within specified range. Cancel execution

break;

}

dst[i] = src[i];

if (src[i] == '{') {

dst[i+1] = '}';

dst[i+2] = ']';

res_len = i+3;

break;

}

}

dst[res_len] = '\0';

res_len++;

return res_len;

}