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