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;
}
/**
* json_node_get_value:
* @node: a #JsonNode
* @value: (out caller-allocates): return location for an uninitialized value
*
* Retrieves a value from a #JsonNode and copies into @value. When done
* using it, call g_value_unset() on the #GValue.
*/
void
json_node_get_value (JsonNode *node,
GValue *value)
{
g_return_if_fail (JSON_NODE_IS_VALID (node));
g_return_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_VALUE);
if (node->data.value)
{
g_value_init (value, JSON_VALUE_TYPE (node->data.value));
switch (JSON_VALUE_TYPE (node->data.value))
{
case G_TYPE_INT64:
g_value_set_int64 (value, json_value_get_int (node->data.value));
break;
case G_TYPE_DOUBLE:
g_value_set_double (value, json_value_get_double (node->data.value));
break;
case G_TYPE_BOOLEAN:
g_value_set_boolean (value, json_value_get_boolean (node->data.value));
break;
case G_TYPE_STRING:
g_value_set_string (value, json_value_get_string (node->data.value));
break;
default:
break;
}
}
}
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;
}
}
bud_error_t bud_config_load_backend(bud_config_t* config,
JSON_Object* obj,
bud_config_backend_t* backend,
bud_hashmap_t* map,
unsigned int* ext_count) {
bud_error_t err;
JSON_Value* val;
const char* external;
int r;
bud_config_load_addr(obj, (bud_config_addr_t*) backend);
backend->config = config;
backend->xforward = -1;
val = json_object_get_value(obj, "proxyline");
if (json_value_get_type(val) == JSONString) {
const char* pline;
pline = json_value_get_string(val);
if (strcmp(pline, "haproxy") == 0)
backend->proxyline = kBudProxylineHAProxy;
else if (strcmp(pline, "json") == 0)
backend->proxyline = kBudProxylineJSON;
else
return bud_error_dstr(kBudErrProxyline, pline);
} else {
backend->proxyline = val != NULL && json_value_get_boolean(val) ?
kBudProxylineHAProxy :
kBudProxylineNone;
}
val = json_object_get_value(obj, "x-forward");
if (val != NULL)
backend->xforward = json_value_get_boolean(val);
/* Set defaults here to use them in sni.c */
bud_config_set_backend_defaults(backend);
r = bud_config_str_to_addr(backend->host, backend->port, &backend->addr);
if (r != 0)
return bud_error_num(kBudErrPton, r);
external = json_object_get_string(obj, "external");
if (external == NULL)
return bud_ok();
/* Insert backend into a hashmap */
err = bud_hashmap_insert(map, external, strlen(external), backend);
if (!bud_is_ok(err))
return err;
(*ext_count)++;
return bud_ok();
}
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;
}
}
/**
* json_node_get_string:
* @node: a #JsonNode of type %JSON_NODE_VALUE
*
* Gets the string value stored inside a #JsonNode
*
* Return value: a string value.
*/
const gchar *
json_node_get_string (JsonNode *node)
{
g_return_val_if_fail (JSON_NODE_IS_VALID (node), NULL);
if (JSON_NODE_TYPE (node) == JSON_NODE_NULL)
return NULL;
if (JSON_VALUE_HOLDS_STRING (node->data.value))
return json_value_get_string (node->data.value);
return NULL;
}
static void GenStat(Stat* s, JSON_Value* v) {
switch (json_value_get_type(v)) {
case JSONObject:
{
JSON_Object* o = json_value_get_object(v);
size_t count = json_object_get_count(o);
for (size_t i = 0; i < count; i++) {
const char* name = json_object_get_name(o, i);
GenStat(s, json_object_get_value(o, name));
s->stringLength += strlen(name);
}
s->objectCount++;
s->memberCount += count;
s->stringCount += count;
}
break;
case JSONArray:
{
JSON_Array* a = json_value_get_array(v);
size_t count = json_array_get_count(a);
for (int i = 0; i < count; i++)
GenStat(s, json_array_get_value(a, i));
s->arrayCount++;
s->elementCount += count;
}
break;
case JSONString:
s->stringCount++;
s->stringLength += strlen(json_value_get_string(v));
break;
case JSONNumber:
s->numberCount++;
break;
case JSONBoolean:
if (json_value_get_boolean(v))
s->trueCount++;
else
s->falseCount++;
break;
case JSONNull:
s->nullCount++;
break;
}
}
static corto_int16 json_deserText(void* p, corto_primitive t, JSON_Value *v)
{
const char *s = json_value_get_string(v);
CORTO_UNUSED(t);
if (json_value_get_type(v) != JSONString) {
corto_seterr("expected string, got %s", json_valueTypeToString(v));
goto error;
}
corto_setstr(p, (corto_string)s);
return 0;
error:
return -1;
}
static mrb_value
json_value_to_mrb_value(mrb_state* mrb, JSON_Value* value) {
ARENA_SAVE;
switch (json_value_get_type(value)) {
case JSONError:
case JSONNull:
return mrb_nil_value();
case JSONString:
return mrb_str_new_cstr(mrb, json_value_get_string(value));
case JSONNumber:
return mrb_float_value(json_value_get_number(value));
case JSONObject:
{
mrb_value hash = mrb_hash_new(mrb);
JSON_Object* object = json_value_get_object(value);
size_t count = json_object_get_count(object);
int n;
for (n = 0; n < count; n++) {
const char* name = json_object_get_name(object, n);
mrb_hash_set(mrb, hash, mrb_str_new_cstr(mrb, name),
json_value_to_mrb_value(mrb, json_object_get_value(object, name)));
}
return hash;
}
case JSONArray:
{
mrb_value ary;
ary = mrb_ary_new(mrb);
JSON_Array* array = json_value_get_array(value);
size_t count = json_array_get_count(array);
int n;
for (n = 0; n < count; n++) {
JSON_Value* elem = json_array_get_value(array, n);
mrb_ary_push(mrb, ary, json_value_to_mrb_value(mrb, elem));
}
return ary;
}
case JSONBoolean:
if (json_value_get_boolean(value)) {
return mrb_true_value();
}
return mrb_false_value();
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
return mrb_nil_value();
}
static corto_int16 json_deserConstant(void* p, corto_primitive t, JSON_Value *v)
{
const char *s = json_value_get_string(v);
CORTO_UNUSED(t);
if (json_value_get_type(v) != JSONString) {
corto_seterr("expected string, got %s", json_valueTypeToString(v));
goto error;
}
if (corto_convert(corto_string_o, (corto_string*)&s, t, p)) {
goto error;
}
return 0;
error:
return -1;
}
bud_error_t bud_sni_from_json(bud_config_t* config,
struct json_value_t* json,
bud_context_t* ctx) {
JSON_Object* obj;
JSON_Value* val;
const char* cert_str;
const char* key_str;
const char* pass_str;
JSON_Array* cert_strs;
JSON_Array* key_strs;
JSON_Array* pass_strs;
bud_error_t err;
cert_str = NULL;
key_str = NULL;
pass_str = NULL;
cert_strs = NULL;
key_strs = NULL;
pass_strs = NULL;
obj = json_value_get_object(json);
val = json_object_get_value(obj, "cert");
if (json_value_get_type(val) == JSONString)
cert_str = json_value_get_string(val);
else
cert_strs = json_value_get_array(val);
val = json_object_get_value(obj, "key");
if (json_value_get_type(val) == JSONString)
key_str = json_value_get_string(val);
else
key_strs = json_value_get_array(val);
val = json_object_get_value(obj, "passphrase");
if (json_value_get_type(val) == JSONString)
pass_str = json_value_get_string(val);
else
pass_strs = json_value_get_array(val);
if (obj == NULL ||
!((cert_str != NULL && key_str != NULL) ||
(cert_strs != NULL && key_strs != NULL))) {
err = bud_error_str(kBudErrJSONParse, "<SNI Response>");
goto fatal;
}
/* Load NPN from response */
memset(ctx, 0, sizeof(*ctx));
ctx->cert_file = cert_str;
ctx->key_file = key_str;
ctx->key_pass = pass_str;
ctx->cert_files = cert_strs;
ctx->key_files = key_strs;
ctx->key_passes = pass_strs;
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");
ctx->npn = json_object_get_array(obj, "npn");
ctx->ca_array = json_object_get_array(obj, "ca");
val = json_object_get_value(obj, "request_cert");
if (val != NULL)
ctx->request_cert = json_value_get_boolean(val);
err = bud_config_load_backend_list(config, obj, &ctx->backend);
if (!bud_is_ok(err))
goto fatal;
err = bud_context_init(config, ctx);
/* Make sure that deallocated values won't be used */
ctx->cert_file = NULL;
ctx->key_file = NULL;
ctx->key_pass = NULL;
ctx->cert_files = NULL;
ctx->key_files = NULL;
ctx->key_passes = NULL;
if (!bud_is_ok(err))
goto fatal;
return bud_ok();
fatal:
if (!bud_is_ok(err)) {
SSL_CTX_free(ctx->ctx);
ctx->ctx = NULL;
}
free(ctx->backend.list);
ctx->backend.list = NULL;
return err;
}
// updates the planes map, planes not seen for a defined intervall are removed from the map and only planes within a defined distance from the given latitude and longited
static void UpdatePlanes(char *balancerUrl, char *zoneName, double latitude, double longitude)
{
time_t currentTime = time(NULL);
if (currentTime != ((time_t) -1))
{
pthread_mutex_lock(&planesMutex);
for (std::map<std::string, Plane*>::iterator p = planes.begin(); p != planes.end(); ++p)
{
Plane *plane = p->second;
if (currentTime - plane->lastSeen > PLANE_TIMEOUT)
{
//printf("Removing: %s - CurrentTime = %d - LastSeen = %d\n", p->first.c_str(), (int) currentTime, (int) plane->lastSeen);
free(plane);
plane = NULL;
planes.erase(p->first);
}
}
pthread_mutex_unlock(&planesMutex);
char url[strlen(balancerUrl) + strlen(URL_ZONE_INFIX) + strlen(zoneName) + strlen(URL_ZONE_SUFFIX)];
sprintf(url, "%s%s%s%s", balancerUrl, URL_ZONE_INFIX, zoneName, URL_ZONE_SUFFIX);
char *zone = GetUrl(url);
if (zone != NULL)
{
int cmp = 1;
if (lastZone != NULL)
cmp = strcmp(zone, lastZone);
if (cmp != 0)
{
JSON_Value *rootJson = json_parse_string(zone);
lastZone = zone;
if (rootJson != NULL)
{
if (rootJson->type == JSONObject)
{
JSON_Object *aircraftJson = json_value_get_object(rootJson);
if (aircraftJson != NULL)
{
size_t aircraftCount = json_object_get_count(aircraftJson);
for (int i = 0; i < aircraftCount; i++)
{
const char *id = json_object_get_name(aircraftJson, i);
if (id != NULL)
{
JSON_Value *value = json_object_get_value(aircraftJson, id);
if (value != NULL && value->type == JSONArray)
{
JSON_Array *propertiesJson = json_value_get_array(value);
if (propertiesJson != NULL)
{
const char *registration = NULL, *icaoId = NULL, *icaoType = NULL, *squawk = NULL;
double latitudePlane = 0.0, longitudePlane = 0.0, altitude = 0.0;
float heading = 0.0f;
int speed = 0, verticalSpeed = 0;
int propertyCount = json_array_get_count(propertiesJson);
for (int k = 0; k < propertyCount; k++)
{
JSON_Value *valueJson = json_array_get_value(propertiesJson, k);
if (valueJson != NULL)
{
switch (k)
{
case ARRAY_INDEX_LATITUDE:
latitudePlane = json_value_get_number(valueJson);
break;
case ARRAY_INDEX_LONGITUDE:
longitudePlane = json_value_get_number(valueJson);
break;
case ARRAY_INDEX_ALTITUDE:
altitude = json_value_get_number(valueJson);
break;
case ARRAY_INDEX_HEADING:
heading = (float) json_value_get_number(valueJson);
break;
case ARRAY_INDEX_SPEED:
speed = (int) json_value_get_number(valueJson);
break;
case ARRAY_INDEX_SQUAWK:
squawk = json_value_get_string(valueJson);
break;
case ARRAY_INDEX_ICAO_TYPE:
icaoType = json_value_get_string(valueJson);
break;
case ARRAY_INDEX_REGISTRATION:
registration = json_value_get_string(valueJson);
break;
case ARRAY_INDEX_VERTICAL_SPEED:
verticalSpeed = (int) json_value_get_number(valueJson);
break;
case ARRAY_INDEX_ICAO_ID:
icaoId = json_value_get_string(valueJson);
break;
}
}
}
if (latitudePlane != 0.0 && longitudePlane != 0.0 && GetDistance(latitude, longitude, latitudePlane, longitudePlane) <= MAX_DISTANCE)
{
Plane *plane = NULL;
pthread_mutex_lock(&planesMutex);
std::map<std::string, Plane*>::iterator p = planes.find(id);
if (p != planes.end())
plane = p->second;
else
{
plane = (Plane*) malloc(sizeof(*plane));
if (plane != NULL)
planes[std::string(id)] = plane;
}
if (plane != NULL)
{
if (registration == NULL || strlen(registration) == 0)
registration = "Unknown";
if (icaoId == NULL || strlen(icaoId) == 0)
icaoId = "Unknown";
if (icaoType == NULL || strlen(icaoType) == 0)
icaoType = "UKN";
if (squawk == NULL || strlen(squawk) == 0)
squawk = "0000";
strncpy(plane->registration, registration, sizeof(plane->registration) / sizeof(char));
strncpy(plane->icaoId, icaoId, sizeof(plane->icaoId) / sizeof(char));
strncpy(plane->icaoType, icaoType, sizeof(plane->icaoType) / sizeof(char));
strncpy(plane->squawk, squawk, sizeof(plane->squawk) / sizeof(char));
if (plane->latitude != latitudePlane)
{
plane->latitude = latitudePlane;
plane->interpolatedLatitude = 0.0;
}
if (plane->longitude != longitudePlane)
{
plane->longitude = longitudePlane;
plane->interpolatedLongitude = 0.0;
}
if (plane->altitude != altitude)
{
plane->altitude = altitude;
plane->interpolatedAltitude = -1000.0;
}
plane->pitch = 0.0f;
plane->roll = 0.0f;
plane->heading = heading;
plane->speed = speed;
plane->verticalSpeed = verticalSpeed;
plane->lastSeen = currentTime;
}
pthread_mutex_unlock(&planesMutex);
}
}
}
}
}
}
json_value_free(rootJson);
rootJson = NULL;
}
}
}
}
}
}
static mrb_value
json_value_to_mrb_value(mrb_state* mrb, JSON_Value* value) {
mrb_value ret;
switch (json_value_get_type(value)) {
case JSONError:
case JSONNull:
ret = mrb_nil_value();
break;
case JSONString:
ret = mrb_str_new_cstr(mrb, json_value_get_string(value));
break;
case JSONNumber:
{
double d = json_value_get_number(value);
if (floor(d) == d) {
ret = mrb_fixnum_value(d);
}
else {
ret = mrb_float_value(mrb, d);
}
}
break;
case JSONObject:
{
mrb_value hash = mrb_hash_new(mrb);
JSON_Object* object = json_value_get_object(value);
size_t count = json_object_get_count(object);
size_t n;
for (n = 0; n < count; n++) {
int ai = mrb_gc_arena_save(mrb);
const char* name = json_object_get_name(object, n);
mrb_hash_set(mrb, hash, mrb_str_new_cstr(mrb, name),
json_value_to_mrb_value(mrb, json_object_get_value(object, name)));
mrb_gc_arena_restore(mrb, ai);
}
ret = hash;
}
break;
case JSONArray:
{
mrb_value ary;
JSON_Array* array;
size_t n, count;
ary = mrb_ary_new(mrb);
array = json_value_get_array(value);
count = json_array_get_count(array);
for (n = 0; n < count; n++) {
int ai = mrb_gc_arena_save(mrb);
JSON_Value* elem = json_array_get_value(array, n);
mrb_ary_push(mrb, ary, json_value_to_mrb_value(mrb, elem));
mrb_gc_arena_restore(mrb, ai);
}
ret = ary;
}
break;
case JSONBoolean:
if (json_value_get_boolean(value))
ret = mrb_true_value();
else
ret = mrb_false_value();
break;
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
return ret;
}
/**
*
* @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;
}
