void test_suite_precincts(JSON_Value *root_value) {
JSON_Object *root_object;
JSON_Array *array;
TEST(root_value);
TEST(json_value_get_type(root_value) == JSONObject);
root_object = json_value_get_object(root_value);
unsigned int number_of_precincts = (int) json_object_get_number(root_object, "number_of_precincts");
printf("number_of_precincts: %d\n", number_of_precincts);
TEST(number_of_precincts == 60);
array = json_object_get_array(root_object, "precincts");
if (array != NULL && json_array_get_count(array) == number_of_precincts) {
JSON_Object *precinct_object;
JSON_Array *layers_array;
int id, coord_x, coord_y;
unsigned int j;
for(j = 0; j < number_of_precincts; j++) {
precinct_object = json_array_get_object(array, j);
id = (int) json_object_get_number(precinct_object, "id");
coord_x = (int) json_object_get_number(precinct_object, "coord_x");
coord_y = (int) json_object_get_number(precinct_object, "coord_y");
printf("id: %d \t coord_x: %d \t coord_y: %d\n", id, coord_x, coord_y);
layers_array = json_object_get_array(precinct_object, "layers");
if (layers_array != NULL && json_array_get_count(layers_array) >= 1) {
JSON_Object *layer_object;
int ql, bytes, psnr;
unsigned k;
for(k = 0; k < json_array_get_count(layers_array); k++) {
layer_object = json_array_get_object(layers_array, k);
ql = (int) json_object_get_number(layer_object, "ql");
bytes = (int) json_object_get_number(layer_object, "bytes");
psnr = (int) json_object_get_number(layer_object, "psnr");
printf("\tql: %d \t bytes: %d \t psnr: %d\n", ql, bytes, psnr);
}
} else {
}
}
} else {
tests_failed++;
}
}
bud_error_t bud_config_load_backend_list(bud_config_t* config,
JSON_Object* obj,
bud_config_backend_list_t* backends) {
bud_error_t err;
JSON_Array* backend;
int i;
backends->external_count = 0;
err = bud_hashmap_init(&backends->external_map, kBudBackendMapSize);
if (!bud_is_ok(err))
return err;
backend = json_object_get_array(obj, "backend");
backends->count = backend == NULL ? 0 : json_array_get_count(backend);
backends->list = calloc(backends->count, sizeof(*backends->list));
if (backends->list == NULL)
return bud_error_str(kBudErrNoMem, "bud_backend_list_t");
for (i = 0; i < backends->count; i++) {
err = bud_config_load_backend(config,
json_array_get_object(backend, i),
&backends->list[i],
&backends->external_map,
&backends->external_count);
if (!bud_is_ok(err))
break;
}
if (!bud_is_ok(err)) {
free(backends->list);
backends->list = NULL;
}
return err;
}
void parseJSON() {
JSON_Value *root_value = json_parse_string(getData);
if (root_value != NULL) {
JSON_Value_Type type = root_value->type;
if (type == JSONArray) {
JSON_Array *stations = json_value_get_array(root_value);
char lookupCallsign[32];
sprintf(lookupCallsign, "%s%s", icaoCode, "_ATIS");
for (int i = 0; i < json_array_get_count(stations); i++) {
const JSON_Object *station = json_array_get_object(stations, i);
const char *callsign = json_object_dotget_string(station, "callsign");
if (strcmp(callsign, lookupCallsign) == 0) {
message = json_object_dotget_string(station, "atis");
XPLMDebugString(message);
break;
}
}
}
json_value_free(root_value);
}
newData = 0;
}
gint jobdesc_streams_count (gchar *job, gchar *pipeline)
{
JSON_Value *val;
JSON_Object *obj;
JSON_Array *array;
gsize size, i;
gint count, index;
gchar *bin, *ptype;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
if (g_str_has_prefix (pipeline, "encoder")) {
ptype = "appsrc";
array = json_object_dotget_array (obj, "encoders");
sscanf (pipeline, "encoder.%d", &index);
obj = json_array_get_object (array, index);
} else if (g_str_has_prefix (pipeline, "source")) {
ptype = "appsink";
obj = json_object_get_object (obj, "source");
}
array = json_object_dotget_array (obj, "bins");
size = json_array_get_count (array);
count = 0;
for (i = 0; i < size; i++) {
bin = (gchar *)json_array_get_string (array, i);
if (g_strrstr (bin, ptype) != NULL)
count += 1;
}
json_value_free (val);
return count;
}
gchar * jobdesc_element_caps (gchar *job, gchar *element)
{
JSON_Value *val;
JSON_Object *obj;
JSON_Array *array;
gchar *p, *caps;
gint index;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
if (g_str_has_prefix (element, "encoder")) {
array = json_object_dotget_array (obj, "encoders");
sscanf (element, "encoder.%d", &index);
obj = json_array_get_object (array, index);
} else {
obj = json_object_get_object (obj, "source");
}
p = g_strrstr (element, "elements");
caps = (gchar *)json_object_dotget_string (obj, p);
if (caps == NULL) {
p = NULL;
} else {
p = g_strdup (caps);
}
json_value_free (val);
return p;
}
bud_error_t bud_config_load_frontend_ifaces(
JSON_Object* obj,
bud_config_frontend_interface_t* interface) {
JSON_Array* arr;
int i;
arr = json_object_get_array(obj, "interfaces");
interface->count = arr == NULL ? 0 : json_array_get_count(arr);
if (interface->count == 0)
return bud_ok();
interface->list = calloc(interface->count, sizeof(*interface->list));
if (interface->list == NULL)
return bud_error_str(kBudErrNoMem, "bud_frontend_interface_t");
for (i = 0; i < interface->count; i++)
bud_config_load_addr(json_array_get_object(arr, i), &interface->list[i]);
return bud_ok();
}
void print_commits_info(const char *username, const char *repo) {
JSON_Value *root_value;
JSON_Array *commits;
JSON_Object *commit;
size_t i;
char curl_command[512];
char cleanup_command[256];
char output_filename[] = "commits.json";
/* it ain't pretty, but it's not a libcurl tutorial */
sprintf(curl_command,
"curl -s \"https://api.github.com/repos/%s/%s/commits\" > %s",
username, repo, output_filename);
sprintf(cleanup_command, "rm -f %s", output_filename);
system(curl_command);
/* parsing json and validating output */
root_value = json_parse_file(output_filename);
if (json_value_get_type(root_value) != JSONArray) {
system(cleanup_command);
return;
}
/* getting array from root value and printing commit info */
commits = json_value_get_array(root_value);
printf("%-10.10s %-10.10s %s\n", "Date", "SHA", "Author");
for (i = 0; i < json_array_get_count(commits); i++) {
commit = json_array_get_object(commits, i);
printf("%.10s %.10s %s\n",
json_object_dotget_string(commit, "commit.author.date"),
json_object_get_string(commit, "sha"),
json_object_dotget_string(commit, "commit.author.name"));
}
/* cleanup code */
json_value_free(root_value);
system(cleanup_command);
}
int main()
{
m2x_context *ctx = NULL;
JSON_Value *val = NULL;
JSON_Array *feeds = NULL;
size_t i;
ctx = m2x_open(M2X_KEY);
if (m2x_json_feed_list(ctx, "", &val) == 0) {
feeds = json_object_get_array(json_value_get_object(val), "feeds");
for (i = 0; i < json_array_get_count(feeds); i++) {
JSON_Object* feed = json_array_get_object(feeds, i);
printf("Feed id: %s\n", json_object_get_string(feed, "id"));
printf(" name: %s\n", json_object_get_string(feed, "name"));
printf("Contains %ld streams\n\n",
json_array_get_count(json_object_get_array(feed, "streams")));
}
json_value_free(val);
}
m2x_close(ctx);
return 0;
}
gchar * jobdesc_udpstreaming (gchar *job, gchar *pipeline)
{
JSON_Value *val;
JSON_Object *obj;
JSON_Array *array;
gint index;
gchar *p, *udpstreaming;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
array = json_object_dotget_array (obj, "encoders");
sscanf (pipeline, "encoder.%d", &index);
obj = json_array_get_object (array, index);
p = (gchar *)json_object_get_string (obj, "udpstreaming");
if (p == NULL) {
udpstreaming = NULL;
} else {
udpstreaming = g_strdup (p);
}
json_value_free (val);
return udpstreaming;
}
bud_error_t bud_config_load(bud_config_t* config) {
int i;
bud_error_t err;
JSON_Value* json;
JSON_Value* val;
JSON_Object* frontend;
JSON_Object* obj;
JSON_Object* log;
JSON_Object* avail;
JSON_Array* contexts;
if (config->piped) {
char* content;
ASSERT(config->loop != NULL, "Loop should be present");
err = bud_read_file_by_fd(config->loop, 0, &content);
if (!bud_is_ok(err))
goto end;
err = bud_hashmap_insert(&config->files.hashmap,
kPipedConfigPath,
strlen(kPipedConfigPath),
content);
if (!bud_is_ok(err)) {
free(content);
goto end;
}
json = json_parse_string(content);
} else if (config->inlined) {
json = json_parse_string(config->path);
} else {
const char* contents;
err = bud_config_load_file(config, config->path, &contents);
if (!bud_is_ok(err))
goto end;
json = json_parse_string(contents);
}
if (json == NULL) {
err = bud_error_dstr(kBudErrJSONParse, config->path);
goto end;
}
obj = json_value_get_object(json);
if (obj == NULL) {
err = bud_error(kBudErrJSONNonObjectRoot);
goto failed_alloc_path;
}
err = bud_config_load_tracing(&config->trace,
json_object_get_object(obj, "tracing"));
if (!bud_is_ok(err))
goto failed_alloc_path;
/* Allocate contexts and backends */
contexts = json_object_get_array(obj, "contexts");
config->context_count = contexts == NULL ? 0 : json_array_get_count(contexts);
config->contexts = calloc(config->context_count + 1,
sizeof(*config->contexts));
if (config->contexts == NULL) {
err = bud_error_str(kBudErrNoMem, "bud_context_t");
goto failed_alloc_contexts;
}
config->json = json;
/* Workers configuration */
config->worker_count = -1;
config->restart_timeout = -1;
config->master_ipc = -1;
val = json_object_get_value(obj, "workers");
if (val != NULL)
config->worker_count = json_value_get_number(val);
val = json_object_get_value(obj, "restart_timeout");
if (val != NULL)
config->restart_timeout = json_value_get_number(val);
val = json_object_get_value(obj, "master_ipc");
if (val != NULL)
config->master_ipc = json_value_get_boolean(val);
/* Logger configuration */
log = json_object_get_object(obj, "log");
config->log.stdio = -1;
config->log.syslog = -1;
if (log != NULL) {
config->log.level = json_object_get_string(log, "level");
config->log.facility = json_object_get_string(log, "facility");
val = json_object_get_value(log, "stdio");
if (val != NULL)
config->log.stdio = json_value_get_boolean(val);
val = json_object_get_value(log, "syslog");
if (val != NULL)
config->log.syslog = json_value_get_boolean(val);
}
/* Availability configuration */
avail = json_object_get_object(obj, "availability");
config->availability.death_timeout = -1;
config->availability.revive_interval = -1;
config->availability.retry_interval = -1;
config->availability.max_retries = -1;
if (avail != NULL) {
val = json_object_get_value(avail, "death_timeout");
if (val != NULL)
config->availability.death_timeout = json_value_get_number(val);
val = json_object_get_value(avail, "revive_interval");
if (val != NULL)
config->availability.revive_interval = json_value_get_number(val);
val = json_object_get_value(avail, "retry_interval");
if (val != NULL)
config->availability.retry_interval = json_value_get_number(val);
val = json_object_get_value(avail, "max_retries");
if (val != NULL)
config->availability.max_retries = json_value_get_number(val);
}
/* Frontend configuration */
frontend = json_object_get_object(obj, "frontend");
err = bud_config_load_frontend(frontend, &config->frontend);
if (!bud_is_ok(err))
goto failed_alloc_contexts;
/* Load frontend's context */
err = bud_context_load(frontend, &config->contexts[0]);
if (!bud_is_ok(err))
goto failed_alloc_contexts;
/* Backend configuration */
config->balance = json_object_get_string(obj, "balance");
err = bud_config_load_backend_list(config,
obj,
&config->contexts[0].backend);
if (!bud_is_ok(err))
goto failed_alloc_contexts;
/* User and group configuration */
config->user = json_object_get_string(obj, "user");
config->group = json_object_get_string(obj, "group");
/* SNI configuration */
bud_config_read_pool_conf(obj, "sni", &config->sni);
/* OCSP Stapling configuration */
bud_config_read_pool_conf(obj, "stapling", &config->stapling);
/* SSL Contexts */
/* TODO(indutny): sort them and do binary search */
for (i = 0; i < config->context_count; i++) {
bud_context_t* ctx;
/* NOTE: contexts[0] - is a default context */
ctx = &config->contexts[i + 1];
obj = json_array_get_object(contexts, i);
if (obj == NULL) {
err = bud_error(kBudErrJSONNonObjectCtx);
goto failed_load_context;
}
err = bud_context_load(obj, ctx);
if (!bud_is_ok(err))
goto failed_load_context;
err = bud_config_load_backend_list(config, obj, &ctx->backend);
if (!bud_is_ok(err))
goto failed_load_context;
}
bud_config_set_defaults(config);
return bud_config_init(config);
failed_load_context:
/* Deinitalize contexts */
for (i++; i >= 0; i--) {
bud_context_t* ctx;
ctx = &config->contexts[i];
free(ctx->backend.list);
ctx->backend.list = NULL;
}
failed_alloc_contexts:
free(config->contexts);
config->contexts = NULL;
free(config->trace.dso);
config->trace.dso = NULL;
failed_alloc_path:
json_value_free(json);
config->json = NULL;
end:
return err;
}
bud_config_t* bud_config_load(uv_loop_t* loop,
const char* path,
bud_error_t* err) {
int i;
int context_count;
JSON_Value* json;
JSON_Value* val;
JSON_Object* obj;
JSON_Object* log;
JSON_Object* frontend;
JSON_Object* backend;
JSON_Array* contexts;
bud_config_t* config;
bud_context_t* ctx;
json = json_parse_file(path);
if (json == NULL) {
*err = bud_error_str(kBudErrJSONParse, path);
goto end;
}
obj = json_value_get_object(json);
if (obj == NULL) {
*err = bud_error(kBudErrJSONNonObjectRoot);
goto failed_get_object;
}
contexts = json_object_get_array(obj, "contexts");
context_count = contexts == NULL ? 0 : json_array_get_count(contexts);
config = calloc(1,
sizeof(*config) +
context_count * sizeof(*config->contexts));
if (config == NULL) {
*err = bud_error_str(kBudErrNoMem, "bud_config_t");
goto failed_get_object;
}
config->loop = loop;
config->json = json;
/* Workers configuration */
config->worker_count = -1;
config->restart_timeout = -1;
val = json_object_get_value(obj, "workers");
if (val != NULL)
config->worker_count = json_value_get_number(val);
val = json_object_get_value(obj, "restart_timeout");
if (val != NULL)
config->restart_timeout = json_value_get_number(val);
/* Logger configuration */
log = json_object_get_object(obj, "log");
config->log.stdio = -1;
config->log.syslog = -1;
if (log != NULL) {
config->log.level = json_object_get_string(log, "level");
config->log.facility = json_object_get_string(log, "facility");
val = json_object_get_value(log, "stdio");
if (val != NULL)
config->log.stdio = json_value_get_boolean(val);
val = json_object_get_value(log, "syslog");
if (val != NULL)
config->log.syslog = json_value_get_boolean(val);
}
/* Frontend configuration */
frontend = json_object_get_object(obj, "frontend");
config->frontend.proxyline = -1;
config->frontend.keepalive = -1;
config->frontend.server_preference = -1;
config->frontend.ssl3 = -1;
if (frontend != NULL) {
config->frontend.port = (uint16_t) json_object_get_number(frontend, "port");
config->frontend.host = json_object_get_string(frontend, "host");
config->frontend.security = json_object_get_string(frontend, "security");
config->frontend.npn = json_object_get_array(frontend, "npn");
config->frontend.ciphers = json_object_get_string(frontend, "ciphers");
config->frontend.cert_file = json_object_get_string(frontend, "cert");
config->frontend.key_file = json_object_get_string(frontend, "key");
config->frontend.reneg_window = json_object_get_number(frontend,
"reneg_window");
config->frontend.reneg_limit = json_object_get_number(frontend,
"reneg_limit");
*err = bud_config_verify_npn(config->frontend.npn);
if (!bud_is_ok(*err))
goto failed_get_index;
val = json_object_get_value(frontend, "proxyline");
if (val != NULL)
config->frontend.proxyline = json_value_get_boolean(val);
val = json_object_get_value(frontend, "keepalive");
if (val != NULL)
config->frontend.keepalive = json_value_get_number(val);
val = json_object_get_value(frontend, "server_preference");
if (val != NULL)
config->frontend.server_preference = json_value_get_boolean(val);
val = json_object_get_value(frontend, "ssl3");
if (val != NULL)
config->frontend.ssl3 = json_value_get_boolean(val);
}
/* Backend configuration */
backend = json_object_get_object(obj, "backend");
config->backend.keepalive = -1;
if (backend != NULL) {
config->backend.port = (uint16_t) json_object_get_number(backend, "port");
config->backend.host = json_object_get_string(backend, "host");
val = json_object_get_value(backend, "keepalive");
if (val != NULL)
config->backend.keepalive = json_value_get_number(val);
}
/* SNI configuration */
bud_config_read_pool_conf(obj, "sni", &config->sni);
/* OCSP Stapling configuration */
bud_config_read_pool_conf(obj, "stapling", &config->stapling);
/* SSL Contexts */
/* TODO(indutny): sort them and do binary search */
for (i = 0; i < context_count; i++) {
/* NOTE: contexts[0] - is a default context */
ctx = &config->contexts[i + 1];
obj = json_array_get_object(contexts, i);
if (obj == NULL) {
*err = bud_error(kBudErrJSONNonObjectCtx);
goto failed_get_index;
}
ctx->servername = json_object_get_string(obj, "servername");
ctx->servername_len = ctx->servername == NULL ? 0 : strlen(ctx->servername);
ctx->cert_file = json_object_get_string(obj, "cert");
ctx->key_file = json_object_get_string(obj, "key");
ctx->npn = json_object_get_array(obj, "npn");
ctx->ciphers = json_object_get_string(obj, "ciphers");
*err = bud_config_verify_npn(ctx->npn);
if (!bud_is_ok(*err))
goto failed_get_index;
}
config->context_count = context_count;
bud_config_set_defaults(config);
*err = bud_ok();
return config;
failed_get_index:
free(config);
failed_get_object:
json_value_free(json);
end:
return NULL;
}
/*******************************************************************************
**
** Function initialize_setup
**
** Description Create streams and trigger
** Can be hardcoded
** to add reading from configuration file.
**
** Returns void
**
*******************************************************************************/
static int create_streams(void)
{
FILE *streams_fp;
char fname[10];
char key_from_file[100];
int stream_len=0;
int device_present;
int stream_present[MAX_STREAM];
int j;
printf("Creating M2X Streams \n");
memset(stream_present, 0, MAX_STREAM);
/* Get the list of streams from the M2X Server and validate that all the Streams are present */
response = m2x_device_streams(ctx, device_id);
printf("Response code: %d\n", response.status);
if (m2x_is_success(&response)) {
JSON_Array *streams = json_object_get_array(json_value_get_object(
response.json), "streams");
size_t i;
for (i = 0; i < json_array_get_count(streams); i++) {
JSON_Object *json_stream = json_array_get_object(streams, i);
const char *stream_name = json_object_get_string(json_stream, "name");
for (j=0; j< MAX_STREAM; j++)
{
if (strncmp(stream_name, stream_name_list[j],strlen(stream_name)))
{
stream_present[j] = 1; /* Stream already present*/
}
}
printf("Name : %s\n", stream_name);
printf("\n");
}
}
m2x_release_response(&response);
/* Create a Stream */
for (i=0; i < MAX_STREAM; i++)
{
if (stream_present[i])
continue;
printf("Creating %d M2X Stream :\"%s\" of size=%d \n", i, stream_name_list[i], sizeof(stream_name_list[i]));
memset(&buf, 0, sizeof(buf));
stream_len= strlen(stream_name_list[i]);
stream_len = (stream_len<MAX_STREAM_NAME)?stream_len:MAX_STREAM_NAME;
memcpy(stream_name, stream_name_list[i], stream_len+1);
/*stream_name[stream_len]='\n';*/
APPL_TRACE_INFO("\nBefore m2x_device_stream_create device_id: %s |\n", &device_id);
APPL_TRACE_INFO("\nBefore m2x_device_stream_create stream_name: %s |\n", stream_name);
switch(i) {
case HUMIDITY:
sprintf(buf, "{ \"unit\": { \"label\": \"percentage\", \"symbol\": \"%%\" }, \"type\": \"numeric\" }");
break;
case TEMPERATURE:
sprintf(buf, "{ \"unit\": { \"label\": \"celsius\", \"symbol\": \"C\" }, \"type\": \"numeric\" }");
break;
case PRESSURE:
sprintf(buf, "{ \"unit\": { \"label\": \"pascal\", \"symbol\": \"Pa\" }, \"type\": \"numeric\" }");
break;
case GYRO:
sprintf(buf, "{ \"unit\": { \"label\": \"point\", \"symbol\": \"p\" }, \"type\": \"numeric\" }");
break;
case ACCL:
sprintf(buf, "{ \"unit\": { \"label\": \"point\", \"symbol\": \"p\" }, \"type\": \"numeric\" }");
break;
case MAGNETO_FLUX:
sprintf(buf, "{ \"unit\": { \"label\": \"point\", \"symbol\": \"p\" }, \"type\": \"numeric\" }");
break;
}
response = m2x_device_stream_create(ctx, &device_id, stream_name, buf);
if (m2x_is_success(&response) && response.raw) {
APPL_TRACE_INFO("%s\n", response.raw);
}
/* Store the Device Id in the file */
sprintf(fname, "/tmp/m2x/stream_%s", stream_name);
streams_fp = fopen (fname, "w+");
fprintf(streams_fp, "%s", stream_name);
fclose(streams_fp);
/* Release the response so that same struct is used for next response */
m2x_release_response(&response);
/* Sleep for about a min, since it takes ~40 sec to create the device */
sleep(5);
}
}
bud_config_t* bud_config_load(const char* path, int inlined, bud_error_t* err) {
int i;
JSON_Value* json;
JSON_Value* val;
JSON_Object* obj;
JSON_Object* tmp;
JSON_Object* log;
JSON_Object* avail;
JSON_Array* contexts;
JSON_Array* backend;
bud_config_t* config;
bud_context_t* ctx;
if (inlined)
json = json_parse_string(path);
else
json = json_parse_file(path);
if (json == NULL) {
*err = bud_error_str(kBudErrJSONParse, path);
goto end;
}
obj = json_value_get_object(json);
if (obj == NULL) {
*err = bud_error(kBudErrJSONNonObjectRoot);
goto failed_get_object;
}
config = calloc(1, sizeof(*config));
if (config == NULL) {
*err = bud_error_str(kBudErrNoMem, "bud_config_t");
goto failed_get_object;
}
/* Copy path or inlined config value */
config->path = strdup(path);
if (config->path == NULL) {
*err = bud_error_str(kBudErrNoMem, "bud_config_t strcpy(path)");
goto failed_alloc_path;
}
config->inlined = inlined;
/* Allocate contexts and backends */
contexts = json_object_get_array(obj, "contexts");
backend = json_object_get_array(obj, "backend");
config->context_count = contexts == NULL ? 0 : json_array_get_count(contexts);
config->backend_count = backend == NULL ? 0 : json_array_get_count(backend);
config->contexts = calloc(config->context_count + 1,
sizeof(*config->contexts));
config->backend = calloc(config->backend_count, sizeof(*config->backend));
if (config->contexts == NULL || config->backend == NULL) {
*err = bud_error_str(kBudErrNoMem, "bud_context_t");
goto failed_get_index;
}
config->json = json;
/* Workers configuration */
config->worker_count = -1;
config->restart_timeout = -1;
val = json_object_get_value(obj, "workers");
if (val != NULL)
config->worker_count = json_value_get_number(val);
val = json_object_get_value(obj, "restart_timeout");
if (val != NULL)
config->restart_timeout = json_value_get_number(val);
/* Logger configuration */
log = json_object_get_object(obj, "log");
config->log.stdio = -1;
config->log.syslog = -1;
if (log != NULL) {
config->log.level = json_object_get_string(log, "level");
config->log.facility = json_object_get_string(log, "facility");
val = json_object_get_value(log, "stdio");
if (val != NULL)
config->log.stdio = json_value_get_boolean(val);
val = json_object_get_value(log, "syslog");
if (val != NULL)
config->log.syslog = json_value_get_boolean(val);
}
/* Availability configuration */
avail = json_object_get_object(obj, "availability");
config->availability.death_timeout = -1;
config->availability.revive_interval = -1;
config->availability.retry_interval = -1;
config->availability.max_retries = -1;
if (avail != NULL) {
val = json_object_get_value(avail, "death_timeout");
if (val != NULL)
config->availability.death_timeout = json_value_get_number(val);
val = json_object_get_value(avail, "revive_interval");
if (val != NULL)
config->availability.revive_interval = json_value_get_number(val);
val = json_object_get_value(avail, "retry_interval");
if (val != NULL)
config->availability.retry_interval = json_value_get_number(val);
val = json_object_get_value(avail, "max_retries");
if (val != NULL)
config->availability.max_retries = json_value_get_number(val);
}
/* Frontend configuration */
*err = bud_config_load_frontend(json_object_get_object(obj, "frontend"),
&config->frontend);
if (!bud_is_ok(*err))
goto failed_get_index;
/* Backend configuration */
config->balance = json_object_get_string(obj, "balance");
for (i = 0; i < config->backend_count; i++) {
bud_config_load_backend(config,
json_array_get_object(backend, i),
&config->backend[i]);
}
/* SNI configuration */
bud_config_read_pool_conf(obj, "sni", &config->sni);
/* OCSP Stapling configuration */
bud_config_read_pool_conf(obj, "stapling", &config->stapling);
/* SSL Contexts */
/* TODO(indutny): sort them and do binary search */
for (i = 0; i < config->context_count; i++) {
/* NOTE: contexts[0] - is a default context */
ctx = &config->contexts[i + 1];
obj = json_array_get_object(contexts, i);
if (obj == NULL) {
*err = bud_error(kBudErrJSONNonObjectCtx);
goto failed_get_index;
}
ctx->servername = json_object_get_string(obj, "servername");
ctx->servername_len = ctx->servername == NULL ? 0 : strlen(ctx->servername);
ctx->cert_file = json_object_get_string(obj, "cert");
ctx->key_file = json_object_get_string(obj, "key");
ctx->npn = json_object_get_array(obj, "npn");
ctx->ciphers = json_object_get_string(obj, "ciphers");
ctx->ecdh = json_object_get_string(obj, "ecdh");
ctx->ticket_key = json_object_get_string(obj, "ticket_key");
tmp = json_object_get_object(obj, "backend");
if (tmp != NULL) {
ctx->backend = &ctx->backend_st;
bud_config_load_backend(config, tmp, ctx->backend);
}
*err = bud_config_verify_npn(ctx->npn);
if (!bud_is_ok(*err))
goto failed_get_index;
}
bud_config_set_defaults(config);
*err = bud_ok();
return config;
failed_get_index:
free(config->contexts);
config->contexts = NULL;
free(config->backend);
config->backend = NULL;
free(config->path);
config->path = NULL;
failed_alloc_path:
free(config);
failed_get_object:
json_value_free(json);
end:
return NULL;
}
int config_parse(const char *file, config_t *config)
{
JSON_Value *jvroot;
JSON_Object *joroot;
JSON_Object *jomaccmd;
JSON_Array *jarray;
JSON_Value_Type jtype;
const char *string;
int ret;
int i;
if(file == NULL){
return -1;
}
/** Clear all flags */
config_free(config);
printf("Start parsing configuration file....\n\n");
/* parsing json and validating output */
jvroot = json_parse_file_with_comments(file);
jtype = json_value_get_type(jvroot);
if (jtype != JSONObject) {
return -1;
}
joroot = json_value_get_object(jvroot);
string = json_object_get_string(joroot, "band");
if(string == NULL){
config->band = LW_BAND_EU868;
}else{
for(i=0; i<LW_BAND_MAX_NUM; i++){
if(0 == strcmp(string, config_band_tab[i])){
config->band = (lw_band_t)i;
break;
}
}
if(i==LW_BAND_MAX_NUM){
config->band = LW_BAND_EU868;
}
}
string = json_object_dotget_string(joroot, "key.nwkskey");
if(string != NULL){
if(str2hex(string, config->nwkskey, 16) == 16){
config->flag |= CFLAG_NWKSKEY;
}
}
string = json_object_dotget_string(joroot, "key.appskey");
if(string != NULL){
if(str2hex(string, config->appskey, 16) == 16){
config->flag |= CFLAG_APPSKEY;
}
}
string = json_object_dotget_string(joroot, "key.appkey");
if(string != NULL){
if(str2hex(string, config->appkey, 16) == 16){
config->flag |= CFLAG_APPKEY;
}
}
ret = json_object_dotget_boolean(joroot, "join.key");
if(ret==0){
//printf("Join key false\n");
config->joinkey = false;
}else if(ret==1){
//printf("Join key true\n");
config->joinkey = true;
}else{
//printf("Unknown join key value\n");
config->joinkey = false;
}
string = json_object_dotget_string(joroot, "join.request");
if(string != NULL){
uint8_t tmp[255];
int len;
len = str2hex(string, tmp, 255);
if(len>0){
config->flag |= CFLAG_JOINR;
config->joinr = malloc(len);
if(config->joinr == NULL){
return -2;
}
config->joinr_size = len;
memcpy(config->joinr, tmp, config->joinr_size);
}
}
string = json_object_dotget_string(joroot, "join.accept");
if(string != NULL){
uint8_t tmp[255];
int len;
len = str2hex(string, tmp, 255);
if(len>0){
config->flag |= CFLAG_JOINA;
config->joina = malloc(len);
if(config->joina == NULL){
return -3;
}
config->joina_size = len;
memcpy(config->joina, tmp, config->joina_size);
}
}
jarray = json_object_get_array(joroot, "messages");
if(jarray != NULL){
uint8_t tmp[255];
for (i = 0; i < json_array_get_count(jarray); i++) {
string = json_array_get_string(jarray, i);
if(string!=NULL){
int len = str2hex(string, tmp, 255);
if(len>0){
message_t *pl = malloc(sizeof(message_t));
memset(pl, 0, sizeof(message_t));
if(pl == NULL){
return -3;
}
pl->buf = malloc(len);
if(pl->buf == NULL){
return -3;
}
pl->len = len;
memcpy(pl->buf, tmp, pl->len);
pl_insert(&config->message, pl);
}else{
printf("Messages[%d] \"%s\" is not hex string\n", i, string);
}
}else{
printf("Messages item %d is not string\n", i);
}
}
}else{
printf("Can't get payload array\n");
}
jarray = json_object_get_array(joroot, "maccommands");
if(jarray != NULL){
uint8_t mhdr;
int len;
uint8_t tmp[255];
for (i = 0; i < json_array_get_count(jarray); i++) {
jomaccmd = json_array_get_object(jarray, i);
string = json_object_get_string(jomaccmd, "MHDR");
if(string != NULL){
len = str2hex(string, &mhdr, 1);
if(len != 1){
printf("\"maccommands\"[%d].MHDR \"%s\" must be 1 byte hex string\n", i, string);
continue;
}
}else{
string = json_object_get_string(jomaccmd, "direction");
if(string != NULL){
int j;
len = strlen(string);
if(len>200){
printf("\"maccommands\"[%d].direction \"%s\" too long\n", i, string);
continue;
}
for(j=0; j<len; j++){
tmp[j] = tolower(string[j]);
}
tmp[j] = '\0';
if(0==strcmp((char *)tmp, "up")){
mhdr = 0x80;
}else if(0==strcmp((char *)tmp, "down")){
mhdr = 0xA0;
}else{
printf("\"maccommands\"[%d].MHDR \"%s\" must be 1 byte hex string\n", i, string);
continue;
}
}else{
printf("Can't recognize maccommand direction\n");
continue;
}
}
string = json_object_get_string(jomaccmd, "command");
if(string != NULL){
len = str2hex(string, tmp, 255);
if(len <= 0){
printf("\"maccommands\"[%d].command \"%s\" is not hex string\n", i, string);
continue;
}
}else{
printf("c\"maccommands\"[%d].command is not string\n", i);
continue;
}
message_t *pl = malloc(sizeof(message_t));
memset(pl, 0, sizeof(message_t));
if(pl == NULL){
return -3;
}
pl->buf = malloc(len+1);
if(pl->buf == NULL){
return -3;
}
pl->len = len+1;
pl->buf[0] = mhdr;
pl->next = 0;
memcpy(pl->buf+1, tmp, pl->len-1);
pl_insert(&config->maccmd, pl);
}
}
print_spliter();
printf("%15s %s\n","BAND:\t", config_band_tab[LW_BAND_EU868]);
printf("%15s","NWKSKEY:\t");
putlen(16);
puthbuf(config->nwkskey, 16);
printf("\n");
printf("%15s","APPSKEY:\t");
putlen(16);
puthbuf(config->appskey, 16);
printf("\n");
printf("%15s","APPKEY:\t");
putlen(16);
puthbuf(config->appkey, 16);
printf("\n");
printf("%15s","JOINR:\t");
putlen(config->joinr_size);
puthbuf(config->joinr, config->joinr_size );
printf("\n");
printf("%15s","JOINA:\t");
putlen(config->joina_size);
puthbuf(config->joina, config->joina_size );
printf("\n");
pl_print(config->message);
maccmd_print(config->maccmd);
json_value_free(jvroot);
return 0;
}
/**
*
* @property: (in): encoders.x.elements.element.property.name or source.elements.element.property.name
*/
gchar * jobdesc_element_property_value (gchar *job, gchar *property)
{
JSON_Value *val;
JSON_Object *obj;
JSON_Array *array;
JSON_Value_Type type;
JSON_Value *value;
gchar *p;
gint64 i;
gdouble n;
gint index;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
if (g_str_has_prefix (property, "encoder")) {
array = json_object_dotget_array (obj, "encoders");
sscanf (property, "encoder.%d", &index);
obj = json_array_get_object (array, index);
p = g_strrstr (property, "elements");
value = json_object_dotget_value (obj, p);
} else if (g_str_has_prefix (property, "source")) {
value = json_object_dotget_value (obj, property);
}
if (value == NULL) {
json_value_free (val);
return NULL;
}
type = json_value_get_type (value);
switch (type) {
case JSONString:
p = g_strdup (json_value_get_string (value));
break;
case JSONNumber:
n = json_value_get_number (value);
i = n;
if (i == n) {
p = g_strdup_printf ("%ld", i);
} else {
p = g_strdup_printf ("%f", n);
}
break;
case JSONBoolean:
if (json_value_get_boolean (value)) {
p = g_strdup ("TRUE");
} else {
p = g_strdup ("FALSE");
}
break;
default:
GST_ERROR ("property value invalid.");
}
json_value_free (val);
return p;
}
static gchar * set_network_interfaces (RequestData *request_data)
{
gchar *interfaces, *result, *name, *path, *value;
augeas *aug;
JSON_Value *val;
JSON_Array *array;
JSON_Object *obj;
gint if_count, i, ret;
aug = aug_init (NULL, NULL, AUG_NONE | AUG_NO_ERR_CLOSE | AUG_NO_MODL_AUTOLOAD);
aug_set (aug, "/augeas/load/Interfaces/lens", "Interfaces.lns");
aug_set (aug, "/augeas/load/Interfaces/incl", "/etc/network/interfaces");
aug_load (aug);
interfaces = request_data->raw_request + request_data->header_size;
val = json_parse_string (interfaces);
if (val == NULL) {
GST_ERROR ("parse json type interfaces failure");
result = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"invalid data\"\n}");
aug_close (aug);
return result;
}
array = json_value_get_array (val);
if (array == NULL) {
GST_ERROR ("get interfaces array failure");
result = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"not array type interfaces\"\n}");
aug_close (aug);
json_value_free (val);
return result;
}
if_count = json_array_get_count (array);
for (i = 0; i < if_count; i++) {
obj = json_array_get_object (array, i);
name = (gchar *)json_object_get_string (obj, "name");
value = (gchar *)json_object_get_string (obj, "method");
if (value != NULL) {
path = g_strdup_printf ("//files/etc/network/interfaces/iface[.='%s']/method", name);
aug_set (aug, path, value);
g_free (path);
}
value = (gchar *)json_object_get_string (obj, "address");
if (value != NULL) {
path = g_strdup_printf ("//files/etc/network/interfaces/iface[.='%s']/address", name);
ret = aug_set (aug, path, value);
g_free (path);
}
value = (gchar *)json_object_get_string (obj, "netmask");
if (value != NULL) {
path = g_strdup_printf ("//files/etc/network/interfaces/iface[.='%s']/netmask", name);
aug_set (aug, path, value);
g_free (path);
}
value = (gchar *)json_object_get_string (obj, "network");
if (value != NULL) {
path = g_strdup_printf ("//files/etc/network/interfaces/iface[.='%s']/network", name);
aug_set (aug, path, value);
g_free (path);
}
value = (gchar *)json_object_get_string (obj, "broadcast");
if (value != NULL) {
path = g_strdup_printf ("//files/etc/network/interfaces/iface[.='%s']/broadcast", name);
aug_set (aug, path, value);
g_free (path);
}
value = (gchar *)json_object_get_string (obj, "gateway");
if (value != NULL) {
path = g_strdup_printf ("//files/etc/network/interfaces/iface[.='%s']/gateway", name);
aug_set (aug, path, value);
g_free (path);
}
}
if (aug_save (aug) == -1) {
aug_get (aug, "/augeas//error", (const gchar **)&value);
GST_ERROR ("set /etc/network/interface failure: %s", value);
result = g_strdup_printf ("{\n \"result\": \"failure\",\n \"reason\": \"%s\"\n}", value);
} else {
result = g_strdup ("{\n \"result\": \"success\"\n}");
}
json_value_free (val);
aug_close (aug);
return result;
}
