static void router_rule_compile (RouterRule *rule, JsonObject *object) { RouterMatch *match; GList *names, *l; JsonNode *node; gint i; g_assert (rule->matches == NULL); names = json_object_get_members (object); rule->matches = g_new0 (RouterMatch, g_list_length (names) + 1); for (l = names, i = 0; l != NULL; l = g_list_next (l), i++) { match = &rule->matches[i]; match->name = g_strdup (l->data); node = json_object_get_member (object, l->data); /* A glob style string pattern */ if (JSON_NODE_HOLDS_VALUE (node) && json_node_get_value_type (node) == G_TYPE_STRING) match->glob = g_pattern_spec_new (json_node_get_string (node)); /* A null matches anything */ if (!JSON_NODE_HOLDS_NULL (node)) match->node = json_node_copy (node); } /* The last match has a null name */ g_list_free (names); }
static void add_alias_to_listing (GHashTable *listing, CockpitPackage *package, JsonNode *node) { const gchar *value; if (JSON_NODE_HOLDS_VALUE (node) && json_node_get_value_type (node) == G_TYPE_STRING) { value = json_node_get_string (node); if (validate_package (value)) { g_hash_table_replace (listing, (gchar *)value, cockpit_package_ref (package)); g_debug ("%s: package has alias: %s", package->name, value); } else { g_message ("invalid \"alias\" package name: \"%s\"", value); } } else { g_message ("invalid \"alias\" value type: \"%s\"", json_node_type_name (node)); } }
/*! * Convert the specified \c JsonNode into a string. * * \param node \c JsonNode. * \return Newly-allocated string on success, else \c NULL. */ static gchar * clr_oci_json_string (JsonNode* node) { gchar buffer[NODE_BUF_SIZE]; GType valueType = json_node_get_value_type(node); switch (valueType) { case G_TYPE_STRING: return json_node_dup_string(node); case G_TYPE_DOUBLE: case G_TYPE_FLOAT: g_snprintf(buffer, NODE_BUF_SIZE, "%f", json_node_get_double(node)); break; case G_TYPE_INT: case G_TYPE_INT64: g_snprintf(buffer, NODE_BUF_SIZE, "%ld", json_node_get_int(node)); break; case G_TYPE_BOOLEAN: if (json_node_get_boolean(node)) { g_snprintf(buffer, NODE_BUF_SIZE, "%s", "true"); } else { g_snprintf(buffer, NODE_BUF_SIZE, "%s", "false"); } break; default: g_snprintf(buffer, NODE_BUF_SIZE, "%s", "Unknown type"); break; } return g_strdup(buffer); }
/** * json_reader_get_string_value: * @reader: a #JsonReader * * Retrieves the string value of the current position of @reader * * Return value: the string value * * Since: 0.12 */ const gchar * json_reader_get_string_value (JsonReader *reader) { JsonNode *node; g_return_val_if_fail (JSON_IS_READER (reader), NULL); json_reader_return_val_if_error_set (reader, NULL); if (reader->priv->current_node == NULL) { json_reader_set_error (reader, JSON_READER_ERROR_INVALID_NODE, _("No node available at the current position")); return NULL; } node = reader->priv->current_node; if (!JSON_NODE_HOLDS_VALUE (node)) { json_reader_set_error (reader, JSON_READER_ERROR_NO_VALUE, _("The current position holds a '%s' and not a value"), json_node_type_get_name (JSON_NODE_TYPE (node))); return NULL; } if (json_node_get_value_type (node) != G_TYPE_STRING) { json_reader_set_error (reader, JSON_READER_ERROR_INVALID_TYPE, _("The current position does not hold a string type")); return NULL; } return json_node_get_string (reader->priv->current_node); }
/** * server_new_from_json: * @object: JSON object with server definition * * Looks at the type and then uses a subclassed function to build the * server. * * Return value: A new Server object or NULL if error */ Server * server_new_from_json (JsonObject * object) { g_return_val_if_fail(object != NULL, NULL); if (!json_object_has_member(object, "Protocol")) { return NULL; } JsonNode * proto_node = json_object_get_member(object, "Protocol"); if (JSON_NODE_TYPE(proto_node) != JSON_NODE_VALUE) { return NULL; } if (json_node_get_value_type(proto_node) != G_TYPE_STRING) { return NULL; } const gchar * proto = json_node_get_string(proto_node); Server * newserver = NULL; if (g_strcmp0(proto, "ICA") == 0 || g_strcmp0(proto, "ica") == 0) { newserver = citrix_server_new_from_json(object); } else if (g_strcmp0(proto, "freerdp") == 0 || g_strcmp0(proto, "rdp") == 0 || g_strcmp0(proto, "RDP") == 0 || g_strcmp0(proto, "FreeRDP") == 0) { newserver = rdp_server_new_from_json(object); } else if (g_strcmp0(proto, "x2go") == 0 || g_strcmp0(proto, "X2go") == 0 || g_strcmp0(proto, "X2Go") == 0 || g_strcmp0(proto, "X2GO") == 0 || g_strcmp0(proto, "x2GO") == 0 || g_strcmp0(proto, "x2gO") == 0) { newserver = x2go_server_new_from_json(object); } return newserver; }
static gboolean check_type (JsonNode *node, JsonNodeType type, GType sub_type, GError **error) { if (JSON_NODE_TYPE (node) != type || (type == JSON_NODE_VALUE && (json_node_get_value_type (node) != sub_type))) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Unexpected type '%s' in JSON node", g_type_name (json_node_get_value_type (node))); return FALSE; } return TRUE; }
static void _iterate_json_object(JsonObject *object, const gchar *member_name, JsonNode *member_node, gpointer user_data) { GHashTable* params = user_data; if (json_node_get_node_type(member_node) != JSON_NODE_VALUE) return; if (json_node_get_value_type(member_node) == G_TYPE_STRING) g_hash_table_insert(params, g_strdup(member_name), g_strdup(json_node_get_string(member_node))); else if (json_node_get_value_type(member_node) == G_TYPE_INT64) g_hash_table_insert(params, g_strdup(member_name), g_strdup_printf("%"G_GINT64_FORMAT, json_node_get_int(member_node))); }
gint json_node_get_parse_int_member(JsonNode *node, gboolean *success) { switch(json_node_get_value_type(node)) { case G_TYPE_INT64: if(success) *success = TRUE; return json_node_get_int(node); case G_TYPE_STRING: return flist_parse_int(json_node_get_string(node), success); } if(success) *success = FALSE; return 0; }
static gboolean _jsonutil_node_check_int (JsonNode *node) { if (!node) return FALSE; if (json_node_get_value_type (node) != G_TYPE_INT64) return FALSE; return TRUE; }
//Cast any type of scalar to a reasonable float. GobjectImplScalar::operator long double() const { switch (json_node_get_value_type(mNode)) { case G_TYPE_FLOAT: return g_value_get_float(&mValue); case G_TYPE_DOUBLE: return g_value_get_double(&mValue); case G_TYPE_BOOLEAN: return g_value_get_boolean(&mValue) ? 1.0 : 0.0; case G_TYPE_INT: return g_value_get_int(&mValue) * 1.0; case G_TYPE_UINT: return g_value_get_uint(&mValue) * 1.0; case G_TYPE_LONG: return g_value_get_long(&mValue) * 1.0; case G_TYPE_INT64: return g_value_get_int64(&mValue) * 1.0; case G_TYPE_ULONG: return g_value_get_ulong(&mValue) * 1.0; case G_TYPE_STRING: return boost::lexical_cast<long double>(g_value_get_string(&mValue)); default: return 0.0; } }
//Cast any type of scalar to a reasonable int. GobjectImplScalar::operator long long() const { switch (json_node_get_value_type(mNode)) { case G_TYPE_FLOAT: return 0; //Fixme, probably an exception is in place. case G_TYPE_DOUBLE: return 0; //Fixme, probably an exception is in place. case G_TYPE_BOOLEAN: return g_value_get_boolean(&mValue) ? 1 : 0; case G_TYPE_INT: return g_value_get_int(&mValue); case G_TYPE_UINT: return g_value_get_uint(&mValue); case G_TYPE_LONG: return g_value_get_long(&mValue); case G_TYPE_INT64: return g_value_get_int64(&mValue); case G_TYPE_ULONG: return g_value_get_ulong(&mValue); case G_TYPE_STRING: return boost::lexical_cast<long long>(g_value_get_string(&mValue)); default: return 0; } }
//Cast any type of scalar to a reasonable bool. GobjectImplScalar::operator bool() const { switch (json_node_get_value_type(mNode)) { case G_TYPE_FLOAT: return false; case G_TYPE_DOUBLE: return false; case G_TYPE_BOOLEAN: return g_value_get_boolean(&mValue); case G_TYPE_INT: return g_value_get_int(&mValue)==0 ? false : true; case G_TYPE_UINT: return g_value_get_uint(&mValue)==0 ? false : true; case G_TYPE_LONG: return g_value_get_long(&mValue)==0 ? false : true; case G_TYPE_ULONG: return g_value_get_ulong(&mValue)==0 ? false : true; case G_TYPE_INT64: return g_value_get_int64(&mValue)==0 ? false : true; case G_TYPE_STRING: return std::string(g_value_get_string(&mValue)) == "" ? false: true; default: return false; } }
/* Build the RDP server from information in the JSON object */ Server * rdp_server_new_from_json (JsonObject * object) { RdpServer * server = g_object_new(RDP_SERVER_TYPE, NULL); if (json_object_has_member(object, JSON_SERVER_NAME)) { JsonNode * node = json_object_get_member(object, JSON_SERVER_NAME); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * name = json_node_get_string(node); server->parent.name = g_strdup(name); } } if (json_object_has_member(object, JSON_URI)) { JsonNode * node = json_object_get_member(object, JSON_URI); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * uri = json_node_get_string(node); server->parent.uri = g_strdup(uri); } } if (json_object_has_member(object, JSON_USERNAME)) { JsonNode * node = json_object_get_member(object, JSON_USERNAME); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * username = json_node_get_string(node); server->username = g_strdup(username); } } if (json_object_has_member(object, JSON_PASSWORD)) { JsonNode * node = json_object_get_member(object, JSON_PASSWORD); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * password = json_node_get_string(node); server->password = g_strdup(password); mlock(server->password, strlen(server->password)); } } if (json_object_has_member(object, JSON_DOMAIN)) { JsonNode * node = json_object_get_member(object, JSON_DOMAIN); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_STRING) { const gchar * domain = json_node_get_string(node); server->domain = g_strdup(domain); } } if (json_object_has_member(object, JSON_DOMAIN_REQ)) { JsonNode * node = json_object_get_member(object, JSON_DOMAIN_REQ); if (JSON_NODE_TYPE(node) == JSON_NODE_VALUE && json_node_get_value_type(node) == G_TYPE_BOOLEAN) { server->domain_required = json_node_get_boolean(node); } } return SERVER(server); }
//Cast any type of scalar to a reasonable string. GobjectImplScalar::operator std::string() const { if (! mNode) { return ""; } switch (json_node_get_value_type(mNode)) { case G_TYPE_FLOAT: return boost::lexical_cast<std::string>(g_value_get_float(&mValue)); case G_TYPE_DOUBLE: return boost::lexical_cast<std::string>(g_value_get_double(&mValue)); case G_TYPE_BOOLEAN: return g_value_get_boolean(&mValue) ? "TRUE" : "FALSE"; case G_TYPE_INT: return boost::lexical_cast<std::string>(g_value_get_int(&mValue)); case G_TYPE_UINT: return boost::lexical_cast<std::string>(g_value_get_uint(&mValue)); case G_TYPE_LONG: return boost::lexical_cast<std::string>(g_value_get_long(&mValue)); case G_TYPE_INT64: return boost::lexical_cast<std::string>(g_value_get_int64(&mValue)); case G_TYPE_ULONG: return boost::lexical_cast<std::string>(g_value_get_ulong(&mValue)); case G_TYPE_STRING: return g_value_get_string(&mValue); default: return ""; } }
//Map glib json lib enum to JsonMe++ enum. jsonme::scalartype GobjectImplScalar::scalartype() const { switch (json_node_get_value_type(mNode)) { case G_TYPE_BOOLEAN : return jsonme::BOOL; case G_TYPE_INT: case G_TYPE_UINT: case G_TYPE_LONG: case G_TYPE_ULONG: case G_TYPE_INT64: return jsonme::INTEGER; case G_TYPE_FLOAT: case G_TYPE_DOUBLE: return jsonme::FLOAT; case G_TYPE_STRING: return jsonme::STRING; default: return jsonme::NULLVAL; } }
static int output_json_node_value (JsonNode *node, PRN *prn) { GType type = 0; int err = 0; if (null_node(node)) { gretl_errmsg_set("jsonget: got a null node"); return E_DATA; } type = json_node_get_value_type(node); #if 0 fprintf(stderr, "jsonget: node type %s\n", g_type_name(type)); #endif if (!handled_type(type)) { gretl_errmsg_sprintf("jsonget: unhandled object type '%s'", g_type_name(type)); err = E_DATA; } else if (type == G_TYPE_STRING) { const gchar *s = json_node_get_string(node); if (s != NULL) { pputs(prn, s); } else { err = E_DATA; } } else if (type == G_TYPE_DOUBLE) { double x = json_node_get_double(node); pprintf(prn, "%.15g", x); } else { gint64 k = json_node_get_int(node); double x = (double) k; pprintf(prn, "%.15g", x); } return err; }
void js_util_pushjsonnode(js_State *state, JsonNode *node) { GType type; if (!JSON_NODE_HOLDS_VALUE(node)) { js_pushundefined(state); return; } type = json_node_get_value_type(node); if (type == G_TYPE_STRING) js_pushstring(state, json_node_get_string(node)); else if (type == G_TYPE_INT) js_pushnumber(state, json_node_get_int(node)); else if (type == G_TYPE_BOOLEAN) js_pushboolean(state, json_node_get_boolean(node)); else js_pushundefined(state); }
gboolean _rpmostree_jsonutil_object_get_optional_boolean_member (JsonObject *object, const char *member_name, gboolean *out_value, GError **error) { gboolean ret = FALSE; JsonNode *node = json_object_get_member (object, member_name); if (node != NULL) { if (json_node_get_value_type (node) != G_TYPE_BOOLEAN) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Member '%s' is not a boolean", member_name); goto out; } *out_value = json_node_get_boolean (node); } ret = TRUE; out: return ret; }
static void postal_http_handle_v1_notify (UrlRouter *router, SoupServer *server, SoupMessage *message, const gchar *path, GHashTable *params, GHashTable *query, SoupClientContext *client, gpointer user_data) { PostalNotification *notif; const gchar *collapse_key = NULL; const gchar *str; PostalHttp *http = user_data; JsonObject *aps; JsonObject *c2dm; JsonObject *gcm; JsonObject *object; JsonArray *devices; JsonArray *users; GPtrArray *devices_ptr; GPtrArray *users_ptr; JsonNode *node; GError *error = NULL; guint count; guint i; g_assert(SOUP_IS_SERVER(server)); g_assert(SOUP_IS_MESSAGE(message)); g_assert(path); g_assert(client); g_assert(POSTAL_IS_HTTP(http)); if (message->method != SOUP_METHOD_POST) { soup_message_set_status(message, SOUP_STATUS_METHOD_NOT_ALLOWED); return; } soup_server_pause_message(server, message); if (!(node = postal_http_parse_body(message, &error))) { postal_http_reply_error(http, message, error); g_error_free(error); return; } if (!JSON_NODE_HOLDS_OBJECT(node) || !(object = json_node_get_object(node)) || !json_object_has_member(object, "aps") || !(node = json_object_get_member(object, "aps")) || !JSON_NODE_HOLDS_OBJECT(node) || !(aps = json_object_get_object_member(object, "aps")) || !json_object_has_member(object, "c2dm") || !(node = json_object_get_member(object, "c2dm")) || !JSON_NODE_HOLDS_OBJECT(node) || !(c2dm = json_object_get_object_member(object, "c2dm")) || !json_object_has_member(object, "gcm") || !(node = json_object_get_member(object, "gcm")) || !JSON_NODE_HOLDS_OBJECT(node) || !(gcm = json_object_get_object_member(object, "gcm")) || !json_object_has_member(object, "users") || !(node = json_object_get_member(object, "users")) || !JSON_NODE_HOLDS_ARRAY(node) || !(users = json_object_get_array_member(object, "users")) || !json_object_has_member(object, "devices") || !(node = json_object_get_member(object, "devices")) || !JSON_NODE_HOLDS_ARRAY(node) || !(devices = json_object_get_array_member(object, "devices"))) { error = g_error_new(postal_json_error_quark(), 0, "Missing or invalid fields in JSON payload."); postal_http_reply_error(http, message, error); json_node_free(node); g_error_free(error); return; } if (json_object_has_member(object, "collapse_key") && (node = json_object_get_member(object, "collapse_key")) && JSON_NODE_HOLDS_VALUE(node)) { collapse_key = json_node_get_string(node); } notif = g_object_new(POSTAL_TYPE_NOTIFICATION, "aps", aps, "c2dm", c2dm, "collapse-key", collapse_key, "gcm", gcm, NULL); count = json_array_get_length(users); users_ptr = g_ptr_array_sized_new(count); for (i = 0; i < count; i++) { node = json_array_get_element(users, i); if (json_node_get_value_type(node) == G_TYPE_STRING) { str = json_node_get_string(node); g_ptr_array_add(users_ptr, (gchar *)str); } } g_ptr_array_add(users_ptr, NULL); count = json_array_get_length(devices); devices_ptr = g_ptr_array_sized_new(count); g_ptr_array_set_free_func(devices_ptr, g_free); for (i = 0; i < count; i++) { node = json_array_get_element(devices, i); if (json_node_get_value_type(node) == G_TYPE_STRING) { str = json_node_get_string(node); g_ptr_array_add(devices_ptr, g_strdup(str)); } } g_ptr_array_add(devices_ptr, NULL); postal_service_notify(http->priv->service, notif, (gchar **)users_ptr->pdata, (gchar **)devices_ptr->pdata, NULL, /* TODO: Cancellable/Timeout? */ postal_http_notify_cb, g_object_ref(message)); g_ptr_array_unref(devices_ptr); g_ptr_array_unref(users_ptr); json_node_free(node); g_object_unref(notif); }
static int websocket_callback(struct libwebsocket_context *context,struct libwebsocket *wsi,enum libwebsocket_callback_reasons reason, void *user,void *in, size_t len) { //printf("Switch: %i\n",reason); switch (reason) { case LWS_CALLBACK_CLIENT_WRITEABLE: { //Connection has been established. //printf("Connection established\n"); break; } case LWS_CALLBACK_CLOSED: { //Connection is closed, we need to remove all related sinks sinkManager->disconnectAll(wsi); /*g_io_ GIOChannel *chan = g_io_channel_unix_new((int)(long)user); g_io_add_watch(chan,G_IO_IN,(GIOFunc)gioPollingFunc,0); g_io_add_watch(chan,G_IO_PRI,(GIOFunc)gioPollingFunc,0); pollfds[count_pollfds].fd = (int)(long)user; pollfds[count_pollfds].events = (int)len; // pollfds[count_pollfds++].revents = 0;*/ break; } case LWS_CALLBACK_CLIENT_RECEIVE: { //printf("Client writable\n"); break; } case LWS_CALLBACK_SERVER_WRITEABLE: { //printf("Server writable\n"); break; } case LWS_CALLBACK_RECEIVE: { //printf("Data Received: %s\n",(char*)in); //The lack of a break; here is intentional. } case LWS_CALLBACK_HTTP: { //TODO: Verify that ALL requests get sent via LWS_CALLBACK_HTTP, so we can use that instead of LWS_CALLBACK_RECIEVE //TODO: Do we want exceptions, or just to return an invalid json reply? Probably an invalid json reply. DebugOut() << __SMALLFILE__ << ":" << __LINE__ << " Requested: " << (char*)in << "\n"; GError* error = nullptr; JsonParser* parser = json_parser_new(); if (!json_parser_load_from_data(parser,(char*)in,len,&error)) { DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "Error loading JSON\n"; return 0; } JsonNode* node = json_parser_get_root(parser); if(node == nullptr) { DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "Error getting root node of json\n"; //throw std::runtime_error("Unable to get JSON root object"); return 0; } JsonReader* reader = json_reader_new(node); if(reader == nullptr) { DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "json_reader is null!\n"; //throw std::runtime_error("Unable to create JSON reader"); return 0; } string type; json_reader_read_member(reader,"type"); type = json_reader_get_string_value(reader); json_reader_end_member(reader); string name; json_reader_read_member(reader,"name"); name = json_reader_get_string_value(reader); json_reader_end_member(reader); string id; json_reader_read_member(reader,"transactionid"); if (strcmp("gchararray",g_type_name(json_node_get_value_type(json_reader_get_value(reader)))) == 0) { //Type is a string id = json_reader_get_string_value(reader); } else { //Type is an integer stringstream strstr; strstr << json_reader_get_int_value(reader); id = strstr.str(); } json_reader_end_member(reader); if (type == "method" && name == "getRanged") { json_reader_read_member(reader,"data"); if (json_reader_is_object(reader)) { double timeBegin; double timeEnd; double sequenceBegin; double sequenceEnd; string property; if (json_reader_read_member(reader,"timeBegin")) { timeBegin = boost::lexical_cast<double,std::string>(json_reader_get_string_value(reader)); json_reader_end_member(reader); } if (json_reader_read_member(reader,"timeEnd")) { timeEnd = boost::lexical_cast<double,std::string>(json_reader_get_string_value(reader)); json_reader_end_member(reader); } if (json_reader_read_member(reader,"sequenceBegin")) { sequenceBegin = boost::lexical_cast<double,std::string>(json_reader_get_string_value(reader)); json_reader_end_member(reader); } if (json_reader_read_member(reader,"sequenceEnd")) { sequenceEnd = boost::lexical_cast<double,std::string>(json_reader_get_string_value(reader)); json_reader_end_member(reader); } if (json_reader_read_member(reader,"property")) { property = json_reader_get_string_value(reader); json_reader_end_member(reader); } if ((timeBegin < 0 && timeEnd > 0) || (timeBegin > 0 && timeEnd < 0)) { //Invalid time begin/end pair } if ((sequenceBegin < 0 && sequenceEnd > 0) || (sequenceBegin > 0 && sequenceEnd < 0)) { //Invalid sequence begin/end pair } sinkManager->addSingleShotRangedSink(wsi,property,timeBegin,timeEnd,sequenceBegin,sequenceEnd,id); } json_reader_end_member(reader); } else { vector<string> data; list<string> key; list<string> value; json_reader_read_member(reader,"data"); if (json_reader_is_array(reader)) { for(int i=0; i < json_reader_count_elements(reader); i++) { json_reader_read_element(reader,i); if (json_reader_is_value(reader)) { //Raw string value string path = json_reader_get_string_value(reader); data.push_back(path); } else { //Not a raw string value, then it's "property/value" kvp, for "set" requests json_reader_read_member(reader,"property"); string keystr = json_reader_get_string_value(reader); key.push_back(keystr); json_reader_end_member(reader); json_reader_read_member(reader,"value"); string valuestr = json_reader_get_string_value(reader); value.push_back(valuestr); json_reader_end_member(reader); } json_reader_end_element(reader); } } else { string path = json_reader_get_string_value(reader); if (path != "") { data.push_back(path); } } json_reader_end_member(reader); if (type == "method") { if (name == "get") { if (data.size() > 0) { //GetProperty is going to be a singleshot sink. //string arg = arguments.front(); sinkManager->addSingleShotSink(wsi,data.front(),id); } else { DebugOut() << __SMALLFILE__ << ":" << __LINE__ << " \"get\" method called with no data! Transaction ID:" << id << "\n"; } } else if (name == "set") { if (data.size() > 0) { //Should not happen } else if (value.size() > 0) { if (key.size() != value.size()) { DebugOut() << __SMALLFILE__ << ":" << __LINE__ << "\"set\" method called with an invalid key value pair count\n"; } else { list<string>::iterator d = value.begin(); for (list<string>::iterator i=key.begin();i!=key.end();i++) { DebugOut() << __SMALLFILE__ << ":" << __LINE__ << "websocketsinkmanager setting" << (*i) << "to" << (*d) << "\n"; //(*i); sinkManager->setValue((*i),(*d)); //(*d); d++; } } } } else if (name == "subscribe") { //Websocket wants to subscribe to an event, data.front(); for (auto i=data.begin();i!=data.end();i++) { sinkManager->addSink(wsi,(*i),id); } } else if (name == "unsubscribe") { //Websocket wants to unsubscribe to an event, data.front(); for (auto i=data.begin();i!=data.end();i++) { sinkManager->removeSink(wsi,(*i),id); } } else if (name == "getSupportedEventTypes") { //If data.front() dosen't contain a property name, return a list of properties supported. //if it does, then return the event types that particular property supports. string typessupported = ""; if (data.size() == 0) { //Send what properties we support typessupported = "\"running_status_speedometer\",\"running_status_engine_speed\",\"running_status_steering_wheel_angle\",\"running_status_transmission_gear_status\""; PropertyList foo = sinkManager->getSupportedProperties(); PropertyList::const_iterator i=foo.cbegin(); while (i != foo.cend()) { typessupported.append(",\"").append((*i)).append("\""); i++; } } else { //Send what events a particular property supports if (data.front()== "running_status_speedometer") { typessupported = "\"get\",\"subscribe\",\"unsubscribe\",\"getSupportedEventTypes\""; } else if (data.front()== "running_status_engine_speed") { typessupported = "\"get\",\"subscribe\",\"unsubscribe\",\"getSupportedEventTypes\""; } else if (data.front() == "running_status_steering_wheel_angle") { typessupported = "\"get\",\"subscribe\",\"unsubscribe\",\"getSupportedEventTypes\""; } else if (data.front() == "running_status_transmission_gear_status") { typessupported = "\"get\",\"subscribe\",\"unsubscribe\",\"getSupportedEventTypes\""; } else { PropertyList foo = sinkManager->getSupportedProperties(); if (ListPlusPlus<VehicleProperty::Property>(&foo).contains(data.front())) { //sinkManager->addSingleShotSink(wsi,data.front(),id); typessupported = "\"get\",\"subscribe\",\"unsubscribe\",\"getSupportedEventTypes\""; } } } stringstream s; string s2; s << "{\"type\":\"methodReply\",\"name\":\"getSupportedEventTypes\",\"data\":[" << typessupported << "],\"transactionid\":\"" << id << "\"}"; string replystr = s.str(); DebugOut() << __SMALLFILE__ << ":" << __LINE__ << " JSON Reply: " << replystr << "\n"; //printf("Reply: %s\n",replystr.c_str()); char *new_response = new char[LWS_SEND_BUFFER_PRE_PADDING + strlen(replystr.c_str()) + LWS_SEND_BUFFER_POST_PADDING]; new_response+=LWS_SEND_BUFFER_PRE_PADDING; strcpy(new_response,replystr.c_str()); libwebsocket_write(wsi, (unsigned char*)new_response, strlen(new_response), LWS_WRITE_TEXT); delete (char*)(new_response-LWS_SEND_BUFFER_PRE_PADDING); } else { DebugOut(0)<<"Unknown method called."<<endl; } } } ///TODO: this will probably explode: //mlc: I agree with Kevron here, it does explode. //if(error) g_error_free(error); g_object_unref(reader); g_object_unref(parser); break; } case LWS_CALLBACK_ADD_POLL_FD: { //printf("Adding poll %i\n",sinkManager); //DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "Adding poll" << (int)sinkManager << "\n"; if (sinkManager != 0) { sinkManager->addPoll((int)(long)user); } break; } case LWS_CALLBACK_DEL_POLL_FD: { sinkManager->removePoll((int)(long)user); break; } case LWS_CALLBACK_SET_MODE_POLL_FD: { //Set the poll mode break; } case LWS_CALLBACK_CLEAR_MODE_POLL_FD: { //Don't handle this yet. break; } default: { //printf("Unhandled callback: %i\n",reason); DebugOut() << __SMALLFILE__ <<":"<< __LINE__ << "Unhandled callback:" << reason << "\n"; break; } } return 0; }
/* Save key/values on the table in the stack if the value is an * object or an array, it calls recursively the function again. * * @param L, pointer to the L with nil on top of it; * @param reader, pointed to the first element of main object; * * returns: the table in the stack with all json values */ static void build_table_from_json_reader (lua_State *L, JsonReader *reader) { const GError *err = json_reader_get_error (reader); if (err != NULL) { GRL_WARNING ("Error when building json: %s", err->message); return; } if (lua_isnil (L, -1)) { /* In the first execution of this recursive call, the main json object * does not have a member name. The nil is in the top of the stack and * it shall be converted to the table with json content */ lua_pop (L, 1); } else if (lua_istable (L, -1)) { const gchar *member_name = json_reader_get_member_name (reader); if (member_name) lua_pushstring (L, member_name); } else if (!lua_isnumber (L, -1)) { GRL_DEBUG ("getting value to either table or array"); return; } if (json_reader_is_object (reader)) { guint index_member = 0; guint num_members = json_reader_count_members (reader); lua_createtable (L, num_members, 0); for (index_member = 0; index_member < num_members; index_member++) { json_reader_read_element (reader, index_member); build_table_from_json_reader (L, reader); json_reader_end_element (reader); } } else if (json_reader_is_array (reader)) { guint index_element = 0; guint num_elements = json_reader_count_elements (reader); lua_createtable (L, num_elements, 0); for (index_element = 0; index_element < num_elements; index_element++) { json_reader_read_element (reader, index_element); lua_pushinteger (L, index_element + 1); build_table_from_json_reader (L, reader); json_reader_end_element (reader); } } else if (json_reader_is_value (reader)) { if (json_reader_get_null_value (reader)) { lua_pushnil (L); } else { /* value of the element */ JsonNode *value = json_reader_get_value (reader); switch (json_node_get_value_type (value)) { case G_TYPE_STRING: lua_pushstring (L, json_reader_get_string_value (reader)); break; case G_TYPE_INT64: lua_pushinteger (L, json_reader_get_int_value (reader)); break; case G_TYPE_DOUBLE: lua_pushnumber (L, json_reader_get_double_value (reader)); break; case G_TYPE_BOOLEAN: lua_pushnumber (L, json_reader_get_boolean_value (reader)); break; default: GRL_DEBUG ("'%d' (json-node-type) is not being handled", (gint) json_node_get_value_type (value)); lua_pushnil (L); } } } if (lua_gettop (L) > 3) { /* save this key/value on previous table */ lua_settable (L, -3); } }
static GValue *getValue(JsonNode *node) { GValue *p = new GValue; GValue &ret = *p; switch (JSON_NODE_TYPE(node)) { case JSON_NODE_OBJECT: { JsonObject *node_object; node_object = json_node_get_object (node); g_assert (node_object != NULL); GHashTable *object = g_hash_table_new(g_str_hash, g_str_equal); json_object_foreach_member(node_object, parseMembers, object); g_value_init(&ret, G_TYPE_HASH_TABLE); g_value_set_boxed(&ret, object); } break; case JSON_NODE_ARRAY: { JsonArray *node_array; node_array = json_node_get_array (node); g_assert (node_array != NULL); GValueArray *array = g_value_array_new(0); json_array_foreach_element(node_array, parseElements, array); g_value_init(&ret, G_TYPE_VALUE_ARRAY); g_value_set_boxed(&ret, array); } break; case JSON_NODE_VALUE: { switch (json_node_get_value_type(node)) { case G_TYPE_INT64: { gint64 val = json_node_get_int(node); g_value_init (&ret, G_TYPE_INT64); g_value_set_int64(&ret, val); } break; case G_TYPE_DOUBLE: { double val = json_node_get_double(node); g_value_init (&ret, G_TYPE_INT64); g_value_set_double(&ret, val); } break; case G_TYPE_BOOLEAN: { bool val = json_node_get_boolean(node); g_value_init (&ret, G_TYPE_INT64); g_value_set_boolean(&ret, val); } break; case G_TYPE_STRING: { const gchar * str = json_node_get_string(node); g_value_init (&ret, G_TYPE_STRING); g_value_set_string(&ret, str); } break; default: break; } } break; case JSON_NODE_NULL: break; } return &ret; }
static void on_socket_connect (GObject *object, GAsyncResult *result, gpointer user_data) { CockpitWebSocketStream *self = COCKPIT_WEB_SOCKET_STREAM (user_data); CockpitChannel *channel = COCKPIT_CHANNEL (self); const gchar *problem = "protocol-error"; gchar **protocols = NULL; GList *l, *names = NULL; GError *error = NULL; JsonObject *options; JsonObject *headers; const gchar *value; JsonNode *node; GIOStream *io; io = cockpit_connect_stream_finish (result, &error); if (error) { problem = cockpit_stream_problem (error, self->origin, "couldn't connect", cockpit_channel_close_options (channel)); cockpit_channel_close (channel, problem); goto out; } options = cockpit_channel_get_options (channel); if (!cockpit_json_get_strv (options, "protocols", NULL, &protocols)) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid \"protocol\" value in WebSocket stream request", self->origin); goto out; } if (G_IS_TLS_CONNECTION (io)) { self->sig_accept_cert = g_signal_connect (G_TLS_CONNECTION (io), "accept-certificate", G_CALLBACK (on_rejected_certificate), self); } else { self->sig_accept_cert = 0; } self->client = web_socket_client_new_for_stream (self->url, self->origin, (const gchar **)protocols, io); node = json_object_get_member (options, "headers"); if (node) { if (!JSON_NODE_HOLDS_OBJECT (node)) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid \"headers\" field in WebSocket stream request", self->origin); goto out; } headers = json_node_get_object (node); names = json_object_get_members (headers); for (l = names; l != NULL; l = g_list_next (l)) { node = json_object_get_member (headers, l->data); if (!node || !JSON_NODE_HOLDS_VALUE (node) || json_node_get_value_type (node) != G_TYPE_STRING) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid header value in WebSocket stream request: %s", self->origin, (gchar *)l->data); goto out; } value = json_node_get_string (node); g_debug ("%s: sending header: %s %s", self->origin, (gchar *)l->data, value); web_socket_client_include_header (WEB_SOCKET_CLIENT (self->client), l->data, value); } } self->sig_open = g_signal_connect (self->client, "open", G_CALLBACK (on_web_socket_open), self); self->sig_message = g_signal_connect (self->client, "message", G_CALLBACK (on_web_socket_message), self); self->sig_closing = g_signal_connect (self->client, "closing", G_CALLBACK (on_web_socket_closing), self); self->sig_close = g_signal_connect (self->client, "close", G_CALLBACK (on_web_socket_close), self); self->sig_error = g_signal_connect (self->client, "error", G_CALLBACK (on_web_socket_error), self); problem = NULL; out: g_clear_error (&error); g_strfreev (protocols); if (io) g_object_unref (io); g_list_free (names); }
static void send_http_request (CockpitHttpStream *self) { CockpitChannel *channel = COCKPIT_CHANNEL (self); JsonObject *options; gboolean had_host; gboolean had_encoding; const gchar *method; const gchar *path; GString *string = NULL; JsonNode *node; JsonObject *headers; const gchar *header; const gchar *value; GList *request = NULL; GList *names = NULL; GBytes *bytes; GList *l; gsize total; options = cockpit_channel_get_options (channel); /* * The checks we do here for token validity are just enough to be able * to format an HTTP response, without leaking across lines etc. */ if (!cockpit_json_get_string (options, "path", NULL, &path)) { cockpit_channel_fail (channel, "protocol-error", "%s: bad \"path\" field in HTTP stream request", self->name); goto out; } else if (path == NULL) { cockpit_channel_fail (channel, "protocol-error", "%s: missing \"path\" field in HTTP stream request", self->name); goto out; } else if (!cockpit_web_response_is_simple_token (path)) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid \"path\" field in HTTP stream request", self->name); goto out; } if (!cockpit_json_get_string (options, "method", NULL, &method)) { cockpit_channel_fail (channel, "protocol-error", "%s: bad \"method\" field in HTTP stream request", self->name); goto out; } else if (method == NULL) { cockpit_channel_fail (channel, "protocol-error", "%s: missing \"method\" field in HTTP stream request", self->name); goto out; } else if (!cockpit_web_response_is_simple_token (method)) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid \"method\" field in HTTP stream request", self->name); goto out; } g_debug ("%s: sending %s request", self->name, method); string = g_string_sized_new (128); g_string_printf (string, "%s %s HTTP/1.1\r\n", method, path); had_encoding = had_host = FALSE; node = json_object_get_member (options, "headers"); if (node) { if (!JSON_NODE_HOLDS_OBJECT (node)) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid \"headers\" field in HTTP stream request", self->name); goto out; } headers = json_node_get_object (node); names = json_object_get_members (headers); for (l = names; l != NULL; l = g_list_next (l)) { header = l->data; if (!cockpit_web_response_is_simple_token (header)) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid header in HTTP stream request: %s", self->name, header); goto out; } node = json_object_get_member (headers, header); if (!node || !JSON_NODE_HOLDS_VALUE (node) || json_node_get_value_type (node) != G_TYPE_STRING) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid header value in HTTP stream request: %s", self->name, header); goto out; } value = json_node_get_string (node); if (disallowed_header (header, value, self->binary)) { cockpit_channel_fail (channel, "protocol-error", "%s: disallowed header in HTTP stream request: %s", self->name, header); goto out; } if (!cockpit_web_response_is_header_value (value)) { cockpit_channel_fail (channel, "protocol-error", "%s: invalid header value in HTTP stream request: %s", self->name, header); goto out; } g_string_append_printf (string, "%s: %s\r\n", (gchar *)l->data, value); g_debug ("%s: sending header: %s %s", self->name, (gchar *)l->data, value); if (g_ascii_strcasecmp (l->data, "Host") == 0) had_host = TRUE; if (g_ascii_strcasecmp (l->data, "Accept-Encoding") == 0) had_encoding = TRUE; } } if (!had_host) { g_string_append (string, "Host: "); g_string_append_uri_escaped (string, self->client->connectable->name, "[]!%$&()*+,-.:;=\\_~", FALSE); g_string_append (string, "\r\n"); } if (!had_encoding) g_string_append (string, "Accept-Encoding: identity\r\n"); if (!self->binary) g_string_append (string, "Accept-Charset: UTF-8\r\n"); request = g_list_reverse (self->request); self->request = NULL; /* Calculate how much data we have to send */ total = 0; for (l = request; l != NULL; l = g_list_next (l)) total += g_bytes_get_size (l->data); if (request || g_ascii_strcasecmp (method, "POST") == 0) g_string_append_printf (string, "Content-Length: %" G_GSIZE_FORMAT "\r\n", total); g_string_append (string, "\r\n"); bytes = g_string_free_to_bytes (string); string = NULL; cockpit_stream_write (self->stream, bytes); g_bytes_unref (bytes); /* Now send all the data */ for (l = request; l != NULL; l = g_list_next (l)) cockpit_stream_write (self->stream, l->data); out: g_list_free (names); g_list_free_full (request, (GDestroyNotify)g_bytes_unref); if (string) g_string_free (string, TRUE); }
static int real_json_get (JsonParser *parser, const char *pathstr, int *n_objects, PRN *prn) { GError *gerr = NULL; JsonNode *match, *node; JsonPath *path; GType ntype; double x; int err = 0; *n_objects = 0; node = json_parser_get_root(parser); path = json_path_new(); if (!json_path_compile(path, pathstr, &gerr)) { if (gerr != NULL) { gretl_errmsg_sprintf("Failed to compile JsonPath: %s", gerr->message); g_error_free(gerr); } else { gretl_errmsg_set("Failed to compile JsonPath"); } g_object_unref(path); return E_DATA; } match = json_path_match(path, node); if (match == NULL) { /* FIXME : maybe return empty string? */ g_object_unref(path); return E_DATA; } /* in case we get floating-point output */ gretl_push_c_numeric_locale(); if (JSON_NODE_HOLDS_ARRAY(match)) { JsonArray *array; array = json_node_get_array(match); node = json_array_get_element(array, 0); repeat: if (node == NULL) { gretl_errmsg_set("Failed to match JsonPath"); ntype = 0; } else { ntype = json_node_get_value_type(node); } if (!handled_type(ntype)) { if (JSON_NODE_HOLDS_ARRAY(node)) { array = json_node_get_array(node); node = json_array_get_element(array, 0); goto repeat; } else { gretl_errmsg_sprintf("Unhandled array type '%s'", g_type_name(ntype)); err = E_DATA; } } else { int i, n = json_array_get_length(array); for (i=0; i<n; i++) { node = json_array_get_element(array, i); if (ntype == G_TYPE_STRING) { pputs(prn, json_node_get_string(node)); } else { x = json_node_get_double(node); pprintf(prn, "%.15g", x); } if (n > 1) { pputc(prn, '\n'); } } *n_objects = n; } } else { ntype = json_node_get_value_type(match); if (!handled_type(ntype)) { gretl_errmsg_sprintf("Unhandled object type '%s'", g_type_name(ntype)); err = E_DATA; } else { if (ntype == G_TYPE_STRING) { pputs(prn, json_node_get_string(match)); } else { x = json_node_get_double(match); pprintf(prn, "%.15g", x); } *n_objects = 1; } } gretl_pop_c_numeric_locale(); json_node_free(match); g_object_unref(path); return err; }
i3ipcCon *i3ipc_con_new(i3ipcCon *parent, JsonObject *data, i3ipcConnection *conn) { i3ipcCon *con; con = g_object_new(I3IPC_TYPE_CON, NULL); g_object_ref(conn); con->priv->conn = conn; if (!json_object_get_null_member(data, "percent")) con->priv->percent = json_object_get_double_member(data, "percent"); if (!json_object_get_null_member(data, "window")) con->priv->window = json_object_get_int_member(data, "window"); if (json_object_has_member(data, "window_properties")) { JsonObject *window_properties = json_object_get_object_member(data, "window_properties"); if (json_object_has_member(window_properties, "class")) con->priv->window_class = g_strdup(json_object_get_string_member(window_properties, "class")); } if (json_object_has_member(data, "mark")) { con->priv->mark = g_strdup(json_object_get_string_member(data, "mark")); } con->priv->name = g_strdup(json_object_get_string_member(data, "name")); con->priv->focused = json_object_get_boolean_member(data, "focused"); con->priv->fullscreen_mode = json_object_get_boolean_member(data, "fullscreen_mode"); con->priv->urgent = json_object_get_boolean_member(data, "urgent"); con->priv->layout = g_strdup(json_object_get_string_member(data, "layout")); con->priv->orientation = g_strdup(json_object_get_string_member(data, "orientation")); con->priv->current_border_width = json_object_get_int_member(data, "current_border_width"); con->priv->border = g_strdup(json_object_get_string_member(data, "border")); con->priv->id = json_object_get_int_member(data, "id"); JsonNode *con_type_node = json_object_get_member(data, "type"); /* XXX: In the development version, the "type" property is a string of the * type, but in the current stable version (4.7.2) it is an integer as * defined in i3's data header. When the next version comes out, the case * where type is a number should be removed. */ if (json_node_get_value_type(con_type_node) == G_TYPE_STRING) { con->priv->type = g_strdup(json_node_get_string(con_type_node)); } else { int con_type_int = (int)json_node_get_int(con_type_node); switch (con_type_int) { case 0: con->priv->type = g_strdup("root"); break; case 1: con->priv->type = g_strdup("output"); break; case 2: case 3: con->priv->type = g_strdup("con"); break; case 4: con->priv->type = g_strdup("workspace"); break; case 5: con->priv->type = g_strdup("dockarea"); break; } } if (parent) { g_object_ref(parent); con->priv->parent = parent; } JsonObject *rect_data = json_object_get_object_member(data, "rect"); con->priv->rect->x = json_object_get_int_member(rect_data, "x"); con->priv->rect->y = json_object_get_int_member(rect_data, "y"); con->priv->rect->width = json_object_get_int_member(rect_data, "width"); con->priv->rect->height = json_object_get_int_member(rect_data, "height"); if (json_object_has_member(data, "deco_rect")) { JsonObject *deco_rect_data = json_object_get_object_member(data, "deco_rect"); con->priv->deco_rect->x = json_object_get_int_member(deco_rect_data, "x"); con->priv->deco_rect->y = json_object_get_int_member(deco_rect_data, "y"); con->priv->deco_rect->width = json_object_get_int_member(deco_rect_data, "width"); con->priv->deco_rect->height = json_object_get_int_member(deco_rect_data, "height"); } JsonArray *nodes_array = json_object_get_array_member(data, "nodes"); json_array_foreach_element(nodes_array, i3ipc_con_initialize_nodes, con); JsonArray *floating_nodes_array = json_object_get_array_member(data, "floating_nodes"); json_array_foreach_element(floating_nodes_array, i3ipc_con_initialize_floating_nodes, con); JsonArray *focus_array = json_object_get_array_member(data, "focus"); guint len = json_array_get_length(focus_array); for (int i = 0; i < len; i += 1) { con->priv->focus = g_list_append(con->priv->focus, GINT_TO_POINTER(json_array_get_int_element(focus_array, i))); } return con; }
/* Params utils */ static gboolean melo_jsonrpc_add_node (JsonNode *node, JsonObject *schema, JsonObject *obj, JsonArray *array) { GType vtype = G_TYPE_INVALID; const gchar *s_name; const gchar *s_type; JsonNodeType type; /* Get name and type from schema */ s_name = json_object_get_string_member (schema, "name"); s_type = json_object_get_string_member (schema, "type"); if (!s_name || !s_type) return FALSE; /* Get type */ type = json_node_get_node_type (node); if (type == JSON_NODE_VALUE) vtype = json_node_get_value_type (node); /* Check type: * We check only first letter of the type string. */ switch (s_type[0]) { case 'b': /* Boolean: check type */ if (vtype != G_TYPE_BOOLEAN) return FALSE; /* Add to object / array */ if (obj || array) { gboolean v; v = json_node_get_boolean (node); if (obj) json_object_set_boolean_member (obj, s_name, v); else json_array_add_boolean_element (array, v); break; } break; case 'i': /* Integer: check type */ if (vtype != G_TYPE_INT64) return FALSE; /* Add to object / array */ if (obj || array) { gint64 v; v = json_node_get_int (node); if (obj) json_object_set_int_member (obj, s_name, v); else json_array_add_int_element (array, v); } break; case 'd': /* Double: check type */ if (vtype != G_TYPE_DOUBLE) return FALSE; /* Add to object / array */ if (obj || array) { gdouble v; v = json_node_get_double (node); if (obj) json_object_set_double_member (obj, s_name, v); else json_array_add_double_element (array, v); } break; case 's': /* String: check type */ if (vtype != G_TYPE_STRING) return FALSE; /* Add to object / array */ if (obj || array) { const gchar *v; v = json_node_get_string (node); if (obj) json_object_set_string_member (obj, s_name, v); else json_array_add_string_element (array, v); } break; case 'o': /* Object: check type */ if (type != JSON_NODE_OBJECT) return FALSE; /* Add to object / array */ if (obj || array) { JsonObject *v; v = json_node_dup_object (node); if (obj) json_object_set_object_member (obj, s_name, v); else json_array_add_object_element (array, v); } break; case 'a': /* Array: check type */ if (type != JSON_NODE_ARRAY) return FALSE; /* Add to object / array */ if (obj || array) { JsonArray *v; v = json_node_dup_array (node); if (obj) json_object_set_array_member (obj, s_name, v); else json_array_add_array_element (array, v); } break; default: return FALSE; } return TRUE; }
static int real_json_get (JsonParser *parser, const char *pathstr, int *n_objects, PRN *prn) { GError *gerr = NULL; JsonNode *match, *node; JsonPath *path; GType ntype; int err = 0; *n_objects = 0; node = json_parser_get_root(parser); if (node == NULL || json_node_is_null(node)) { gretl_errmsg_set("jsonget: got null root node"); return E_DATA; } path = json_path_new(); if (!json_path_compile(path, pathstr, &gerr)) { if (gerr != NULL) { gretl_errmsg_sprintf("jsonget: failed to compile JsonPath: %s", gerr->message); g_error_free(gerr); } else { gretl_errmsg_set("jsonget: failed to compile JsonPath"); } g_object_unref(path); return E_DATA; } match = json_path_match(path, node); if (null_node(match)) { /* FIXME : maybe return empty string? */ g_object_unref(path); return E_DATA; } /* in case we get floating-point output */ gretl_push_c_numeric_locale(); if (JSON_NODE_HOLDS_ARRAY(match)) { JsonArray *array = json_node_get_array(match); int len = 0, index = 0; if (non_empty_array(array)) { len = json_array_get_length(array); node = json_array_get_element(array, index); } else { node = NULL; } repeat: if (null_node(node)) { gretl_errmsg_set("jsonget: failed to match JsonPath"); ntype = 0; err = E_DATA; goto bailout; } else { ntype = json_node_get_value_type(node); } if (node != NULL && !handled_type(ntype)) { if (JSON_NODE_HOLDS_ARRAY(node)) { /* recurse on array type */ array = json_node_get_array(node); if (non_empty_array(array)) { node = json_array_get_element(array, 0); goto repeat; } } else if (json_node_get_node_type(node) == JSON_NODE_OBJECT) { err = excavate_json_object(node, n_objects, prn); if (!err) { if (index < len - 1) { node = json_array_get_element(array, ++index); goto repeat; } } } else { gretl_errmsg_sprintf("jsonget: unhandled array type '%s'", g_type_name(ntype)); err = E_DATA; } } else if (array != NULL) { int i, n = json_array_get_length(array); for (i=0; i<n && !err; i++) { node = json_array_get_element(array, i); err = output_json_node_value(node, prn); if (!err) { *n_objects += 1; if (n > 1) { pputc(prn, '\n'); } } } } } else { /* not an array-holding node */ err = output_json_node_value(match, prn); if (!err) { *n_objects += 1; } } bailout: gretl_pop_c_numeric_locale(); json_node_free(match); g_object_unref(path); return err; }