inline
strbuffer_t * json_array_to_string(json_t* array) {
size_t i = 0;
json_t* elem;
strbuffer_t* sb = strbuffer_new();
strbuffer_t* tempString;
strbuffer_append(sb, "[ ");
for(i = 0; i < array->size; i++ ) {
if(i != 0) {
strbuffer_append(sb, ", ");
}
elem = json_array_get(array, i);
tempString = json_to_string(elem);
strbuffer_append(sb, tempString->value);
strbuffer_destroy(tempString);
}
strbuffer_append(sb, " ]");
return sb;
}
int add_new_rpc_request(packet_t *incomePacket) {
portBASE_TYPE xStatus;
int retries;
xStatus = 0;
if(requestQueue != NULL && incomePacket) {
retries = SYSTEM_MSG_QUEUE_ADD_RETRIES;
while((xStatus != pdPASS) && (retries-- >= 0)) {
xStatus = xQueueSendToBack( requestQueue, &incomePacket, (portTickType) QUEUE_SEND_WAIT_TIMEOUT );
if(xStatus != pdPASS) { vTaskDelay(SYSTEM_TASK_DELAY); }
}
if((xStatus != pdPASS) && (retries < 0)) {
strbuffer_t *error = strbuffer_new();
strbuffer_append(error, "Unable to add message to requestQueue after ");
strbuffer_append(error, int_to_string(SYSTEM_MSG_QUEUE_ADD_RETRIES));
strbuffer_append(error, " retries");
logger(LEVEL_ERR, error->value);
strbuffer_destroy(&error);
packet_destroy(&incomePacket);
}
} else {
return FALSE;
}
return (xStatus == pdPASS);
}
int check_packet_type(packet_t *packet, packet_type_t pkgType) {
char *errorString;
strbuffer_t *errorBuffer;
if(packet->type != pkgType) {
strbuffer_t *logMsg = strbuffer_new();
strbuffer_append(logMsg, "Received packet with wrong type. Got ");
strbuffer_append(logMsg, int_to_string(packet->type));
strbuffer_append(logMsg, " instead of ");
strbuffer_append(logMsg, int_to_string(pkgType));
logger(LEVEL_ERR, logMsg->value);
strbuffer_destroy(&logMsg);
errorString = format_jsonrpc_error(JSONRPC_SERVER_ERROR, MSG_JSONRPC_ERRORS.server_error, "internal server error", 0);
errorBuffer = strbuffer_new();
strbuffer_append(errorBuffer, errorString);
packet_t * errorPacket = packet_new();
errorPacket->type = PKG_TYPE_OUTGOING_MESSAGE_STRING;
errorPacket->payload.stringData = errorBuffer;
errorPacket->transport = packet->transport;
sendOutputMessage(errorPacket);
return FALSE;
}
return TRUE;
}
strbuffer_t * json_to_string(json_t* object) {
strbuffer_t* sb = strbuffer_new();
strbuffer_t* tempString;
if(object == NULL) {
strbuffer_append(sb, "");
return sb;
}
switch(object->type) {
case JSON_OBJECT:
tempString = json_object_to_string(object);
strbuffer_append(sb, tempString->value);
strbuffer_destroy(tempString);
break;
case JSON_ARRAY:
tempString = json_array_to_string(object);
strbuffer_append(sb, tempString->value);
strbuffer_destroy(tempString);
break;
case JSON_STRING:
strbuffer_append(sb, "\"" );
strbuffer_append(sb, object->value );
strbuffer_append(sb, "\"" );
break;
case JSON_NUMBER:
strbuffer_append(sb, object->value);
break;
case JSON_TRUE:
strbuffer_append(sb, "true");
break;
case JSON_FALSE:
strbuffer_append(sb, "false");
break;
case JSON_NULL:
strbuffer_append(sb, "null");
break;
default:
break;
}
return sb;
}
inline
strbuffer_t * json_object_to_string(json_t* object){
json_t *key;
size_t i = 0;
strbuffer_t* sb = strbuffer_new();
strbuffer_t* tempString;
strbuffer_append(sb, "{ ");
if(object->children != NULL) {
for(key = object->children; key != NULL; key = key->next) {
if(i++ != 0) {
strbuffer_append(sb, ", ");
}
strbuffer_append(sb, "\"" );
strbuffer_append(sb, key->value );
strbuffer_append(sb, "\" : " );
tempString = json_to_string(key->children);
strbuffer_append(sb, tempString->value);
strbuffer_destroy(tempString);
}
}
strbuffer_append(sb, " }");
return sb;
}
inline
void format_error_text(strbuffer_t *errorText, json_error_t *error) {
if(errorText && error) {
strbuffer_append(errorText, "Text: ");
strbuffer_append(errorText, error->text);
strbuffer_append(errorText, " Source: ");
strbuffer_append(errorText, error->source);
strbuffer_append(errorText, " Line: ");
strbuffer_append(errorText, int_to_string(error->line));
strbuffer_append(errorText, " Column: ");
strbuffer_append(errorText, int_to_string(error->column));
strbuffer_append(errorText, " Position: ");
strbuffer_append(errorText, int_to_string(error->position));
}
}
json_error_t* parsingError(
json_error_code_t errCode,
char* errMsg,
jsmntok_t *token,
char* jsonString
) {
json_error_t* err = (json_error_t*) json_malloc(sizeof(json_error_t));
err->errorMsg = (strbuffer_t*) json_malloc(sizeof(json_error_t));
strbuffer_init(err->errorMsg);
err->errorCode = errCode;
strbuffer_append(err->errorMsg, errMsg);
if( token != NULL && jsonString != NULL) {
strbuffer_t *tokenText = json_token_tostr(jsonString, token);
strbuffer_append(err->errorMsg, " Error was in: ");
strbuffer_append(err->errorMsg, tokenText->value);
strbuffer_destroy(tokenText);
}
return err;
}
void node_send_json(json_t *array) {
strbuffer_t strbuff;
int rv = strbuffer_init(&strbuff);
assert(rv == 0);
if (0 == json_dump_callback(array, dump_to_strbuffer, (void *)&strbuff, 0)) {
strbuffer_append(&strbuff, "\n");
node_send_raw(strbuffer_value(&strbuff));
}
strbuffer_close(&strbuff);
json_decref(array);
}
static char console_filter_ecma48_writeCallback(char c, console_info_t *info, console_driver_t *output)
{
bool discard = 0;
bool complete = 0;
if (buffer_dictionary == NULL)
buffer_dictionary = dict_new();
strbuffer_t *buffer = dict_get(buffer_dictionary, info);
if (buffer == (void *)-1)
{
buffer = strbuffer_new(0);
dict_set(buffer_dictionary, info, buffer);
}
if (buffer->length == 0)
{
if (c == 27)
strbuffer_append(buffer, c);
else if (c == 0x9b)
{
strbuffer_append(buffer, 27);
strbuffer_append(buffer, '[');
}
else
discard = 1;
}
else if (strbuffer_last(buffer) == 27)
{
if (c == '[')
strbuffer_append(buffer, c);
else
discard = 1;
}
else
{
if ((c >= '0' && c <= '9') || c == ';')
strbuffer_append(buffer, c);
else if (c == 'm' || c == 'A' || c == 'B' || c == 'C' || c == 'D' || c == 'H' || c == 'J')
{
strbuffer_append(buffer, c);
complete = 1;
}
else
discard = 1;
}
if (complete == 1)
{
processControlSequence(info, buffer, output);
strbuffer_clear(buffer);
return 0;
}
if (discard == 0)
return 0;
if (complete == 0)
{
int i = 0;
while ( i < buffer->length )
{
output->write(info, strbuffer_chr(buffer, i++));
}
}
strbuffer_clear(buffer);
return c;
}
inline void parseJsonPacket(packet_t *jsonPacket) {
json_t *root;
json_error_t jsonError;
char *errorString;
strbuffer_t *errorBuffer;
strbuffer_t *logMsg;
if(!jsonPacket || (jsonPacket->type != PKG_TYPE_INCOME_MESSAGE_STRING)) {
logMsg = strbuffer_new();
strbuffer_append(logMsg, "parseJsonPacket : Wrong packet type was received. Got ");
strbuffer_append(logMsg, int_to_string(jsonPacket->type));
strbuffer_append(logMsg, " instead of ");
strbuffer_append(logMsg, int_to_string(PKG_TYPE_INCOME_MESSAGE_STRING));
logger(LEVEL_ERR, logMsg->value);
strbuffer_destroy(&logMsg);
return;
}
strbuffer_t *jsonString = jsonPacket->payload.stringData;
if(!jsonString) {
char *errorMessage = "parseJsonPacket : Unable to extract json string from packet";
logger(LEVEL_ERR, errorMessage);
errorString = format_jsonrpc_error(JSONRPC_SERVER_ERROR, MSG_JSONRPC_ERRORS.server_error, errorMessage, 0);
errorBuffer = strbuffer_new();
strbuffer_append(errorBuffer, errorString);
packet_lock(jsonPacket);
{
jsonPacket->type = PKG_TYPE_OUTGOING_MESSAGE_STRING;
jsonPacket->payload.stringData = errorBuffer;
}
packet_unlock(jsonPacket);
return;
}
logMsg = strbuffer_new();
strbuffer_append(logMsg, "parseJsonPacket Received json packet: transport=");
strbuffer_append(logMsg, int_to_string(jsonPacket->transport));
strbuffer_append(logMsg, " length=");
strbuffer_append(logMsg, int_to_string(jsonString->length));
logger(LEVEL_INFO, logMsg->value);
strbuffer_destroy(&logMsg);
root = json_loads(jsonString->value, 0, &jsonError);
//packet_destroy(jsonPacket);
if(root != NULL) {
/* TODO decode array or object
array --> batch (optional, but will be implemented only if there will be enough resources mcu flash)
if batch proceed requests one by one and put the batch flag
*/
logger(LEVEL_DEBUG, "parseJsonPacket String parsing was successful");
if(isJsonRPCVersion2_0(root)){
logMsg = strbuffer_new();
strbuffer_append(logMsg, "parseJsonPacket Packet parsing succeed. Transport=");
strbuffer_append(logMsg, int_to_string(jsonPacket->transport));
logger(LEVEL_INFO, logMsg->value);
strbuffer_destroy(&logMsg);
json_t* idObj = json_object_get(root, "id");
json_int_t id = json_integer_value(idObj);
packet_lock(jsonPacket);
{
strbuffer_destroy(&(jsonPacket->payload.stringData));
jsonPacket->type = PKG_TYPE_INCOME_JSONRPC_REQUEST;
jsonPacket->payload.jsonDoc = root;
jsonPacket->id = id;
}
packet_unlock(jsonPacket);
return;
} else {
// TODO print_help(transport);
logMsg = strbuffer_new();
strbuffer_append(logMsg, ".parseJsonPacket : ");
strbuffer_append(logMsg, MSG_MAINTASKS.parseJsonPacket.invalid_jsonrpc_2_0);
logger(LEVEL_WARN, logMsg->value);
strbuffer_destroy(&logMsg);
json_int_t id = 0;
if(json_object_get(root, "id") != NULL) {
id = json_integer_value(json_object_get(root, "id"));
}
json_decref(root);
errorString = format_jsonrpc_error(JSONRPC_INVALID_REQUEST, MSG_JSONRPC_ERRORS.invalid_request, MSG_MAINTASKS.parseJsonPacket.invalid_jsonrpc_2_0, id);
errorBuffer = strbuffer_new();
strbuffer_append(errorBuffer, errorString);
packet_lock(jsonPacket);
{
strbuffer_destroy(&(jsonPacket->payload.stringData));
jsonPacket->type = PKG_TYPE_OUTGOING_MESSAGE_STRING;
jsonPacket->payload.stringData = errorBuffer;
jsonPacket->id = id;
}
packet_unlock(jsonPacket);
return;
}
} else {
strbuffer_t *errorText = strbuffer_new();
format_error_text(errorText, &jsonError);
logMsg = strbuffer_new();
strbuffer_append(logMsg, "parseJsonPacket Packet parsing failed: ");
strbuffer_append(logMsg, errorText->value);
logger(LEVEL_WARN, logMsg->value);
strbuffer_destroy(&logMsg);
errorString = format_jsonrpc_error(JSONRPC_PARSE_ERROR, MSG_JSONRPC_ERRORS.parse_error, errorText->value, 0);
errorBuffer = strbuffer_new();
strbuffer_append(errorBuffer, errorString);
strbuffer_destroy(&errorText);
packet_lock(jsonPacket);
{
strbuffer_destroy(&(jsonPacket->payload.stringData));
jsonPacket->type = PKG_TYPE_OUTGOING_MESSAGE_STRING;
jsonPacket->payload.stringData = errorBuffer;
}
packet_unlock(jsonPacket);
return;
}
}
void tskParseJson(void *pvParameters) {
packet_t *incomePacket = NULL;
json_t *requestJson = NULL;
const char *transportString;
char *errorString;
strbuffer_t *errorBuffer;
strbuffer_t *logMsg;
portBASE_TYPE xStatus;
while(1) {
if(uxQueueMessagesWaiting(msgIncomeQueue) > 0) {
xStatus = xQueueReceive( msgIncomeQueue, &incomePacket, (portTickType) QUEUE_RECEIVE_WAIT_TIMEOUT );
if( (xStatus == pdPASS) && incomePacket) {
if(incomePacket->type != PKG_TYPE_INCOME_MESSAGE_STRING) {
logMsg = strbuffer_new();
strbuffer_append(logMsg, "Received packet with wrong type. Got ");
strbuffer_append(logMsg, int_to_string(incomePacket->type));
strbuffer_append(logMsg, " instead of ");
strbuffer_append(logMsg, int_to_string(PKG_TYPE_INCOME_MESSAGE_STRING));
logger(LEVEL_ERR, logMsg->value);
strbuffer_destroy(&logMsg);
errorString = format_jsonrpc_error(JSONRPC_SERVER_ERROR, MSG_JSONRPC_ERRORS.server_error, "internal server error", 0);
errorBuffer = strbuffer_new();
strbuffer_append(errorBuffer, errorString);
packet_t * errorPacket = packet_new();
errorPacket->type = PKG_TYPE_OUTGOING_MESSAGE_STRING;
errorPacket->payload.stringData = errorBuffer;
errorPacket->transport = incomePacket->transport;
sendOutputMessage(errorPacket);
packet_destroy(&incomePacket);
continue;
}
logMsg = strbuffer_new();
strbuffer_append(logMsg, "Received packet. len = ");
strbuffer_append(logMsg, int_to_string(incomePacket->payload.stringData->length));
strbuffer_append(logMsg, " transport=");
strbuffer_append(logMsg, int_to_string(incomePacket->transport));
logger(LEVEL_INFO, logMsg->value);
strbuffer_destroy(&logMsg);
parseJsonPacket(incomePacket);
strbuffer_t *logMsg;
switch(incomePacket->type) {
case PKG_TYPE_OUTGOING_MESSAGE_STRING:
logger(LEVEL_WARN, "Unable to parse incoming json packet. Sending message to client");
sendOutputMessage(incomePacket);
break;
case PKG_TYPE_INCOME_JSONRPC_REQUEST:
logMsg = strbuffer_new();
strbuffer_append(logMsg, "New jsonrpc request. id=");
strbuffer_append(logMsg, int_to_string(incomePacket->id));
strbuffer_append(logMsg, "transport=");
strbuffer_append(logMsg, int_to_string(incomePacket->transport));
logger(LEVEL_INFO, logMsg->value);
strbuffer_destroy(&logMsg);
//logger_format(LEVEL_INFO, "New jsonrpc request. id=%d transport=%s", incomePacket->id, transportString);
add_new_rpc_request(incomePacket);
break;
default:
logMsg = strbuffer_new();
strbuffer_append(logMsg, "Wrong packet type was returned fron json parse function. type_returned=");
strbuffer_append(logMsg, int_to_string(incomePacket->type));
logger(LEVEL_ERR, logMsg->value);
strbuffer_destroy(&logMsg);
packet_destroy(&incomePacket);
break;
}
// if(requestJson) {
// logger_format(LEVEL_INFO, "Parsing packet was successful.");
//
//// json_incref(requestJson);
// logger(LEVEL_DEBUG, "Adding json to request queue");
// xStatus = xQueueSendToBack( requestQueue, &requestJson, (portTickType) QUEUE_SEND_WAIT_TIMEOUT );
// if( xStatus != pdPASS ){
//
// json_object_del(requestJson, "method");
// json_object_del(requestJson, "params");
//
// json_t* errorObj = create_error(JSONRPC_SERVER_ERROR, MSG_JSONRPC_ERRORS.server_error);
// json_object_set_new(errorObj, "data", json_string(MSG_MAINTASKS.tskAbstractReader.device_is_busy_timeout));
//
// json_object_set_new(requestJson, "error", errorObj);
//
// logger_format(LEVEL_WARN, "%s", MSG_MAINTASKS.tskAbstractReader.device_is_busy_timeout);
//
// // send error back to client using output queue
// xStatus = xQueueSendToBack( responseQueue, &requestJson, (portTickType) QUEUE_SEND_WAIT_TIMEOUT );
// if( xStatus != pdPASS ){
// char* id = json_dumps(json_object_get(requestJson, "id"), JSON_ENCODE_ANY);
// transport_type_t transport = json_integer_value(json_object_get(requestJson, "transport"));
// json_object_del(requestJson, "transport");
// json_decref(requestJson);
// // send using error reporting function
// if(id && transport) {
// report_error_to_sender(
// transport,
// MSG_JSONRPC_ERRORS.general_error_json,
// JSONRPC_SERVER_ERROR, /* <-- code */
// MSG_JSONRPC_ERRORS.server_error, /* <-- message */
// MSG_MAINTASKS.tskAbstractReader.device_is_busy_timeout , /* <-- data */
// id
// );
// }
// if(id) vPortFree(id);
// logger_format(LEVEL_WARN, "%s", MSG_MAINTASKS.tskAbstractReader.device_is_busy_timeout);
// }
// } else {
// logger(LEVEL_DEBUG, "Json was added to request queue");
// }
// }
// json_decref(requestJson);
}
}
taskYIELD();
}
}
void tskHandleRequests(void *pvParameters) {
packet_t *requestPacket = NULL;
packet_t *responsePacket = NULL;
json_t *idObj;
json_int_t id;
char *errorString;
strbuffer_t *errorBuffer;
strbuffer_t *logMsg;
portBASE_TYPE xStatus;
while(1) {
if(uxQueueMessagesWaiting(requestQueue) > 0) {
xStatus = xQueueReceive( requestQueue, &requestPacket, (portTickType) QUEUE_RECEIVE_WAIT_TIMEOUT );
if( (xStatus == pdPASS) && requestPacket) {
if(check_packet_type(requestPacket, PKG_TYPE_INCOME_JSONRPC_REQUEST) != TRUE) {
logger(LEVEL_ERR, "Wrong data packet from requestQueue. Deleting packet" );
packet_destroy(&requestPacket);
continue;
}
logMsg = strbuffer_new();
strbuffer_append(logMsg, "Received new request: id=");
strbuffer_append(logMsg, int_to_string(requestPacket->id));
strbuffer_append(logMsg, " transport=");
strbuffer_append(logMsg, int_to_string(requestPacket->transport));
logger(LEVEL_INFO, logMsg->value);
strbuffer_destroy(&logMsg);
handle_request(requestPacket);
responsePacket = requestPacket;
if(responsePacket) {
if(requestPacket->type == PKG_TYPE_OUTCOME_JSONRPC_NOTIFICATION) {
logger(LEVEL_INFO, "Request was notification only. Destroying response");
packet_destroy(&requestPacket);
packet_destroy(&responsePacket);
continue;
}
if(check_packet_type(requestPacket, PKG_TYPE_OUTCOME_JSONRPC_RESPONSE) != TRUE) {
logger(LEVEL_ERR, "Wrong response packet. Deleting packet" );
packet_destroy(&requestPacket);
continue;
}
logMsg = strbuffer_new();
strbuffer_append(logMsg, "Received response: id=");
strbuffer_append(logMsg, int_to_string(responsePacket->id));
strbuffer_append(logMsg, " transport=");
strbuffer_append(logMsg, int_to_string(responsePacket->transport));
logger(LEVEL_INFO, logMsg->value);
strbuffer_destroy(&logMsg);
logger(LEVEL_DEBUG, "creating json string from json object");
strbuffer_t *stringData = strbuffer_new();
char *jsonData = json_dumps(responsePacket->payload.jsonDoc, JSON_ENCODE_ANY );
if(jsonData) {
logger(LEVEL_DEBUG, "json string was created. Creating packet to send.");
strbuffer_append(stringData, jsonData);
logMsg = strbuffer_new();
strbuffer_append(logMsg, "Sending new packet: packet_length=");
strbuffer_append(logMsg, int_to_string(stringData->length));
strbuffer_append(logMsg, " packet_transport=");
strbuffer_append(logMsg, int_to_string(responsePacket->transport));
logger(LEVEL_DEBUG, logMsg->value);
strbuffer_destroy(&logMsg);
} else {
logMsg = strbuffer_new();
strbuffer_append(logMsg, "Unable to create string from response json: id=");
strbuffer_append(logMsg, int_to_string(responsePacket->id));
strbuffer_append(logMsg, " transport=");
strbuffer_append(logMsg, int_to_string(responsePacket->transport));
logger(LEVEL_WARN, logMsg->value);
strbuffer_destroy(&logMsg);
errorString = format_jsonrpc_error(JSONRPC_SERVER_ERROR, MSG_JSONRPC_ERRORS.server_error, "internal server error", responsePacket->id);
strbuffer_append(stringData, errorString);
}
vPortFree(jsonData);
packet_lock(responsePacket);
{
json_decref(responsePacket->payload.jsonDoc);
responsePacket->type = PKG_TYPE_OUTGOING_MESSAGE_STRING;
responsePacket->payload.stringData = stringData;
}
packet_unlock(responsePacket);
sendOutputMessage(responsePacket);
// idObj = json_object_get(responseJson, "id");
// id = json_integer_value(idObj);
//
// json_t *transportObject = json_object_get(responseJson, "transport");
// json_int_t transport = json_integer_value(transportObject);
//
// logger_format(LEVEL_INFO, "Received response. id = %d transport=%s", (int) id, transport_type_to_str((transport_type_t) transport));
//
// xStatus = xQueueSendToBack( responseQueue, &responseJson, (portTickType) QUEUE_SEND_WAIT_TIMEOUT );
// if( xStatus != pdPASS ){
// char* idStr = json_dumps(json_object_get(requestPacket, "id"), JSON_ENCODE_ANY);
// json_int_t transport = json_integer_value(json_object_get(requestPacket, "transport"));
// json_object_del(requestPacket, "transport");
// json_decref(requestJson);
// // send using error reporting function
// if(id && transport) {
// report_error_to_sender(
// (transport_type_t) transport,
// MSG_JSONRPC_ERRORS.general_error_json,
// JSONRPC_SERVER_ERROR, /* <-- code */
// MSG_JSONRPC_ERRORS.server_error, /* <-- message */
// MSG_MAINTASKS.tskAbstractReader.device_is_busy_timeout , /* <-- data */
// idStr
// );
// }
// if(idStr) vPortFree(idStr);
// logger_format(LEVEL_INFO, "Unable to add response to queue. Request id = %d", (int) id );
// } else {
// logger(LEVEL_DEBUG, "Response was added to response queue");
// }
}
// json_decref(requestPacket);
}
}
taskYIELD();
}
}
