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; }