static inline list_t *
parse_package_deps(JSON_Object *obj) {
if (NULL == obj) return NULL;
list_t *list = list_new();
if (NULL == list) {
return NULL;
}
for (size_t i = 0; i < json_object_get_count(obj); i++) {
const char *name = json_object_get_name(obj, i);
if (!name) {
list_destroy(list);
return NULL;
}
const char *version = json_object_get_string_safe(obj, name);
if (!version) {
list_destroy(list);
return NULL;
}
clib_package_dependency_t *dep = clib_package_dependency_new(name, version);
if (NULL == dep) {
list_destroy(list);
return NULL;
}
list_node_t *node = list_node_new(dep);
list_rpush(list, node);
}
return list;
}
static inline list_t *
parse_package_deps(JSON_Object *obj) {
list_t *list = NULL;
if (!obj) goto done;
if (!(list = list_new())) goto done;
list->free = clib_package_dependency_free;
for (unsigned int i = 0; i < json_object_get_count(obj); i++) {
const char *name = NULL;
char *version = NULL;
clib_package_dependency_t *dep = NULL;
int error = 1;
if (!(name = json_object_get_name(obj, i))) goto loop_cleanup;
if (!(version = json_object_get_string_safe(obj, name))) goto loop_cleanup;
if (!(dep = clib_package_dependency_new(name, version))) goto loop_cleanup;
if (!(list_rpush(list, list_node_new(dep)))) goto loop_cleanup;
error = 0;
loop_cleanup:
if (version) free(version);
if (error) {
list_destroy(list);
list = NULL;
break;
}
}
done:
return list;
}
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 JSON_Value * json_object_nget_value(const JSON_Object *object, const char *name, size_t n) {
size_t i, name_length;
for (i = 0; i < json_object_get_count(object); i++) {
name_length = strlen(object->names[i]);
if (name_length != n) { continue; }
if (strncmp(object->names[i], name, n) == 0) { return object->values[i]; }
}
return NULL;
}
// 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;
}
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 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();
}
// 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;
}
}
}
}
}
}
// parses a JSON object containing zones and calculates the zone that fits the given latitude and longitude best, bestDistance is used internally and contains the distance from the midpoint of the selected zone
static void ParseZones(char **bestZone, double *bestDistance, JSON_Object *zonesJson, double latitude, double longitude)
{
*bestDistance = -1.0;
if (zonesJson != NULL)
{
size_t zoneCount = json_object_get_count(zonesJson);
for (int i = 0; i < zoneCount; i++)
{
const char *zoneName = json_object_get_name(zonesJson, i);
JSON_Value *valueJson = json_object_get_value(zonesJson, zoneName);
if (valueJson != NULL && valueJson->type == JSONObject)
{
JSON_Object *zoneJson = json_value_get_object(valueJson);
double topLeftX = 0.0, topLeftY = 0.0, bottomRightX = 0.0, bottomRightY = 0.0;
JSON_Object *subzonesJson = NULL;
size_t propertyCount = json_object_get_count(zoneJson);
for (int j = 0; j < propertyCount; j++)
{
const char *propertyName = json_object_get_name(zoneJson, j);
JSON_Value *propertyJson = json_object_get_value(zoneJson, propertyName);
if (propertyJson != NULL)
{
if (propertyJson->type == JSONNumber)
{
double number = json_value_get_number(propertyJson);
if (strcmp(propertyName, "tl_x") == 0)
topLeftX = number;
else if (strcmp(propertyName, "tl_y") == 0)
topLeftY = number;
else if (strcmp(propertyName, "br_x") == 0)
bottomRightX = number;
else if (strcmp(propertyName, "br_y") == 0)
bottomRightY = number;
}
else if (propertyJson->type == JSONObject && (strcmp(propertyName, "subzones") == 0))
subzonesJson = json_value_get_object(propertyJson);
}
}
if (topLeftX != 0.0 && topLeftY != 0.0 && bottomRightX != 0.0 && bottomRightY != 0.0 && longitude > topLeftX && latitude < topLeftY && longitude < bottomRightX && latitude > bottomRightY)
{
double latitudeMidpoint = 0.0, longitudeMidpoint = 0.0;
GetMidpoint(&latitudeMidpoint, &longitudeMidpoint, topLeftY, topLeftX, bottomRightY, bottomRightX);
double distance = GetDistance(latitudeMidpoint, longitudeMidpoint, latitude, longitude);
// printf("Distance from %s = %f\n", zoneName, distance);
if (*bestDistance == -1.0 || distance < *bestDistance)
{
if (*bestZone != NULL)
{
free(*bestZone);
*bestZone = NULL;
}
if (subzonesJson != NULL)
{
char *bestSubzone = NULL;
double subzoneDistance = -1.0;
ParseZones(&bestSubzone, &subzoneDistance, subzonesJson, latitude, longitude);
if (bestSubzone != NULL && subzoneDistance != -1.0)
{
*bestDistance = subzoneDistance;
*bestZone = bestSubzone;
}
}
if (*bestZone == NULL)
{
*bestDistance = distance;
*bestZone = (char*) malloc(strlen(zoneName) + 1);
if (*bestZone != NULL)
strcpy(*bestZone, zoneName);
}
}
}
}
}
}
}
static corto_int16 json_deserComposite(void* p, corto_type t, JSON_Value *v)
{
corto_assert(t->kind == CORTO_COMPOSITE, "not deserializing composite");
if (json_value_get_type(v) != JSONObject) {
corto_seterr("expected object, got %s", json_valueTypeToString(v));
goto error;
}
JSON_Object* o = json_value_get_object(v);
size_t count = json_object_get_count(o);
size_t i;
corto_bool isUnion = corto_interface(t)->kind == CORTO_UNION;
corto_int32 discriminator = 0;
corto_member unionMember = NULL;
for (i = 0; i < count; i++) {
const char* memberName = json_object_get_name(o, i);
corto_member member_o;
if (!strcmp(memberName, "super")) {
JSON_Value* value = json_object_get_value(o, memberName);
if (json_deserItem(p, corto_type(corto_interface(t)->base), value)) {
goto error;
}
} else if (!strcmp(memberName, "_d") && isUnion) {
JSON_Value* value = json_object_get_value(o, memberName);
if (json_deserPrimitive(&discriminator, corto_union(t)->discriminator, value)) {
goto error;
}
unionMember = corto_union_findCase(t, discriminator);
if (!unionMember) {
corto_seterr("discriminator '%d' invalid for union '%s'",
discriminator, corto_fullpath(NULL, t));
}
} else {
member_o = corto_interface_resolveMember(t, (char*)memberName);
/* Ensure that we're not resolving members from a base type */
if (!member_o || (corto_parentof(member_o) != t)) {
corto_seterr(
"cannot find member '%s' in type '%s'",
memberName,
corto_fullpath(NULL, t));
goto error;
}
if (isUnion && (unionMember != member_o)) {
corto_seterr(
"member '%s' does not match discriminator '%d' (expected member '%s')",
memberName,
discriminator,
corto_idof(unionMember));
goto error;
} else if (isUnion) {
corto_int32 prev = *(corto_int32*)p;
if (prev != discriminator) {
corto_member prevMember = corto_union_findCase(t, prev);
corto_deinitp(CORTO_OFFSET(p, prevMember->offset), prevMember->type);
memset(CORTO_OFFSET(p, member_o->offset), 0, member_o->type->size);
}
*(corto_int32*)p = discriminator;
}
if (!json_deserMustSkip(member_o, p)) {
JSON_Value* value = json_object_get_value(o, memberName);
void *offset = CORTO_OFFSET(p, member_o->offset);
if (member_o->modifiers & CORTO_OBSERVABLE) {
offset = *(void**)offset;
if (json_deserType(offset, member_o->type, value)) {
goto error;
}
} else {
if (member_o->modifiers & CORTO_OPTIONAL) {
if (*(void**)offset) {
corto_deinitp(*(void**)offset, member_o->type);
memset(*(void**)offset, 0, member_o->type->size);
} else {
*(void**)offset = corto_calloc(member_o->type->size);
}
offset = *(void**)offset;
}
if (json_deserItem(offset, member_o->type, value)) {
goto error;
}
}
}
}
}
return 0;
error:
return -1;
}
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;
}