void json_object_free(json_t *root) {
// json_t* last;
// json_t* next;
if(root == NULL) {
return;
}
if(root->children != NULL) {
json_object_free(root->children);
root->children = NULL;
}
if(root->next != NULL) {
json_object_free(root->next);
root->next = NULL;
}
// if(root->last != NULL) {
// json_object_free(root->last);
// root->last = NULL;
// }
if(root->value != NULL) {
json_free(root->value);
root->value = NULL;
}
json_free(root);
}
void json_object_free(JSON_object o){
if(! o) {
return;
}
json_object_free(o->left);
json_object_free(o->right);
free(o->key);
json_free(o->value);
free(o);
}
void json_free(JSON j){
if(j->type == ARRAYTYPE) {
json_array_free(j->aVal);
} else if( j->type == OBJECTTYPE) {
json_object_free(j->oVal);
} else if ( j-> type == NULLTYPE) {
return;
}
free(j);
}
void json_object_free(json_object *data)
{
if (data->type == ARRAY || data->type == TABLE)
while (data->value.item)
{
json_object *item = data->value.item;
data->value.item = item->next;
json_object_free(item);
free(item);
}
else if (data->type == TEXT)
free(data->value.text);
}
json_object json_parse(wchar_t json[],wchar_t **message,long* error_pos)
{
parse_engine result;
result.data.type = NONE;
result.pos = json;
result.json = json;
if (parsing(&result, &result.data))
{
if(message) *message = result.message;
json_object_free(&result.data);
if(error_pos) *error_pos = result.pos - result.json;
json_object null_item;
null_item.type = NONE;
return null_item;
}
if(message) *message = (wchar_t *)L"SUCCEED";
if(error_pos) *error_pos = 0;
return result.data;
}
static int parsing(parse_engine* engine, json_object *pos_parse)
{
wchar_t c = next_token(engine);
switch (c)
{
case 0:
engine->message = (wchar_t *)L"Unexpected end";
return 1;
case '[':
{
pos_parse->type = ARRAY;
pos_parse->value.item = 0;
if (next_token(engine) == ']') return 0;
--engine->pos;
while (1)
{
json_object *item = insert_item(pos_parse, 0);
if (next_token(engine) == ',')
{
--engine->pos;
}
else
{
--engine->pos;
if (parsing(engine, item))
return 1;
}
switch (next_token(engine))
{
case ',':
if (next_token(engine) == ']')
return 0;
--engine->pos;
break;
case ']':
return 0;
default:
engine->message = (wchar_t *)L":Expected a ',' or ']'";
return 1;
}
}
}
case '{':
{
pos_parse->type = TABLE;
pos_parse->value.item = 0;
if (next_token(engine) == '}') return 0;
--engine->pos;
while (1)
{
json_object key;
if (parsing(engine, &key) || key.type != TEXT)
{
json_object_free(&key);
engine->message = (wchar_t *)L"Illegal key of pair";
return 1;
}
if (next_token(engine) != ':')
{
engine->message = (wchar_t *)L"Expected a ':'";
return 1;
}
json_object* item=insert_item(pos_parse, key.value.text);
json_object_free(&key);
if (parsing(engine, item))
{
return 1;
}
switch (next_token(engine))
{
case ';':
case ',':
if (next_token(engine) == '}')
return 0;
--engine->pos;
break;
case '}':
return 0;
default:
engine->message = (wchar_t *)L"Expected a ',' or '}'";
return 1;
}
}
}
case '\'':
case '"':
{
pos_parse->type = TEXT;
pos_parse->value.text = 0;
strlist str = { 0 };
while (1)
{
wchar_t ch = *engine->pos++;
switch (ch)
{
case '\n':
case '\r':
strlist_free(&str);
engine->message = (wchar_t *)L"Unterminated string";
return 1;
case '\\':
ch = *engine->pos++;
switch (ch)
{
case 'b':
strlist_append(&str, L"\b", 1);
break;
case 't':
strlist_append(&str, L"\t", 1);
break;
case 'n':
strlist_append(&str, L"\n", 1);
break;
case 'f':
strlist_append(&str, L"\f", 1);
break;
case 'r':
strlist_append(&str, L"\r", 1);
break;
case '"':
case '\'':
case '\\':
case '/':
strlist_append(&str, &ch, 1);
break;
case 'u': {
wchar_t num = 0;
for (int i = 0; i < 4; ++i)
{
wchar_t tmp = *engine->pos++;
if (tmp >= '0'&&tmp <= '9')
tmp = tmp - '0';
else if (tmp >= 'A'&&tmp <= 'F')
tmp = tmp - ('A' - 10);
else if (tmp >= 'a'&&tmp <= 'f')
tmp = tmp - ('a' - 10);
num = num << 4 | tmp;
}
strlist_append(&str, &num, 1);
break;
}
default:
strlist_free(&str);
engine->message = (wchar_t *)L"Illegal escape";
return 1;
}
break;
default:
if (ch == c)
{
pos_parse->value.text = strlist_to_string(&str);
strlist_free(&str);
return 0;
}
strlist_append(&str, &ch, 1);
break;
}
}
break;
}
}
int length = 0;
char buffer[32] = { 0 };
while (c >= ' ') {
if(strchr(",:]}/\\\"[{;=#", c))
break;
if(length<sizeof(buffer)&&strchr("0123456789+-.AEFLNRSTUaeflnrstu",c))
{
buffer[length++]=(char)c;
c = *engine->pos++;
}
else{
engine->message=(wchar_t *)L"Illegal Value";
return 1;
}
}
--engine->pos;
if (!length)
{
pos_parse->type = TEXT;
pos_parse->value.text = (wchar_t *)malloc(sizeof(wchar_t));
pos_parse->value.text[0] = 0;
return 0;
}
else {
if (!strcmp(buffer, "TRUE") || !strcmp(buffer, "true"))
{
pos_parse->type = BOOLEAN;
pos_parse->value.boolean = true;
return 0;
}
else if (!strcmp(buffer, "FALSE") || !strcmp(buffer, "false"))
{
pos_parse->type = BOOLEAN;
pos_parse->value.boolean = false;
return 0;
}
else if (!strcmp(buffer, "NULL") || !strcmp(buffer, "null"))
{
pos_parse->type = NONE;
return 0;
}
pos_parse->type = (strstr(buffer, ".") || strstr(buffer, "e") || strstr(buffer, "E")) ? DECIMAL : INTEGER;
const char *format = pos_parse->type == INTEGER ? "%lld" : "%lf";
if (sscanf(buffer, format, &pos_parse->value)) return 0;
engine->message = (wchar_t *)L"Unexpected end";
return 1;
}
}
json_error_t * json_from_string(char *jsonString, json_t **destObject) {
int resultCode = 0;
jsmn_parser parser;
jsmntok_t tokens[TOKENS_COUNT];
size_t tokenIndex = 0;
jsmntok_t *failedToken = NULL;
if(jsonString == NULL) {
return parsingError(
JSON_NULL_POINTER,
"Error: Json string is NULL.",
NULL,
NULL
);
}
memset(tokens, 0, TOKENS_COUNT*sizeof(jsmntok_t));
json_t *root = NULL;
jsmn_init(&parser);
resultCode = jsmn_parse(&parser, jsonString, tokens, TOKENS_COUNT);
if(resultCode != JSMN_SUCCESS) {
failedToken = ((tokenIndex <= TOKENS_COUNT) ? &tokens[tokenIndex] : NULL);
switch(resultCode) {
case JSMN_ERROR_INVAL:
return parsingError(
JSON_INVALID_INPUT,
"Error: Invalid character inside JSON string.",
failedToken,
jsonString
);
case JSMN_ERROR_NOMEM:
return parsingError(
JSON_MEMORY_ALLOC_FAILED,
"Error: Not enough tokens were provided. Please add more tokens in application configuration.",
failedToken,
jsonString
);
case JSMN_ERROR_PART:
return parsingError(
JSON_INVALID_INPUT,
"Error: The string is not a full JSON packet, more bytes expected.",
failedToken,
jsonString
);
case JSMN_SUCCESS:
break;
default:
return parsingError(
JSON_INLLEGAL_STATE_EXCEPTION,
"Error: Invalid jsmp result code. Normally program should not reach here.",
NULL,
NULL
);
}
}
json_error_t *parseError = NULL;
parseError = createJsonObject(&root, jsonString, tokens, TOKENS_COUNT, &tokenIndex );
if(parseError != NULL) {
json_object_free(root);
return parseError;
}
*destObject = root;
return NULL; /* none errors */
}
inline
void freeResources(json_t* root, json_t* key, json_t* value) {
json_object_free(root);
json_object_free(key);
json_object_free(value);
}
void log_ref_display(struct vty *vty, uint32_t code, bool json)
{
struct log_ref *ref;
struct json_object *top = NULL, *obj = NULL;
struct list *errlist;
struct listnode *ln;
if (json)
top = json_object_new_object();
pthread_mutex_lock(&refs_mtx);
{
errlist = code ? list_new() : hash_to_list(refs);
}
pthread_mutex_unlock(&refs_mtx);
if (code) {
ref = log_ref_get(code);
if (!ref) {
vty_out(vty, "Code %"PRIu32" - Unknown\n", code);
return;
}
listnode_add(errlist, ref);
}
for (ALL_LIST_ELEMENTS_RO(errlist, ln, ref)) {
if (json) {
char key[11];
snprintf(key, sizeof(key), "%"PRIu32, ref->code);
obj = json_object_new_object();
json_object_string_add(obj, "title", ref->title);
json_object_string_add(obj, "description",
ref->description);
json_object_string_add(obj, "suggestion",
ref->suggestion);
json_object_object_add(top, key, obj);
} else {
char pbuf[256];
char ubuf[256];
snprintf(pbuf, sizeof(pbuf), "\nError %"PRIu32" - %s",
ref->code, ref->title);
memset(ubuf, '=', strlen(pbuf));
ubuf[strlen(pbuf)] = '\0';
vty_out(vty, "%s\n%s\n", pbuf, ubuf);
vty_out(vty, "Description:\n%s\n\n", ref->description);
vty_out(vty, "Recommendation:\n%s\n", ref->suggestion);
}
}
if (json) {
const char *str = json_object_to_json_string_ext(
top, JSON_C_TO_STRING_PRETTY);
vty_out(vty, "%s\n", str);
json_object_free(top);
}
list_delete(&errlist);
}
