/*******************************************************************************
**
** Function create_device
**
** Description Create Device,
** Hardcoded
** to add reading from configuration file.
**
** Returns void
**
*******************************************************************************/
static int create_device(void)
{
char *master_key;
char fname[50];
FILE *device_fp;
printf("Creating M2X device \n");
sprintf(fname, "/etc/m2x/dev_%s", name);
device_fp = fopen (fname, "r");
if (device_fp)
{
fscanf(device_fp, "%s", device_id);
APPL_TRACE_INFO("Device '%s' Exists. Device ID:%s\n",name, device_id );
fclose(device_fp);
return 2;
}
else
{
/* 1.3 Create a Device */
sprintf(buf, "{\"name\": \"%s\", \"description\": \"%s\", \"tags\": \"%s\", \"visibility\": \"%s\"}",
name, description, tags, visibility);
APPL_TRACE_INFO("Create device: %s\n", buf);
response = m2x_device_create(ctx, buf);
APPL_TRACE_INFO("Status code: %d\n", response.status);
if (m2x_is_success(&response) && response.raw)
{
APPL_TRACE_INFO("%s\n", response.raw);
APPL_TRACE_INFO("Feed ID : %s\n", json_object_get_string(json_value_get_object(
response.json), "id"));
memcpy(device_id, json_object_get_string(json_value_get_object(response.json), "id"),
sizeof(device_id));
APPL_TRACE_INFO("%s\n", &device_id);
/* Store the Device Id in the file */
/*sprintf(fname, "/etc/m2x/dev_%s", name);*/
device_fp = fopen (fname, "w+");
if (device_fp) {
fprintf(device_fp, "%s", device_id);
fclose(device_fp);
} else
{
printf("create_device: Failed to open file");
}
device_count++;
}
/* 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(45);
return 1;
}
}
static void handle_lobi_error(ANativeActivity *nativeActivity, int code, const char *response) {
// see
// https://github.com/nakamap/docs/wiki/Android-SDK-Docs#wiki-nakamap-callback
switch (code) {
case LOBI_NETWORK_ERROR:
// do something
break;
case LOBI_RESPONSE_ERROR:
// do something
break;
case LOBI_FATAL_ERROR:
{
JSON_Value *responseValue = json_parse_string(response);
JSON_Object *jsonObject = json_value_get_object(responseValue);
// do something.
// only in this case, response is not null and has
// an array of messages with the key 'error'
JSON_Array *errors = json_object_get_array((const JSON_Object *)jsonObject, "error");
if (errors) {
for (size_t i = 0, len = json_array_get_count(errors);
i < len; ++i) {
const char *error = json_array_get_string(errors, i);
lobi_showToast(nativeActivity, error);
LOGV("error #%d: %s", i, error);
}
}
json_value_free(responseValue);
break;
}
}
}
static GString *gmime_message_to_json(GMimeMessage *message, guint content_option) {
MessageData *mdata = convert_message(message, content_option);
JSON_Value *root_value = json_value_init_object();
JSON_Object *root_object = json_value_get_object(root_value);
json_object_set_value(root_object, "from", addresses_list_to_json(mdata->from));
json_object_set_value(root_object, "to", addresses_list_to_json(mdata->to));
json_object_set_value(root_object, "replyTo", addresses_list_to_json(mdata->reply_to));
json_object_set_value(root_object, "cc", addresses_list_to_json(mdata->cc));
json_object_set_value(root_object, "bcc", addresses_list_to_json(mdata->bcc));
json_object_set_string(root_object, "messageId", mdata->message_id);
json_object_set_string(root_object, "subject", mdata->subject);
json_object_set_string(root_object, "date", mdata->date);
json_object_set_value(root_object, "inReplyTo", references_to_json(mdata->in_reply_to));
json_object_set_value(root_object, "references", references_to_json(mdata->references));
json_object_set_value(root_object, "text", message_body_to_json(mdata->text));
json_object_set_value(root_object, "html", message_body_to_json(mdata->html));
json_object_set_value(root_object, "attachments", message_attachments_list_to_json(mdata->attachments));
free_message_data(mdata);
gchar *serialized_string = json_serialize_to_string(root_value);
json_value_free(root_value);
GString *json_string = g_string_new(serialized_string);
g_free(serialized_string);
return json_string;
}
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;
}
static JSON_Value* querySpecification_toJson(const PROVISIONING_QUERY_SPECIFICATION* query_spec)
{
JSON_Value* root_value = NULL;
JSON_Object* root_object = NULL;
//Setup
if ((root_value = json_value_init_object()) == NULL)
{
LogError("json_value_init_object failed");
}
else if ((root_object = json_value_get_object(root_value)) == NULL)
{
LogError("json_value_get_object failed");
json_value_free(root_value);
root_value = NULL;
}
//Set data
else if (json_object_set_string(root_object, QUERY_SPECIFICATION_JSON_KEY_QUERY, query_spec->query_string) != JSONSuccess)
{
LogError("Failed to set %s in JSON string", QUERY_SPECIFICATION_JSON_KEY_QUERY);
json_value_free(root_value);
root_value = NULL;
}
return root_value;
}
// returns the name of the zone that fits the given latitude and longitude best
static char *GetZoneName(double latitude, double longitude)
{
char *zoneName = NULL;
char *zones = GetUrl(URL_ZONES);
if (zones != NULL)
{
JSON_Value *rootJson = json_parse_string(zones);
free(zones);
zones = NULL;
if (rootJson != NULL)
{
if (rootJson->type == JSONObject)
{
double bestDistance = -1.0;
ParseZones(&zoneName, &bestDistance, json_value_get_object(rootJson), latitude, longitude);
}
json_value_free(rootJson);
rootJson = NULL;
}
}
return zoneName;
}
int APP_ParseCommand(char * pReadBuffer)
{
if(pReadBuffer == NULL)
return COMMAND_BAD_POINTER;
JSON_Value *rootValue = json_parse_string(pReadBuffer);
if (json_value_get_type(rootValue) != JSONObject)
return COMMAND_BAD_JSON;
JSON_Object * tObject = json_value_get_object(rootValue);
if(json_object_dotget_string(tObject, "message.command") != NULL)
{
if(strcmp(json_object_dotget_string(tObject, "message.command"), "hello") == 0)
{
return COMMAND_HELLO;
}
else if (strcmp(json_object_dotget_string(tObject, "message.command"), "configuration") == 0)
{
return COMMAND_CONFIGURE;
}
else if (strcmp(json_object_dotget_string(tObject, "message.command"), "debug_set") == 0)
{
return COMMAND_DEBUG_SET;
}
else
{
return COMMAND_INVALID;
}
}
else
{
return COMMAND_INVALID;
}
return COMMAND_INVALID;
}
void AppList::add_app_from_file(std::string file_path)
{
JSON_Value *root = json_parse_file(file_path.c_str());
if (!root) {
std::cout << "Couldn't parse returned JSON";
return;
}
if (json_value_get_type(root) != JSONObject) {
std::cout << "Returned JSON isn't a JSON object";
json_value_free(root);
return;
}
JSON_Object *node = json_value_get_object(root);
if (!node) {
std::cout << "Couldn't get node";
json_value_free(root);
return;
}
this->add_app(node);
json_value_free(root);
}
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;
}
int parse_gateway_configuration(const char * conf_file) {
const char conf_obj[] = "gateway_conf";
JSON_Value *root_val;
JSON_Object *root = NULL;
JSON_Object *conf = NULL;
const char *str; /* pointer to sub-strings in the JSON data */
unsigned long long ull = 0;
/* try to parse JSON */
root_val = json_parse_file_with_comments(conf_file);
root = json_value_get_object(root_val);
if (root == NULL) {
MSG("ERROR: %s id not a valid JSON file\n", conf_file);
exit(EXIT_FAILURE);
}
conf = json_object_get_object(root, conf_obj);
if (conf == NULL) {
MSG("INFO: %s does not contain a JSON object named %s\n", conf_file, conf_obj);
return -1;
} else {
MSG("INFO: %s does contain a JSON object named %s, parsing gateway parameters\n", conf_file, conf_obj);
}
/* getting network parameters (only those necessary for the packet logger) */
str = json_object_get_string(conf, "gateway_ID");
if (str != NULL) {
sscanf(str, "%llx", &ull);
lgwm = ull;
MSG("INFO: gateway MAC address is configured to %016llX\n", ull);
}
json_value_free(root_val);
return 0;
}
corto_int16 json_deserReference(void* p, corto_type t, JSON_Value* v)
{
switch(json_value_get_type(v)) {
case JSONString: {
const char* reference = json_value_get_string(v);
corto_object o = corto_resolve(NULL, (corto_string)reference);
if (!o) {
corto_error("unresolved reference \"%s\"", reference);
goto error;
}
if (!corto_instanceof(t, o)) {
corto_error("%s is not an instance of %s", reference, corto_idof(t));
}
corto_setref(p, o);
corto_release(o);
break;
}
case JSONObject: {
JSON_Object* obj = json_value_get_object(v);
JSON_Value* type = json_object_get_value(obj, "type");
if (json_value_get_type(type) != JSONString) {
corto_seterr("type parameter of anonymous object must be a string");
goto error;
}
corto_type cortoType = corto_resolve(NULL, (char*)json_value_get_string(type));
if (!cortoType) {
corto_seterr("type '%s' not found for anonymous object", json_value_get_string(type));
goto error;
}
corto_object cortoObj = *(corto_object*)p;
if (!cortoObj || (corto_typeof(cortoObj) != cortoType)) {
cortoObj = corto_create(cortoType);
corto_setref(p, cortoObj);
corto_release(cortoObj);
}
corto_release(cortoType);
JSON_Value* value = json_object_get_value(obj, "value");
if (json_deserType(cortoObj, cortoType, value)) {
goto error;
}
break;
}
case JSONNull:
corto_setref(p, NULL);
break;
default:
corto_seterr("expected string, null or object (reference), got %s", json_valueTypeToString(v));
break;
}
return 0;
error:
return -1;
}
/* Testing correctness of parsed values */
void test_suite_2(JSON_Value *root_value) {
JSON_Object *root_object;
JSON_Array *array;
size_t i;
TEST(root_value);
TEST(json_value_get_type(root_value) == JSONObject);
root_object = json_value_get_object(root_value);
TEST(STREQ(json_object_get_string(root_object, "string"), "lorem ipsum"));
TEST(STREQ(json_object_get_string(root_object, "utf string"), "lorem ipsum"));
TEST(STREQ(json_object_get_string(root_object, "utf-8 string"), "あいうえお"));
TEST(STREQ(json_object_get_string(root_object, "surrogate string"), "lorem𝄞ipsum𝍧lorem"));
TEST(json_object_get_number(root_object, "positive one") == 1.0);
TEST(json_object_get_number(root_object, "negative one") == -1.0);
TEST(json_object_get_number(root_object, "hard to parse number") == -0.000314);
TEST(json_object_get_boolean(root_object, "boolean true") == 1);
TEST(json_object_get_boolean(root_object, "boolean false") == 0);
TEST(json_value_get_type(json_object_get_value(root_object, "null")) == JSONNull);
array = json_object_get_array(root_object, "string array");
if (array != NULL && json_array_get_count(array) > 1) {
TEST(STREQ(json_array_get_string(array, 0), "lorem"));
TEST(STREQ(json_array_get_string(array, 1), "ipsum"));
} else {
tests_failed++;
}
array = json_object_get_array(root_object, "x^2 array");
if (array != NULL) {
for (i = 0; i < json_array_get_count(array); i++) {
TEST(json_array_get_number(array, i) == (i * i));
}
} else {
tests_failed++;
}
TEST(json_object_get_array(root_object, "non existent array") == NULL);
TEST(STREQ(json_object_dotget_string(root_object, "object.nested string"), "str"));
TEST(json_object_dotget_boolean(root_object, "object.nested true") == 1);
TEST(json_object_dotget_boolean(root_object, "object.nested false") == 0);
TEST(json_object_dotget_value(root_object, "object.nested null") != NULL);
TEST(json_object_dotget_number(root_object, "object.nested number") == 123);
TEST(json_object_dotget_value(root_object, "should.be.null") == NULL);
TEST(json_object_dotget_value(root_object, "should.be.null.") == NULL);
TEST(json_object_dotget_value(root_object, ".") == NULL);
TEST(json_object_dotget_value(root_object, "") == NULL);
array = json_object_dotget_array(root_object, "object.nested array");
if (array != NULL && json_array_get_count(array) > 1) {
TEST(STREQ(json_array_get_string(array, 0), "lorem"));
TEST(STREQ(json_array_get_string(array, 1), "ipsum"));
} else {
tests_failed++;
}
TEST(json_object_dotget_boolean(root_object, "nested true"));
TEST(STREQ(json_object_get_string(root_object, "/**/"), "comment"));
TEST(STREQ(json_object_get_string(root_object, "//"), "comment"));
}
/* Testing correctness of parsed values */
void test_suite_2(void) {
JSON_Value *root_value;
JSON_Object *object;
JSON_Array *array;
int i;
const char *filename = "tests/test_2.txt";
printf("Testing %s:\n", filename);
root_value = json_parse_file(filename);
TEST(root_value);
TEST(json_value_get_type(root_value) == JSONObject);
object = json_value_get_object(root_value);
TEST(STREQ(json_object_get_string(object, "string"), "lorem ipsum"));
TEST(STREQ(json_object_get_string(object, "utf string"), "lorem ipsum"));
TEST(json_object_get_number(object, "positive one") == 1.0);
TEST(json_object_get_number(object, "negative one") == -1.0);
TEST(json_object_get_number(object, "hard to parse number") == -0.000314);
TEST(json_object_get_boolean(object, "boolean true") == 1);
TEST(json_object_get_boolean(object, "boolean false") == 0);
TEST(json_value_get_type(json_object_get_value(object, "null")) == JSONNull);
array = json_object_get_array(object, "string array");
if (array != NULL && json_array_get_count(array) > 1) {
TEST(STREQ(json_array_get_string(array, 0), "lorem"));
TEST(STREQ(json_array_get_string(array, 1), "ipsum"));
} else {
tests_failed++;
}
array = json_object_get_array(object, "x^2 array");
if (array != NULL) {
for (i = 0; i < json_array_get_count(array); i++) {
TEST(json_array_get_number(array, i) == (i * i));
}
} else {
tests_failed++;
}
TEST(json_object_get_array(object, "non existent array") == NULL);
TEST(STREQ(json_object_dotget_string(object, "object.nested string"), "str"));
TEST(json_object_dotget_boolean(object, "object.nested true") == 1);
TEST(json_object_dotget_boolean(object, "object.nested false") == 0);
TEST(json_object_dotget_value(object, "object.nested null") != NULL);
TEST(json_object_dotget_number(object, "object.nested number") == 123);
TEST(json_object_dotget_value(object, "should.be.null") == NULL);
TEST(json_object_dotget_value(object, "should.be.null.") == NULL);
TEST(json_object_dotget_value(object, ".") == NULL);
TEST(json_object_dotget_value(object, "") == NULL);
array = json_object_dotget_array(object, "object.nested array");
if (array != NULL && json_array_get_count(array) > 1) {
TEST(STREQ(json_array_get_string(array, 0), "lorem"));
TEST(STREQ(json_array_get_string(array, 1), "ipsum"));
} else {
tests_failed++;
}
TEST(json_object_dotget_boolean(object, "nested true"));
json_value_free(root_value);
}
static EJSBool
json_value_to_ejsval(JSON_Value *v, ejsval *rv)
{
switch (json_value_get_type (v)) {
case JSONNull:
*rv = _ejs_null;
return EJS_TRUE;
case JSONString:
*rv = _ejs_string_new_utf8 (json_value_get_string(v));
return EJS_TRUE;
case JSONNumber:
*rv = NUMBER_TO_EJSVAL(json_value_get_number(v));
return EJS_TRUE;
case JSONObject: {
JSON_Object *obj = json_value_get_object (v);
*rv = _ejs_object_create (_ejs_null);
int count = json_object_get_count (obj);
for (int i = 0; i < count; i ++) {
const char *propkey = json_object_get_name (obj, i);
ejsval propval;
if (!json_value_to_ejsval (json_object_get_value (obj, propkey), &propval))
return EJS_FALSE;
_ejs_object_setprop_utf8 (*rv, propkey, propval);
}
return EJS_TRUE;
}
case JSONArray: {
JSON_Array *arr = json_value_get_array (v);
int count = json_array_get_count (arr);
*rv = _ejs_array_new (count, EJS_FALSE);
for (int i = 0; i < count; i ++) {
ejsval propkey = _ejs_number_new (i);
ejsval propval;
if (!json_value_to_ejsval (json_array_get_value (arr, i), &propval))
return EJS_FALSE;
_ejs_object_setprop (*rv, propkey, propval);
}
return EJS_TRUE;
}
case JSONBoolean:
*rv = BOOLEAN_TO_EJSVAL(json_value_get_boolean(v));
return EJS_TRUE;
case JSONError:
EJS_NOT_IMPLEMENTED();
return EJS_FALSE;
}
}
static
uintptr_t
do_load_ppp_module(const char *fname)
{
tried_files = g_list_prepend(tried_files, g_strdup(fname));
module_dl_handler = dlopen(fname, RTLD_LAZY);
if (!module_dl_handler) {
trace_info_f("%s, can't open %s\n", __func__, fname);
return 1;
}
int32_t (*ppp_initialize_module)(PP_Module module_id, PPB_GetInterface get_browser_interface);
ppp_initialize_module = dlsym(module_dl_handler, "PPP_InitializeModule");
ppp_get_interface = dlsym(module_dl_handler, "PPP_GetInterface");
if (!ppp_initialize_module || !ppp_get_interface) {
trace_error("%s, one of required PPP_* is missing\n", __func__);
if (module_dl_handler)
dlclose(module_dl_handler);
module_dl_handler = NULL;
return 1;
}
module_file_name = g_strdup(fname);
if (!fpp_config_plugin_has_manifest()) {
use_fallback_version_strings();
return 0;
}
// try to read manifest.json file (only for those who can have it)
char *manifest_dir = strdup(fname);
gchar *manifest_path = g_strdup_printf("%s/manifest.json", dirname(manifest_dir));
free(manifest_dir);
JSON_Value *root_val = json_parse_file(manifest_path);
g_free(manifest_path);
if (!root_val) {
use_fallback_version_strings();
return 0;
}
JSON_Object *root_obj = json_value_get_object(root_val);
const char *version = json_object_get_string(root_obj, "version");
if (version) {
int v1 = 0, v2 = 0, v3 = 0, v4 = 0;
module_version = g_strdup(version);
(void)sscanf(module_version, "%9d.%9d.%9d.%9d", &v1, &v2, &v3, &v4);
module_descr = g_strdup_printf("%s %d.%d r%d", fpp_config_get_plugin_name(), v1, v2, v3);
} else {
use_fallback_version_strings();
}
json_value_free(root_val);
return 0;
}
MODULE_LOADER_RESULT ModuleLoader_ParseBaseConfigurationFromJson(
MODULE_LOADER_BASE_CONFIGURATION* configuration,
const JSON_Value* json
)
{
// The JSON is expected to be an object that has a string
// property called "binding.path"
MODULE_LOADER_RESULT result;
JSON_Value_Type value_type = json_value_get_type(json);
if (
configuration == NULL ||
json == NULL ||
value_type != JSONObject
)
{
LogError(
"Invalid input arguments. "
"configuration = %p, json = %p, json value type = %d",
configuration,
json,
(json != NULL) ? value_type : 0
);
/*
Codes_SRS_MODULE_LOADER_13_049: [ ModuleLoader_ParseBaseConfigurationFromJson shall return MODULE_LOADER_ERROR if configuration is NULL. ]
Codes_SRS_MODULE_LOADER_13_050 : [ModuleLoader_ParseBaseConfigurationFromJson shall return MODULE_LOADER_ERROR if json is NULL.]
Codes_SRS_MODULE_LOADER_13_051 : [ModuleLoader_ParseBaseConfigurationFromJson shall return MODULE_LOADER_ERROR if json is not a JSON object.]
*/
result = MODULE_LOADER_ERROR;
}
else
{
JSON_Object* config = json_value_get_object(json);
if (config == NULL)
{
LogError("json_value_get_object failed");
/*Codes_SRS_MODULE_LOADER_13_052: [ ModuleLoader_ParseBaseConfigurationFromJson shall return MODULE_LOADER_ERROR if an underlying platform call fails. ]*/
result = MODULE_LOADER_ERROR;
}
else
{
// It is acceptable to have binding.path be NULL.
/*Codes_SRS_MODULE_LOADER_13_053: [ ModuleLoader_ParseBaseConfigurationFromJson shall read the value of the string attribute binding.path from the JSON object and assign to configuration->binding_path. ]*/
const char* binding_path = json_object_get_string(config, "binding.path");
configuration->binding_path = STRING_construct(binding_path);
/*Codes_SRS_MODULE_LOADER_13_054: [ ModuleLoader_ParseBaseConfigurationFromJson shall return MODULE_LOADER_SUCCESS if the parsing is successful. ]*/
result = MODULE_LOADER_SUCCESS;
}
}
return result;
}
// retrieves the balancer url with the lowest load, if there are several balancers with the same load one of these is randomly selected
static char *GetBalancerUrl(void)
{
char *bestUrl = NULL;
char *balance = GetUrl(URL_BALANCE);
if (balance != NULL)
{
JSON_Value *rootJson = json_parse_string(balance);
free(balance);
balance = NULL;
if (rootJson != NULL && rootJson->type == JSONObject)
{
JSON_Object *serversJson = json_value_get_object(rootJson);
if (serversJson != NULL)
{
size_t serverCount = json_object_get_count(serversJson);
int bestLoad = 0;
for (int i = 0; i < serverCount; i++)
{
const char *url = json_object_get_name(serversJson, i);
JSON_Value *value = json_object_get_value(serversJson, url);
if (value != NULL && value->type == JSONNumber)
{
int load = (int) json_object_get_number(serversJson, url);
if (load != 0 && (bestUrl == NULL || load <= bestLoad/* || (load == bestLoad && rand() % 2)*/))
{
if (bestUrl != NULL)
{
free(bestUrl);
bestUrl = NULL;
}
bestUrl = (char*) malloc(strlen(url) + 1);
if (bestUrl != NULL)
strcpy(bestUrl, url);
bestLoad = load;
}
}
}
}
json_value_free(rootJson);
rootJson = NULL;
}
}
return bestUrl;
}
void do_network(JSON_Value* json, char* msg) {
if(json_value_get_type(json) == JSONObject) {
JSON_Object* obj = json_value_get_object(json);
const char* msgtype = json_object_dotget_string(obj, "type");
if(strcmp(msgtype, msg_type_sensor) == 0 || strcmp(msgtype, msg_type_actor) == 0) {
const char* command = json_object_dotget_string(obj, "msg.command");
if(command != 0) execute_command(command);
}
}
}
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++;
}
}
char *json(UDF_INIT *initid, UDF_ARGS *args,
char *result, unsigned long *length,
char *is_null, char *error)
{
JSON_Value *jv = json_parse_string(args->args[0]);
JSON_Value_Type json_type = json_value_get_type(jv);
if(json_type==JSONError){
*length=0;
*is_null=1;
*error=1;
json_value_free(jv);
return NULL;
}else{
if(json_type == JSONObject){
JSON_Object *o = json_value_get_object(jv);
JSON_Value *value = json_object_dotget_value(o,args->args[1]);
if(value==NULL){
*length = 0;
*is_null = 0;
return NULL;
}else{
*is_null = 0;
switch(json_value_get_type(value)){
case JSONArray:
*is_null = 1;
break;
case JSONError:
case JSONObject:
*is_null = 1;
*error = 1;
break;
case JSONString:
strcpy(initid->ptr,((char*)json_value_get_string(value)));
break;
case JSONNumber:
sprintf(initid->ptr,"%f",json_value_get_number(value));
break;
case JSONNull:
*is_null = 1;
break;
case JSONBoolean:
sprintf(initid->ptr,"%d",json_value_get_boolean(value));
break;
}
*length = initid->ptr == NULL ? 0 : strlen(initid->ptr);
}
}else{
*is_null = 1;
}
json_value_free(jv);
return initid->ptr;
}
}
void test_suite_7(void) {
JSON_Value *val_from_file = json_parse_file("tests/test_5.txt");
JSON_Value *schema = json_value_init_object();
JSON_Object *schema_obj = json_value_get_object(schema);
json_object_set_string(schema_obj, "first", "");
json_object_set_string(schema_obj, "last", "");
json_object_set_number(schema_obj, "age", 0);
json_object_set_null(schema_obj, "favorites");
TEST(json_validate(schema, val_from_file) == JSONSuccess);
json_object_set_string(schema_obj, "age", "");
TEST(json_validate(schema, val_from_file) == JSONFailure);
}
static JSON_Value *address_to_json(Address *addr) {
if (!addr)
return NULL;
JSON_Value *address_value = json_value_init_object();
JSON_Object *address_object = json_value_get_object(address_value);
json_object_set_string(address_object, "name", addr->name);
json_object_set_string(address_object, "address", addr->address);
return address_value;
}
guint jobdesc_m3u8streaming_version (gchar *job)
{
JSON_Value *val;
JSON_Object *obj;
guint version;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
version = json_object_dotget_number (obj, "m3u8streaming.version");
json_value_free (val);
return version;
}
guint jobdesc_m3u8streaming_window_size (gchar *job)
{
JSON_Value *val;
JSON_Object *obj;
guint window_size;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
window_size = json_object_dotget_number (obj, "m3u8streaming.window-size");
json_value_free (val);
return window_size;
}
GstClockTime jobdesc_m3u8streaming_segment_duration (gchar *job)
{
JSON_Value *val;
JSON_Object *obj;
GstClockTime segment_duration;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
segment_duration = GST_SECOND * json_object_dotget_number (obj, "m3u8streaming.segment-duration");
json_value_free (val);
return segment_duration;
}
static JSON_Value *message_body_to_json(MessageBody *mbody) {
if (!mbody)
return NULL;
JSON_Value *body_value = json_value_init_object();
JSON_Object *body_object = json_value_get_object(body_value);
json_object_set_string(body_object, "type", mbody->content_type);
json_object_set_string(body_object, "content", mbody->content->str);
json_object_set_number(body_object, "size", mbody->size);
return body_value;
}
void serialization_example(void) {
JSON_Value *root_value = json_value_init_object();
JSON_Object *root_object = json_value_get_object(root_value);
char *serialized_string = NULL;
json_object_set_string(root_object, "name", "John Smith");
json_object_set_number(root_object, "age", 25);
json_object_dotset_string(root_object, "address.city", "Cupertino");
json_object_dotset_value(root_object, "contact.emails",
json_parse_string("[\"[email protected]\", \"[email protected]\"]"));
serialized_string = json_serialize_to_string(root_value);
puts(serialized_string);
json_free_serialized_string(serialized_string);
json_value_free(root_value);
}
gchar * jobdesc_m3u8streaming_push_server_uri (gchar *job)
{
JSON_Value *val;
JSON_Object *obj;
gchar *ret, *push_url;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
push_url = (gchar *)json_object_dotget_string (obj, "m3u8streaming.push-server-uri");
ret = g_strdup (push_url);
json_value_free (val);
return ret;
}
gchar * jobdesc_get_name (gchar *job)
{
JSON_Value *val;
JSON_Object *obj;
gchar *name, *ret;
val = json_parse_string_with_comments (job);
obj = json_value_get_object (val);
name = (gchar *)json_object_get_string (obj, "name");
ret = g_strdup (name);
json_value_free (val);
return ret;
}
corto_int16 json_deserialize(corto_value *v, corto_string s)
{
corto_assert(v != NULL, "NULL passed to json_deserialize");
char *json = s;
if ((json[0] != '{') && (json[1] != '[') && (json[0] != '[')) {
corto_asprintf(&json, "{\"value\": %s}", json);
}
JSON_Value *jsonValue = json_parse_string(json);
if (!jsonValue) {
corto_seterr("invalid JSON '%s'", json);
goto error;
}
corto_type type = corto_value_getType(v);
if (type->kind == CORTO_PRIMITIVE) {
JSON_Object* jsonObj = json_value_get_object(jsonValue);
if (!jsonObj) {
corto_seterr("json: invalid JSON for primitive value '%s'", json);
goto error;
}
JSON_Value *jsonValue = json_object_get_value(jsonObj, "value");
if (!jsonValue) {
corto_seterr("json: missing 'value' field for primitive value '%s'", json);
goto error;
}
}
if (json_deserialize_from_JSON_Value(v, jsonValue)) {
goto error;
}
if (json != s) {
corto_dealloc(json);
}
return 0;
error:
if (json != s) {
corto_dealloc(json);
}
if (jsonValue) {
json_value_free(jsonValue);
}
return -1;
}
