JsonNode*
cometd_new_handshake_message(const cometd* h)
{
gint64 seed = ++(h->conn->msg_id_seed);
JsonNode* root = json_node_new(JSON_NODE_OBJECT);
JsonObject* obj = json_object_new();
json_object_set_int_member (obj, COMETD_MSG_ID_FIELD, seed);
json_object_set_string_member(obj, COMETD_MSG_CHANNEL_FIELD, COMETD_CHANNEL_META_HANDSHAKE);
json_object_set_string_member(obj, COMETD_MSG_VERSION_FIELD, COMETD_VERSION);
json_object_set_string_member(obj, COMETD_MSG_MIN_VERSION_FIELD, COMETD_MIN_VERSION);
// construct advice - TODO: these values should not be hardcoded
JsonObject* advice = json_object_new();
json_object_set_int_member(advice, "timeout", 60000);
json_object_set_int_member(advice, "interval", 0);
json_object_set_object_member(obj, COMETD_MSG_ADVICE_FIELD, advice);
// construct supported transports
JsonArray* json_transports = json_array_new();
GList* entry = h->config->transports;
while (entry){
cometd_transport* t = entry->data;
json_array_add_string_element(json_transports, t->name);
entry = g_list_next(entry);
}
json_object_set_array_member(obj, "supportedConnectionTypes", json_transports);
// call extensions with message - TODO: implement extensions first
json_node_take_object(root, obj);
return root;
}
JsonNode* cometd_ping_ls(cometd* h, char *target)
{
JsonObject *adviceObject = json_object_new();
JsonNode *adviceNode = json_node_new(JSON_NODE_OBJECT);
JsonNode *adviceRoot = json_node_init_object(adviceNode, adviceObject);
adviceObject = json_node_get_object(adviceRoot);
json_object_set_string_member(adviceObject, "folder", "/");
JsonNode* root = json_node_new(JSON_NODE_OBJECT);
JsonObject* obj = json_object_new();
gint64 seed = ++(h->conn->msg_id_seed);
char* connection_type = cometd_current_transport(h)->name;
json_object_set_int_member (obj, COMETD_MSG_ID_FIELD, seed);
json_object_set_string_member(obj, COMETD_MSG_CHANNEL_FIELD, target);
json_object_set_string_member(obj, "connectionType", connection_type);
json_object_set_member(obj, "data", adviceRoot);
json_object_set_string_member(obj, "clientId", cometd_conn_client_id(h->conn));
json_node_take_object(root, obj);
return(root);
}
/**
* json_builder_add_int_value:
* @builder: a #JsonBuilder
* @value: the value of the member or element
*
* If called after json_builder_set_member_name(), sets @value as member of the
* most recent opened object, otherwise @value is added as element of the most
* recent opened array.
*
* See also: json_builder_add_value()
*
* Return value: (transfer none): the #JsonBuilder, or %NULL if the call was inconsistent
*/
JsonBuilder *
json_builder_add_int_value (JsonBuilder *builder,
gint64 value)
{
JsonBuilderState *state;
g_return_val_if_fail (JSON_IS_BUILDER (builder), NULL);
g_return_val_if_fail (!g_queue_is_empty (builder->priv->stack), NULL);
g_return_val_if_fail (json_builder_is_valid_add_mode (builder), NULL);
state = g_queue_peek_head (builder->priv->stack);
switch (state->mode)
{
case JSON_BUILDER_MODE_MEMBER:
json_object_set_int_member (state->data.object, state->member_name, value);
g_free (state->member_name);
state->member_name = NULL;
state->mode = JSON_BUILDER_MODE_OBJECT;
break;
case JSON_BUILDER_MODE_ARRAY:
json_array_add_int_element (state->data.array, value);
break;
default:
g_assert_not_reached ();
}
return builder;
}
JsonNode*
cometd_new_publish_message(const cometd* h,
const char* channel,
JsonNode* data)
{
gint64 seed = ++(h->conn->msg_id_seed);
JsonNode* root = json_node_new(JSON_NODE_OBJECT);
JsonObject* obj = json_object_new();
json_object_set_int_member(obj, COMETD_MSG_ID_FIELD, seed);
json_object_set_string_member(obj,
COMETD_MSG_CHANNEL_FIELD,
channel);
json_object_set_string_member(obj,
COMETD_MSG_CLIENT_ID_FIELD,
cometd_conn_client_id(h->conn));
json_object_set_member(obj,
COMETD_MSG_DATA_FIELD,
json_node_copy(data));
json_node_take_object(root, obj);
return root;
}
static JsonNode *
melo_jsonrpc_build_error_nodev (MeloJSONRPCError error_code,
const char *error_format, va_list args)
{
gchar *error_message;
JsonObject *obj;
JsonNode *node;
/* Create a new JSON builder */
obj = json_object_new ();
if (!obj)
return NULL;
/* Generate error message */
error_message = g_strdup_vprintf (error_format, args);
/* Begin a new object */
json_object_set_int_member (obj, "code", error_code);
json_object_set_string_member (obj, "message", error_message);
/* Free message */
g_free (error_message);
/* Create node */
node = json_node_new (JSON_NODE_OBJECT);
json_node_take_object (node, obj);
return node;
}
JsonNode*
cometd_new_unsubscribe_message(const cometd* h, const char* channel)
{
gint64 seed = ++(h->conn->msg_id_seed);
JsonNode* root = json_node_new(JSON_NODE_OBJECT);
JsonObject* obj = json_object_new();
json_object_set_int_member(obj, COMETD_MSG_ID_FIELD, seed);
json_object_set_string_member(obj,
COMETD_MSG_CHANNEL_FIELD,
COMETD_CHANNEL_META_UNSUBSCRIBE);
json_object_set_string_member(obj,
COMETD_MSG_CLIENT_ID_FIELD,
cometd_conn_client_id(h->conn));
json_object_set_string_member(obj,
COMETD_MSG_SUBSCRIPTION_FIELD,
channel);
json_node_take_object(root, obj);
return root;
}
void
cometd_msg_set_advice(JsonNode* msg, const cometd_advice* advice)
{
g_return_if_fail(JSON_NODE_HOLDS_OBJECT (msg));
if (!advice) return;
JsonObject* advice_obj = json_object_new();
char* reconnect = NULL;
switch (advice->reconnect)
{
case COMETD_RECONNECT_NONE:
reconnect = "none";
break;
case COMETD_RECONNECT_RETRY:
reconnect = "retry";
break;
case COMETD_RECONNECT_HANDSHAKE:
reconnect = "handshake";
break;
}
json_object_set_string_member(advice_obj, "reconnect", reconnect);
json_object_set_int_member(advice_obj, "interval", advice->interval);
JsonObject* obj = json_node_get_object(msg);
json_object_set_object_member(obj, COMETD_MSG_ADVICE_FIELD, advice_obj);
}
static void
send_init_command (CockpitTransport *transport)
{
const gchar *checksum;
const gchar *name;
JsonObject *object;
GBytes *bytes;
object = json_object_new ();
json_object_set_string_member (object, "command", "init");
json_object_set_int_member (object, "version", 1);
checksum = cockpit_packages_get_checksum (packages);
if (checksum)
json_object_set_string_member (object, "checksum", checksum);
/* Happens when we're in --interact mode */
name = cockpit_dbus_internal_name ();
if (name)
json_object_set_string_member (object, "bridge-dbus-name", name);
bytes = cockpit_json_write_bytes (object);
json_object_unref (object);
cockpit_transport_send (transport, NULL, bytes);
g_bytes_unref (bytes);
}
END_TEST
static void add_foo(const cometd* h, JsonNode* n)
{
JsonObject* obj = json_node_get_object(n);
json_object_set_int_member(obj, "foo", 1);
}
void
couchdb_document_contact_set_phone_numbers (CouchdbDocumentContact *document, GSList *list)
{
GSList *l;
JsonObject *phone_numbers;
g_return_if_fail (COUCHDB_IS_DOCUMENT_CONTACT (document));
phone_numbers = json_object_new ();
for (l = list; l != NULL; l = l->next) {
const gchar *number_str;
CouchdbStructField *sf = (CouchdbStructField *) l->data;
number_str = couchdb_document_contact_phone_get_number (sf);
if (number_str) {
JsonObject *this_phone;
this_phone = json_object_new ();
json_object_set_string_member (this_phone, "number", number_str);
json_object_set_string_member (this_phone, "description",
couchdb_document_contact_phone_get_description (sf));
json_object_set_int_member (this_phone, "priority",
couchdb_document_contact_phone_get_priority (sf));
json_object_set_object_member (phone_numbers,
couchdb_struct_field_get_uuid (sf),
this_phone);
}
}
json_object_set_object_member (couchdb_document_get_json_object (COUCHDB_DOCUMENT (document)),
"phone_numbers", phone_numbers);
}
void
trg_json_widget_spin_int_save(GtkWidget * widget, JsonObject * obj,
gchar * key)
{
json_object_set_int_member(obj, key,
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON
(widget)));
}
/**
* couchdb_struct_field_set_int_field:
* @sf: A #CouchdbStructField object
* @field: Name of the field
* @calue: Value to set the field to
*
* Set the value of an integer field in the given struct field.
*/
void
couchdb_struct_field_set_int_field (CouchdbStructField *sf, const char *field, gint value)
{
g_return_if_fail (sf != NULL);
g_return_if_fail (field != NULL);
json_object_set_int_member (sf->json_object, field, value);
}
static void
cockpit_channel_actual_send (CockpitChannel *self,
GBytes *payload,
gboolean trust_is_utf8)
{
GBytes *validated = NULL;
guint64 out_sequence;
JsonObject *ping;
gsize size;
g_return_if_fail (self->priv->out_buffer == NULL);
g_return_if_fail (self->priv->buffer_timeout == 0);
if (!trust_is_utf8)
{
if (!self->priv->binary_ok)
payload = validated = cockpit_unicode_force_utf8 (payload);
}
cockpit_transport_send (self->priv->transport, self->priv->id, payload);
/* A wraparound of our gint64 size? */
if (self->priv->flow_control)
{
size = g_bytes_get_size (payload);
g_return_if_fail (G_MAXINT64 - size > self->priv->out_sequence);
/* How many bytes have been sent (queued) */
out_sequence = self->priv->out_sequence + size;
/* Every CHANNEL_FLOW_PING bytes we send a ping */
if (out_sequence / CHANNEL_FLOW_PING != self->priv->out_sequence / CHANNEL_FLOW_PING)
{
ping = json_object_new ();
json_object_set_int_member (ping, "sequence", out_sequence);
cockpit_channel_control (self, "ping", ping);
g_debug ("%s: sending ping with sequence: %" G_GINT64_FORMAT, self->priv->id, out_sequence);
json_object_unref (ping);
}
/* If we've sent more than the window, apply back pressure */
self->priv->out_sequence = out_sequence;
if (self->priv->out_sequence > self->priv->out_window)
{
g_debug ("%s: sent too much data without acknowledgement, emitting back pressure until %"
G_GINT64_FORMAT, self->priv->id, self->priv->out_window);
cockpit_flow_emit_pressure (COCKPIT_FLOW (self), TRUE);
}
}
if (validated)
g_bytes_unref (validated);
}
/**
* cockpit_channel_close_int_option:
* @self: a channel
* @name: the option name
* @value: the value to add
*
* Add a value to the close message for this channel. This must
* be called before the cockpit_channel_close base class
* implementation.
*/
void
cockpit_channel_close_int_option (CockpitChannel *self,
const gchar *name,
gint64 value)
{
g_return_if_fail (COCKPIT_IS_CHANNEL (self));
g_return_if_fail (name != NULL);
if (!self->priv->close_options)
self->priv->close_options = json_object_new ();
json_object_set_int_member (self->priv->close_options, name, value);
}
/* Export play list to a json object */
JsonArray *plist_export_to_json( plist_t *pl )
{
JsonArray *js_plist = json_array_new();
for ( int i = 0; i < pl->m_len; i ++ )
{
song_t *s = pl->m_list[i];
JsonObject *js_song = json_object_new();
json_object_set_string_member(js_song, "name", song_get_name(s));
json_object_set_int_member(js_song, "length", s->m_full_len);
json_object_set_int_member(js_song, "start_time", s->m_start_time);
json_object_set_int_member(js_song, "end_time", s->m_end_time);
if (s->m_default_title)
json_object_set_string_member(js_song, "title", s->m_default_title);
if (s->m_info && (s->m_info->m_flags & SI_INITIALIZED))
{
song_info_t *si = s->m_info;
JsonObject *js_si = json_object_new();
json_object_set_string_member(js_si, "artist", si->m_artist);
json_object_set_string_member(js_si, "name", si->m_name);
json_object_set_string_member(js_si, "album", si->m_album);
json_object_set_string_member(js_si, "year", si->m_year);
json_object_set_string_member(js_si, "comments", si->m_comments);
json_object_set_string_member(js_si, "track", si->m_track);
if (si->m_own_data)
json_object_set_string_member(js_si, "own_data", si->m_own_data);
json_object_set_object_member(js_song, "song_info", js_si);
if (s->m_flags & SONG_STATIC_INFO)
json_object_set_int_member(js_song, "static_info", 1);
}
json_array_add_object_element(js_plist, js_song);
}
return js_plist;
}
static void
send_init_command (CockpitTransport *transport)
{
JsonObject *object;
GBytes *bytes;
object = json_object_new ();
json_object_set_string_member (object, "command", "init");
json_object_set_int_member (object, "version", 1);
bytes = cockpit_json_write_bytes (object);
cockpit_transport_send (transport, NULL, bytes);
g_bytes_unref (bytes);
}
JsonNode*
cometd_msg_connect_new(const cometd* h) {
JsonNode* root = json_node_new(JSON_NODE_OBJECT);
JsonObject* obj = json_object_new();
gint64 seed = ++(h->conn->msg_id_seed);
char* connection_type = cometd_current_transport(h)->name;
json_object_set_int_member (obj, COMETD_MSG_ID_FIELD, seed);
json_object_set_string_member(obj, COMETD_MSG_CHANNEL_FIELD, COMETD_CHANNEL_META_CONNECT);
json_object_set_string_member(obj, "connectionType", connection_type);
json_object_set_string_member(obj, "clientId", cometd_conn_client_id(h->conn));
json_node_take_object(root, obj);
return root;
}
void trg_prefs_empty_init(TrgPrefs * p)
{
TrgPrefsPrivate *priv = p->priv;
JsonArray *profiles = json_array_new();
priv->user = json_node_new(JSON_NODE_OBJECT);
priv->userObj = json_object_new();
json_node_take_object(priv->user, priv->userObj);
priv->profile = trg_prefs_new_profile_object();
json_array_add_object_element(profiles, priv->profile);
json_object_set_array_member(priv->userObj, TRG_PREFS_KEY_PROFILES,
profiles);
json_object_set_int_member(priv->userObj, TRG_PREFS_KEY_PROFILE_ID, 0);
}
static void
on_web_socket_open (WebSocketConnection *connection,
CockpitWebService *self)
{
CockpitSocket *socket;
JsonArray *capabilities;
GBytes *command;
JsonObject *object;
JsonObject *info;
g_info ("New connection to session from %s", cockpit_creds_get_rhost (self->creds));
socket = cockpit_socket_lookup_by_connection (&self->sockets, connection);
g_return_if_fail (socket != NULL);
object = json_object_new ();
json_object_set_string_member (object, "command", "init");
json_object_set_int_member (object, "version", 1);
json_object_set_string_member (object, "channel-seed", socket->id);
json_object_set_string_member (object, "host", "localhost");
json_object_set_string_member (object, "csrf-token", cockpit_creds_get_csrf_token (self->creds));
capabilities = json_array_new ();
json_array_add_string_element (capabilities, "multi");
json_array_add_string_element (capabilities, "credentials");
json_array_add_string_element (capabilities, "binary");
json_object_set_array_member (object, "capabilities", capabilities);
info = json_object_new ();
json_object_set_string_member (info, "version", PACKAGE_VERSION);
json_object_set_string_member (info, "build", COCKPIT_BUILD_INFO);
json_object_set_object_member (object, "system", info);
command = cockpit_json_write_bytes (object);
json_object_unref (object);
web_socket_connection_send (connection, WEB_SOCKET_DATA_TEXT, self->control_prefix, command);
g_bytes_unref (command);
/* Do we have an authorize password? if so tell the frontend */
if (cockpit_creds_get_password (self->creds))
send_socket_hints (self, "credential", "password");
g_signal_connect (connection, "message",
G_CALLBACK (on_web_socket_message), self);
}
PurpleCmdRet flist_timeout_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
gchar **split; guint count;
const gchar *character, *time, *reason;
gulong time_parsed; gchar *endptr;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & (FLIST_FLAG_ADMIN | FLIST_FLAG_GLOBAL_OP))) {
*error = g_strdup(_("You must be a global operator to timeban."));
return PURPLE_CMD_STATUS_FAILED;
}
split = g_strsplit(args[0], ",", 3);
count = g_strv_length(split);
if(count < 3) {
g_strfreev(split);
*error = g_strdup(_("You must enter a character, a time, and a reason."));
return PURPLE_CMD_STATUS_WRONG_ARGS;
}
character = split[0];
time = g_strchug(split[1]);
reason = g_strchug(split[2]);
time_parsed = strtoul(time, &endptr, 10);
if(time_parsed == 0 || endptr != time + strlen(time)) {
g_strfreev(split);
*error = g_strdup(_("You must enter a valid length of time."));
return PURPLE_CMD_STATUS_WRONG_ARGS;
}
json = json_object_new();
json_object_set_string_member(json, "character", character);
json_object_set_string_member(json, "reason", reason);
json_object_set_int_member(json, "time", time_parsed);
flist_request(pc, FLIST_GLOBAL_TIMEOUT, json);
json_object_unref(json);
g_strfreev(split);
return PURPLE_CMD_STATUS_OK;
}
static const gchar *
process_transport_init (CockpitWebService *self,
CockpitTransport *transport,
JsonObject *options)
{
JsonObject *object;
GBytes *payload;
gint64 version;
if (!cockpit_json_get_int (options, "version", -1, &version))
{
g_warning ("invalid version field in init message");
return "protocol-error";
}
if (version == 1)
{
g_debug ("received init message");
self->init_received = TRUE;
g_object_set_data_full (G_OBJECT (transport), "init",
json_object_ref (options),
(GDestroyNotify) json_object_unref);
/* Always send an init message down the new transport */
object = cockpit_transport_build_json ("command", "init", NULL);
json_object_set_int_member (object, "version", 1);
json_object_set_string_member (object, "host", "localhost");
payload = cockpit_json_write_bytes (object);
json_object_unref (object);
cockpit_transport_send (transport, NULL, payload);
g_bytes_unref (payload);
}
else
{
g_message ("unsupported version of cockpit protocol: %" G_GINT64_FORMAT, version);
return "not-supported";
}
g_signal_emit (self, sig_transport_init, 0);
return NULL;
}
static void
send_init_command (CockpitTransport *transport)
{
const gchar *checksum;
JsonObject *object;
GBytes *bytes;
object = json_object_new ();
json_object_set_string_member (object, "command", "init");
json_object_set_int_member (object, "version", 1);
checksum = cockpit_packages_get_checksum (packages);
if (checksum)
json_object_set_string_member (object, "checksum", checksum);
bytes = cockpit_json_write_bytes (object);
json_object_unref (object);
cockpit_transport_send (transport, NULL, bytes);
g_bytes_unref (bytes);
}
static void
postal_http_reply_error (PostalHttp *http,
SoupMessage *message,
const GError *error)
{
JsonGenerator *g;
JsonObject *obj;
JsonNode *node;
gchar *json_buf;
gsize length;
g_assert(SOUP_IS_MESSAGE(message));
g_assert(error);
obj = json_object_new();
json_object_set_string_member(obj, "message", error->message);
json_object_set_string_member(obj, "domain", g_quark_to_string(error->domain));
json_object_set_int_member(obj, "code", error->code);
node = json_node_new(JSON_NODE_OBJECT);
json_node_set_object(node, obj);
json_object_unref(obj);
g = json_generator_new();
json_generator_set_indent(g, 2);
json_generator_set_pretty(g, TRUE);
json_generator_set_root(g, node);
json_node_free(node);
json_buf = json_generator_to_data(g, &length);
g_object_unref(g);
soup_message_set_response(message,
"application/json",
SOUP_MEMORY_TAKE,
json_buf,
length);
soup_message_set_status(message, get_status_code(error));
soup_server_unpause_message(http->priv->server, message);
}
gchar *
error_to_json (int code, const char *msg, gsize *len)
{
JsonObject *object = json_object_new ();
JsonNode *root = json_node_new (JSON_NODE_OBJECT);
JsonGenerator *generator = json_generator_new ();
gchar *data;
json_object_set_int_member (object, "err_code", code);
json_object_set_string_or_null_member (object, "err_msg", msg);
json_node_take_object (root, object);
json_generator_set_root (generator, root);
g_object_set (generator, "pretty", FALSE, NULL);
data = json_generator_to_data (generator, len);
json_node_free (root);
g_object_unref (generator);
return data;
}
static void
cockpit_channel_real_close (CockpitChannel *self,
const gchar *problem)
{
const gchar *reason = problem;
JsonObject *object;
GBytes *message;
if (self->priv->closed)
return;
self->priv->closed = TRUE;
if (reason == NULL)
reason = "";
if (self->priv->close_options)
{
object = self->priv->close_options;
self->priv->close_options = NULL;
}
else
{
object = json_object_new ();
}
json_object_set_string_member (object, "command", "close");
json_object_set_int_member (object, "channel", self->priv->number);
json_object_set_string_member (object, "reason", reason);
message = cockpit_json_write_bytes (object);
json_object_unref (object);
cockpit_transport_send (self->priv->transport, 0, message);
g_bytes_unref (message);
g_signal_emit (self, cockpit_channel_sig_closed, 0, problem);
}
gchar *
searpc_marshal_set_ret_common (JsonObject *object, gsize *len, GError *error)
{
JsonNode *root = json_node_new (JSON_NODE_OBJECT);
JsonGenerator *generator = json_generator_new ();
gchar *data;
if (error) {
json_object_set_int_member (object, "err_code", error->code);
json_object_set_string_or_null_member (object, "err_msg", error->message);
g_error_free (error);
}
json_node_take_object (root, object);
json_generator_set_root (generator, root);
g_object_set (generator, "pretty", FALSE, NULL);
data = json_generator_to_data (generator, len);
json_node_free (root);
g_object_unref (generator);
return data;
}
static void
send_init_command (CockpitTransport *transport,
gboolean interactive)
{
const gchar *checksum;
JsonObject *object;
GBytes *bytes;
object = json_object_new ();
json_object_set_string_member (object, "command", "init");
json_object_set_int_member (object, "version", 1);
/*
* When in interactive mode pretend we received an init
* message, and don't print one out.
*/
if (interactive)
{
json_object_set_string_member (object, "host", "localhost");
}
else
{
checksum = cockpit_packages_get_checksum (packages);
if (checksum)
json_object_set_string_member (object, "checksum", checksum);
}
bytes = cockpit_json_write_bytes (object);
json_object_unref (object);
if (interactive)
cockpit_transport_emit_recv (transport, NULL, bytes);
else
cockpit_transport_send (transport, NULL, bytes);
g_bytes_unref (bytes);
}
JsonNode*
cometd_new_handshake_message(const cometd* h)
{
gint64 seed = ++(h->conn->msg_id_seed);
/////////////////Data Concatenation/////////////
JsonObject* dataObject = json_object_new();
JsonNode* dataNode = json_node_new(JSON_NODE_OBJECT);
JsonNode* dataRoot = json_node_init_object(dataNode, dataObject);
dataObject = json_node_get_object(dataRoot);
json_object_set_string_member(dataObject, "login", "test2");
json_object_set_string_member(dataObject, "password", "password");
////////////////Data Concatenation////////////
/////////////////Auth/////////////////
// I begin from the most inner JsonObject of my Json File
//here i initialize my Root JsonNode with an object in it and a JsonObject to be able to get the object from the JsonNode
JsonObject* authObject = json_object_new();
JsonNode* authNode = json_node_new(JSON_NODE_OBJECT);
JsonNode* authRoot = json_node_init_object(authNode, authObject);
// Here i retrieve the initialized JsonObject that is inside my JsonNode
authObject = json_node_get_object(authRoot);
// And here some few insertion of strings in the object
json_object_set_string_member(authObject, "action", "authenticate");
json_object_set_string_member(authObject, "type", "GmY-HuzW.KZyH.simple");
json_object_set_string_member(authObject, "resource", "zetapushTuto");
json_object_set_member(authObject, "data", dataRoot);
///////////////Auth/////////////////
//////////////First Concatenation : Authentication///////////////
//Here i make the authentication of my first JsonObject with a upper membrane.
JsonObject *extMembrane = json_object_new();
JsonNode *contactMembrane = json_node_new(JSON_NODE_OBJECT);
JsonNode *secondRootMembrane = json_node_init_object(contactMembrane, extMembrane);
extMembrane = json_node_get_object(secondRootMembrane);
json_object_set_member(extMembrane, "authentication", authRoot);
/////////////First Concatenation////////////////
////////////Second Concatenation : Ext///////////////
// Here i finnaly concatenante my last JsonObject and encapsulate the overall file inside the root JsonNode
JsonObject *rootObjectMembrane = json_object_new();
JsonNode *initRootMembrane = json_node_new(JSON_NODE_OBJECT);
JsonNode *rootMembrane = json_node_init_object(initRootMembrane, rootObjectMembrane);
rootObjectMembrane = json_node_get_object(rootMembrane);
json_object_set_member(rootObjectMembrane, "ext", secondRootMembrane);
// I still needs to create a object under Ext JsonNode, then an JsonArray to supportedConnectionTypes
//Then add the advice object with "timeout" and "interval"
json_object_set_int_member(rootObjectMembrane, "id", seed);
json_object_set_string_member(rootObjectMembrane, "version", "1.0");
json_object_set_string_member(rootObjectMembrane, "minimumVersion", "1.0");
json_object_set_string_member(rootObjectMembrane, "channel", "/meta/handshake");
JsonArray* json_transports = json_array_new();
GList* entry = h->config->transports;
while (entry){
cometd_transport* t = entry->data;
json_array_add_string_element(json_transports, t->name);
entry = g_list_next(entry);
}
//json_array_add_string_element(json_transports, "long-polling");
json_object_set_array_member(rootObjectMembrane, "supportedConnectionTypes", json_transports);
//////////Advice////////
JsonObject *adviceMembrane = json_object_new();
JsonNode *adviceNodeMembrane = json_node_new(JSON_NODE_OBJECT);
JsonNode *adviceRootMembrane = json_node_init_object(adviceNodeMembrane, adviceMembrane);
gint64 interval = 0;
gint64 timeout = 60000;
adviceMembrane = json_node_get_object(adviceRootMembrane);
json_object_set_int_member(adviceMembrane, "timeout", timeout);
json_object_set_int_member(adviceMembrane, "interval", interval);
json_object_set_member(rootObjectMembrane, "advice", adviceRootMembrane);
/////////Advice////////
////////////Second Concatenation//////////////
// call extensions with message - TODO: implement extensions first
//json_node_take_object(root, obj);
return rootMembrane;
}
/**
* push_gcm_client_deliver_async:
* @client: (in): A #PushGcmClient.
* @identities: (element-type PushGcmIdentity*): A #GList of #PushGcmIdentity.
* @message: A #PushGcmMessage.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback.
* @user_data: User data for @callback.
*
* Asynchronously deliver a #PushGcmMessage to one or more GCM enabled
* devices.
*/
void
push_gcm_client_deliver_async (PushGcmClient *client,
GList *identities,
PushGcmMessage *message,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
PushGcmClientPrivate *priv;
GSimpleAsyncResult *simple;
SoupMessage *request;
const gchar *registration_id;
const gchar *collapse_key;
JsonGenerator *g;
JsonObject *obj;
JsonObject *data;
JsonObject *mdata;
JsonArray *ar;
JsonNode *node;
GList *iter;
GList *list;
gchar *str;
gsize length;
guint time_to_live;
ENTRY;
g_return_if_fail(PUSH_IS_GCM_CLIENT(client));
g_return_if_fail(identities);
g_return_if_fail(PUSH_IS_GCM_MESSAGE(message));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
g_return_if_fail(callback);
priv = client->priv;
request = soup_message_new("POST", PUSH_GCM_CLIENT_URL);
ar = json_array_new();
for (iter = identities; iter; iter = iter->next) {
g_assert(PUSH_IS_GCM_IDENTITY(iter->data));
registration_id = push_gcm_identity_get_registration_id(iter->data);
json_array_add_string_element(ar, registration_id);
}
str = g_strdup_printf("key=%s", priv->auth_token);
soup_message_headers_append(request->request_headers, "Authorization", str);
g_free(str);
soup_message_headers_append(request->request_headers,
"Accept",
"application/json");
data = json_object_new();
if ((collapse_key = push_gcm_message_get_collapse_key(message))) {
json_object_set_string_member(data, "collapse_key", collapse_key);
}
json_object_set_boolean_member(data,
"delay_while_idle",
push_gcm_message_get_delay_while_idle(message));
json_object_set_boolean_member(data,
"dry_run",
push_gcm_message_get_dry_run(message));
if ((time_to_live = push_gcm_message_get_time_to_live(message))) {
json_object_set_int_member(data, "time_to_live", time_to_live);
}
if ((mdata = push_gcm_message_get_data(message))) {
json_object_set_object_member(data, "data", mdata);
}
obj = json_object_new();
json_object_set_array_member(obj, "registration_ids", ar);
json_object_set_object_member(obj, "data", data);
node = json_node_new(JSON_NODE_OBJECT);
json_node_set_object(node, obj);
json_object_unref(obj);
g = json_generator_new();
json_generator_set_pretty(g, TRUE);
json_generator_set_indent(g, 2);
json_generator_set_root(g, node);
str = json_generator_to_data(g, &length);
json_node_free(node);
g_object_unref(g);
g_print("REQUEST: \"%s\"\n", str);
soup_message_set_request(request,
"application/json",
SOUP_MEMORY_TAKE,
str,
length);
simple = g_simple_async_result_new(G_OBJECT(client), callback, user_data,
push_gcm_client_deliver_async);
/*
* Keep the list of identities around until we receive our result.
* We need them to key with the resulting array.
*/
list = g_list_copy(identities);
g_list_foreach(list, (GFunc)g_object_ref, NULL);
g_object_set_data_full(G_OBJECT(simple),
"identities",
list,
_push_gcm_identities_free);
soup_session_queue_message(SOUP_SESSION(client),
request,
push_gcm_client_deliver_cb,
simple);
EXIT;
}
static void
send_meta (CockpitInternalMetrics *self)
{
JsonArray *metrics;
JsonObject *metric;
JsonObject *root;
struct timeval now_timeval;
gint64 now;
gettimeofday (&now_timeval, NULL);
now = timestamp_from_timeval (&now_timeval);
root = json_object_new ();
json_object_set_int_member (root, "timestamp", now);
json_object_set_int_member (root, "now", now);
json_object_set_int_member (root, "interval", self->interval);
metrics = json_array_new ();
for (int i = 0; i < self->n_metrics; i++)
{
MetricInfo *info = &self->metrics[i];
metric = json_object_new ();
/* Name and derivation mode
*/
json_object_set_string_member (metric, "name", info->desc->name);
if (info->derive)
json_object_set_string_member (metric, "derive", info->derive);
/* Instances
*/
if (info->desc->instanced)
{
GHashTableIter iter;
gpointer key, value;
int index;
JsonArray *instances = json_array_new ();
g_hash_table_iter_init (&iter, info->instances);
index = 0;
while (g_hash_table_iter_next (&iter, &key, &value))
{
const gchar *name = key;
InstanceInfo *inst = value;
/* HACK: We can't use json_builder_add_string_value here since
it turns empty strings into 'null' values inside arrays.
https://bugzilla.gnome.org/show_bug.cgi?id=730803
*/
{
JsonNode *string_element = json_node_alloc ();
json_node_init_string (string_element, name);
json_array_add_element (instances, string_element);
}
inst->index = index++;
}
json_object_set_array_member (metric, "instances", instances);
}
/* Units and semantics
*/
json_object_set_string_member (metric, "units", info->desc->units);
json_object_set_string_member (metric, "semantics", info->desc->semantics);
json_array_add_object_element (metrics, metric);
}
json_object_set_array_member (root, "metrics", metrics);
cockpit_metrics_send_meta (COCKPIT_METRICS (self), root, FALSE);
json_object_unref (root);
}