363 lines
8.0 KiB
C
363 lines
8.0 KiB
C
/* Icecast
|
|
*
|
|
* This program is distributed under the GNU General Public License, version 2.
|
|
* A copy of this license is included with this source.
|
|
*
|
|
* Copyright 2018-2020, Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>,
|
|
*/
|
|
|
|
/**
|
|
* This file contains functions for rendering JSON.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "json.h"
|
|
|
|
#include "logging.h"
|
|
#define CATMODULE "json"
|
|
|
|
#define MAX_RECURSION 64
|
|
|
|
struct json_renderer_tag {
|
|
unsigned int flags;
|
|
|
|
int valid;
|
|
|
|
char *buffer;
|
|
size_t bufferlen;
|
|
size_t bufferfill;
|
|
|
|
char levelinfo[MAX_RECURSION];
|
|
size_t level;
|
|
};
|
|
|
|
static int allocate_buffer(json_renderer_t *renderer, size_t needed)
|
|
{
|
|
size_t required = needed + renderer->level;
|
|
size_t have = renderer->bufferlen - renderer->bufferfill;
|
|
|
|
if (!renderer->valid)
|
|
return 1;
|
|
|
|
if (have)
|
|
have--;
|
|
|
|
if (have < required) {
|
|
size_t want;
|
|
char *n;
|
|
|
|
if (required < 128)
|
|
required = 128;
|
|
|
|
want = renderer->bufferfill + required;
|
|
if (want < 512)
|
|
want = 512;
|
|
|
|
n = realloc(renderer->buffer, want);
|
|
|
|
if (!n)
|
|
return 1;
|
|
|
|
renderer->buffer = n;
|
|
renderer->bufferlen = want;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void json_renderer_destroy(json_renderer_t *renderer)
|
|
{
|
|
if (!renderer)
|
|
return;
|
|
|
|
renderer->valid = 0;
|
|
|
|
free(renderer->buffer);
|
|
free(renderer);
|
|
}
|
|
|
|
json_renderer_t * json_renderer_create(unsigned int flags)
|
|
{
|
|
json_renderer_t *renderer = calloc(1, sizeof(json_renderer_t));
|
|
|
|
if (!renderer)
|
|
return NULL;
|
|
|
|
renderer->flags = flags;
|
|
renderer->valid = 1;
|
|
|
|
renderer->levelinfo[0] = '0';
|
|
renderer->level = 1;
|
|
|
|
if (allocate_buffer(renderer, 0) != 0) {
|
|
json_renderer_destroy(renderer);
|
|
return NULL;
|
|
}
|
|
|
|
return renderer;
|
|
}
|
|
|
|
char * json_renderer_finish(json_renderer_t **rendererptr)
|
|
{
|
|
json_renderer_t *renderer;
|
|
char *ret;
|
|
|
|
if (!rendererptr)
|
|
return NULL;
|
|
|
|
renderer = *rendererptr;
|
|
*rendererptr = NULL;
|
|
|
|
if (!renderer)
|
|
return NULL;
|
|
|
|
if (!renderer->valid) {
|
|
json_renderer_destroy(renderer);
|
|
return NULL;
|
|
}
|
|
|
|
for (; renderer->level; renderer->level--) {
|
|
switch (renderer->levelinfo[renderer->level-1]) {
|
|
case '0':
|
|
renderer->buffer[renderer->bufferfill++] = 0;
|
|
break;
|
|
case 'o':
|
|
case 'O':
|
|
renderer->buffer[renderer->bufferfill++] = '}';
|
|
break;
|
|
case 'a':
|
|
case 'A':
|
|
renderer->buffer[renderer->bufferfill++] = ']';
|
|
break;
|
|
default:
|
|
json_renderer_destroy(renderer);
|
|
return NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ret = renderer->buffer;
|
|
renderer->buffer = NULL;
|
|
json_renderer_destroy(renderer);
|
|
return ret;
|
|
}
|
|
|
|
static int write_raw(json_renderer_t *renderer, const char *raw, int begin)
|
|
{
|
|
size_t rawlen = strlen(raw);
|
|
size_t want = rawlen;
|
|
char level;
|
|
char seperator = 0;
|
|
|
|
if (!renderer->valid)
|
|
return 1;
|
|
|
|
level = renderer->levelinfo[renderer->level-1];
|
|
|
|
if (begin) {
|
|
if (level == 'O' || level == 'A') {
|
|
seperator = ',';
|
|
} else if (level == 'o') {
|
|
renderer->levelinfo[renderer->level-1] = 'O';
|
|
} else if (level == 'a') {
|
|
renderer->levelinfo[renderer->level-1] = 'A';
|
|
} else if (level == 'P') {
|
|
seperator = ':';
|
|
renderer->level--;
|
|
}
|
|
}
|
|
|
|
if (seperator)
|
|
want++;
|
|
|
|
if (allocate_buffer(renderer, want) != 0)
|
|
return 1;
|
|
|
|
if (seperator)
|
|
renderer->buffer[renderer->bufferfill++] = seperator;
|
|
|
|
memcpy(&(renderer->buffer[renderer->bufferfill]), raw, rawlen);
|
|
renderer->bufferfill += rawlen;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int want_write_value(json_renderer_t *renderer)
|
|
{
|
|
char level;
|
|
|
|
|
|
if (!renderer || !renderer->valid)
|
|
return 1;
|
|
|
|
level = renderer->levelinfo[renderer->level-1];
|
|
if (level == 'o' || level == 'O') {
|
|
renderer->valid = 0;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void json_renderer_begin(json_renderer_t *renderer, json_element_type_t type)
|
|
{
|
|
const char *towrite;
|
|
char next_level;
|
|
|
|
if (!renderer || !renderer->valid)
|
|
return;
|
|
|
|
if (renderer->level == MAX_RECURSION) {
|
|
renderer->valid = 0;
|
|
return;
|
|
}
|
|
|
|
switch (type) {
|
|
case JSON_ELEMENT_TYPE_OBJECT:
|
|
next_level = 'o';
|
|
towrite = "{";
|
|
break;
|
|
case JSON_ELEMENT_TYPE_ARRAY:
|
|
next_level = 'a';
|
|
towrite = "[";
|
|
break;
|
|
default:
|
|
renderer->valid = 0;
|
|
return;
|
|
}
|
|
|
|
write_raw(renderer, towrite, 1);
|
|
renderer->levelinfo[renderer->level++] = next_level;
|
|
}
|
|
|
|
void json_renderer_end(json_renderer_t *renderer)
|
|
{
|
|
if (!renderer || !renderer->valid)
|
|
return;
|
|
|
|
switch (renderer->levelinfo[renderer->level-1]) {
|
|
case 'o':
|
|
case 'O':
|
|
write_raw(renderer, "}", 0);
|
|
renderer->level--;
|
|
break;
|
|
case 'a':
|
|
case 'A':
|
|
write_raw(renderer, "]", 0);
|
|
renderer->level--;
|
|
break;
|
|
default:
|
|
renderer->valid = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void json_renderer_write_null(json_renderer_t *renderer)
|
|
{
|
|
if (want_write_value(renderer) != 0)
|
|
return;
|
|
write_raw(renderer, "null", 1);
|
|
}
|
|
|
|
void json_renderer_write_boolean(json_renderer_t *renderer, int val)
|
|
{
|
|
if (want_write_value(renderer) != 0)
|
|
return;
|
|
write_raw(renderer, val ? "true" : "false", 1);
|
|
}
|
|
|
|
static void write_string(json_renderer_t *renderer, const char *string, unsigned int flags)
|
|
{
|
|
// Allocate for the quotes plus 110% of the string length to account for escapes.
|
|
if (allocate_buffer(renderer, 2 + ((strlen(string) * 110) / 100)) != 0)
|
|
return;
|
|
|
|
write_raw(renderer, "\"", 1);
|
|
|
|
for (; *string && renderer->valid; string++) {
|
|
if (renderer->bufferfill == renderer->bufferlen) {
|
|
// Reallocate buffer, same rules as above, expect that we only need one additional quote.
|
|
if (allocate_buffer(renderer, 1 + ((strlen(string) * 110) / 100)) != 0)
|
|
return;
|
|
}
|
|
|
|
if (((unsigned char)*string) < 0x20) {
|
|
char buf[7];
|
|
snprintf(buf, sizeof(buf), "\\u%.4x", (unsigned int)*string);
|
|
write_raw(renderer, buf, 0);
|
|
} else if (*string == '\\' || *string == '"') {
|
|
if (allocate_buffer(renderer, 2) != 0)
|
|
return;
|
|
renderer->buffer[renderer->bufferfill++] = '\\';
|
|
renderer->buffer[renderer->bufferfill++] = *string;
|
|
} else {
|
|
renderer->buffer[renderer->bufferfill++] = *string;
|
|
}
|
|
}
|
|
|
|
write_raw(renderer, "\"", 0);
|
|
}
|
|
|
|
void json_renderer_write_key(json_renderer_t *renderer, const char *key, unsigned int flags)
|
|
{
|
|
char level;
|
|
|
|
if (!renderer || !renderer->valid)
|
|
return;
|
|
|
|
level = renderer->levelinfo[renderer->level-1];
|
|
if (level != 'o' && level != 'O') {
|
|
renderer->valid = 0;
|
|
return;
|
|
}
|
|
|
|
if (renderer->level == MAX_RECURSION) {
|
|
renderer->valid = 0;
|
|
return;
|
|
}
|
|
|
|
write_string(renderer, key, flags);
|
|
|
|
renderer->levelinfo[renderer->level++] = 'P';
|
|
}
|
|
|
|
void json_renderer_write_string(json_renderer_t *renderer, const char *string, unsigned int flags)
|
|
{
|
|
if (want_write_value(renderer) != 0)
|
|
return;
|
|
write_string(renderer, string, flags);
|
|
}
|
|
|
|
void json_renderer_write_int(json_renderer_t *renderer, intmax_t val)
|
|
{
|
|
char buf[80];
|
|
|
|
if (want_write_value(renderer) != 0)
|
|
return;
|
|
|
|
snprintf(buf, sizeof(buf), "%" PRIdMAX, val);
|
|
|
|
write_raw(renderer, buf, 1);
|
|
}
|
|
|
|
void json_renderer_write_uint(json_renderer_t *renderer, uintmax_t val)
|
|
{
|
|
char buf[80];
|
|
|
|
if (want_write_value(renderer) != 0)
|
|
return;
|
|
|
|
snprintf(buf, sizeof(buf), "%" PRIuMAX, val);
|
|
|
|
write_raw(renderer, buf, 1);
|
|
}
|