gboolean
gs_plugin_auth_login (GsPlugin *plugin, GsAuth *auth,
GCancellable *cancellable, GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(SnapdAuthData) auth_data = NULL;
g_autoptr(GVariant) macaroon_variant = NULL;
g_autofree gchar *serialized_macaroon = NULL;
g_autoptr(GError) local_error = NULL;
if (auth != priv->auth)
return TRUE;
auth_data = snapd_login_sync (gs_auth_get_username (auth), gs_auth_get_password (auth), gs_auth_get_pin (auth), NULL, &local_error);
if (auth_data == NULL) {
if (g_error_matches (local_error, SNAPD_ERROR, SNAPD_ERROR_TWO_FACTOR_REQUIRED)) {
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_PIN_REQUIRED,
local_error->message);
} else if (g_error_matches (local_error, SNAPD_ERROR, SNAPD_ERROR_AUTH_DATA_INVALID) ||
g_error_matches (local_error, SNAPD_ERROR, SNAPD_ERROR_TWO_FACTOR_INVALID)) {
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_AUTH_INVALID,
local_error->message);
} else {
g_set_error_literal (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
local_error->message);
}
return FALSE;
}
macaroon_variant = g_variant_new ("(s^as)",
snapd_auth_data_get_macaroon (auth_data),
snapd_auth_data_get_discharges (auth_data));
serialized_macaroon = g_variant_print (macaroon_variant, FALSE);
gs_auth_add_metadata (auth, "macaroon", serialized_macaroon);
/* store */
if (!gs_auth_store_save (auth,
GS_AUTH_STORE_FLAG_USERNAME |
GS_AUTH_STORE_FLAG_METADATA,
cancellable, error))
return FALSE;
gs_auth_add_flags (priv->auth, GS_AUTH_FLAG_VALID);
return TRUE;
}
static gboolean on_PushOOB(neardalHandoverAgent *handoverAgent
, GDBusMethodInvocation *invocation
, GVariant *values
, gpointer user_data)
{
neardal_handover_agent_t *agent_data = user_data;
gconstpointer value;
const gchar* blobKeys[] = {"EIR", "nokia.com:bt", "WSC", NULL};
gchar *blob = NULL;
gsize blobLen = 0;
guint counter;
(void) handoverAgent; /* Avoid warning */
(void) invocation; /* Avoid warning */
NEARDAL_TRACEIN();
NEARDAL_TRACEF("%s\n", g_variant_print(values, TRUE));
if (agent_data != NULL) {
NEARDAL_TRACEF("handoverAgent pid=%d, obj path is : %s\n"
, agent_data->pid
, agent_data->objPath);
if (agent_data->cb_oob_push_agent != NULL) {
GVariant *tmpOut = NULL;
for(counter = 0; blobKeys[counter] != NULL; counter++) {
tmpOut = g_variant_lookup_value(values, blobKeys[counter],
G_VARIANT_TYPE_ARRAY);
if (tmpOut != NULL) {
value = g_variant_get_data(tmpOut);
blobLen = g_variant_get_size(tmpOut);
if (blobLen > 0) {
blob = g_try_malloc0(blobLen);
if (blob != NULL)
memcpy(blob, value
, blobLen);
}
break;
}
}
(agent_data->cb_oob_push_agent)(
(unsigned char *) blob
, blobLen
, agent_data->user_data);
if (invocation != NULL)
neardal_handover_agent_complete_push_oob(handoverAgent, invocation);
}
}
return TRUE;
}
static void on_signal (GDBusProxy *proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
gchar *parameters_str;
parameters_str = g_variant_print (parameters, TRUE);
g_printf ("*** Received Signal: %s: %s\n",
signal_name, parameters_str);
g_free (parameters_str);
}
void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
{
if (info == TargetTypeText)
gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
else if (info == TargetTypeMarkup) {
// Some Linux applications refuse to accept pasted markup unless it is
// prefixed by a content-type meta tag.
CString markup = String(gMarkupPrefix + dataObject->markup()).utf8();
gtk_selection_data_set(selectionData, markupAtom, 8,
reinterpret_cast<const guchar*>(markup.data()), markup.length());
} else if (info == TargetTypeURIList) {
CString uriList = dataObject->uriList().utf8();
gtk_selection_data_set(selectionData, uriListAtom, 8,
reinterpret_cast<const guchar*>(uriList.data()), uriList.length());
} else if (info == TargetTypeNetscapeURL && dataObject->hasURL()) {
String url(dataObject->url());
String result(url);
result.append("\n");
if (dataObject->hasText())
result.append(dataObject->text());
else
result.append(url);
GUniquePtr<gchar> resultData(g_strdup(result.utf8().data()));
gtk_selection_data_set(selectionData, netscapeURLAtom, 8,
reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()));
} else if (info == TargetTypeImage)
gtk_selection_data_set_pixbuf(selectionData, dataObject->image());
else if (info == TargetTypeSmartPaste)
gtk_selection_data_set_text(selectionData, "", -1);
else if (info == TargetTypeUnknown) {
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
for (auto& it : dataObject->unknownTypes()) {
GUniquePtr<gchar> dictItem(g_strdup_printf("{'%s', '%s'}", it.key.utf8().data(), it.value.utf8().data()));
g_variant_builder_add_parsed(&builder, dictItem.get());
}
GRefPtr<GVariant> variant = g_variant_builder_end(&builder);
GUniquePtr<gchar> serializedVariant(g_variant_print(variant.get(), TRUE));
gtk_selection_data_set(selectionData, unknownAtom, 1, reinterpret_cast<const guchar*>(serializedVariant.get()), strlen(serializedVariant.get()));
}
}
/**
* playerctl_player_print_metadata_prop:
* @self: a #PlayerctlPlayer
* @property: (allow-none): the property from the metadata to print
* @err: (allow-none): the location of a GError or NULL
*
* Gets the artist from the metadata of the current track, or empty string if
* no track is playing.
*
* Returns: (transfer full): The artist from the metadata of the current track
*/
gchar *playerctl_player_print_metadata_prop(PlayerctlPlayer *self, gchar *property, GError **err)
{
GVariant *prop_variant;
const gchar **prop_strv;
GString *prop;
GVariant *metadata;
GError *tmp_error = NULL;
g_return_val_if_fail(err == NULL || *err == NULL, NULL);
if (self->priv->init_error != NULL) {
g_propagate_error(err, g_error_copy(self->priv->init_error));
return NULL;
}
metadata = org_mpris_media_player2_player_get_metadata(self->priv->proxy);
if (!metadata)
return g_strdup("");
if (!property)
return g_variant_print(metadata, FALSE);
prop_variant = g_variant_lookup_value(metadata, property, NULL);
if (!prop_variant)
return g_strdup("");
prop = g_string_new("");
if (g_variant_is_of_type(prop_variant, G_VARIANT_TYPE_STRING_ARRAY)) {
gsize prop_count;
prop_strv = g_variant_get_strv(prop_variant, &prop_count);
for (int i = 0; i < prop_count; i += 1) {
g_string_append(prop, prop_strv[i]);
if (i != prop_count - 1) {
g_string_append(prop, ", ");
}
}
g_free(prop_strv);
} else if (g_variant_is_of_type(prop_variant, G_VARIANT_TYPE_STRING)) {
g_string_append(prop, g_variant_get_string(prop_variant, NULL));
} else {
prop = g_variant_print_string(prop_variant, prop, FALSE);
}
return g_string_free(prop, FALSE);
}
static void
connman_mgr_signal(GDBusProxy *proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
TRACE(TRACE_DEBUG, "CONNMAN", "Manager-signal %s from %s",
signal_name, sender_name);
TRACE(TRACE_DEBUG, "CONNMAN", "%s", g_variant_print(parameters, TRUE));
if(!strcmp(signal_name, "ServicesChanged")) {
services_changed(parameters);
}
}
QString DeviceOptions::print_gvariant(GVariant *const gvar)
{
QString s;
if (g_variant_is_of_type(gvar, G_VARIANT_TYPE("s")))
s = QString(g_variant_get_string(gvar, NULL));
else
{
gchar *const text = g_variant_print(gvar, FALSE);
s = QString(text);
g_free(text);
}
return s;
}
static void
connman_svc_signal(GDBusProxy *proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
connman_service_t *cs = user_data;
TRACE(TRACE_DEBUG, "CONNMAN", "Service-signal %s %s from %s",
cs->cs_path, signal_name, sender_name);
TRACE(TRACE_DEBUG, "CONNMAN", "%s", g_variant_print(parameters, TRUE));
if(!strcmp(signal_name, "PropertyChanged")) {
prop_set_from_tuple(parameters, prop_create(cs->cs_prop, "metadata"));
}
}
static gint
handler_get_stats(struct request_context_s *req_ctx, GError **err)
{
struct reply_context_s ctx;
memset(&ctx, 0x00, sizeof(struct reply_context_s));
ctx.req_ctx = req_ctx;
GString *gs = g_string_new ("");
void msg_append_field(gpointer u, const gchar *name, GVariant *gv) {
(void) u;
if (!gv) return;
gchar *v = g_variant_print(gv, FALSE);
g_string_append_printf (gs, "%s=%s\n", name, v);
g_free(v);
}
/**
* Callback called if a editable element changes it focus state.
* Event target may be a WebKitDOMDocument (in case of iframe) or a
* WebKitDOMDOMWindow.
*/
static void on_editable_change_focus(WebKitDOMEventTarget *target,
WebKitDOMEvent *event, WebKitWebPage *page)
{
WebKitDOMDocument *doc;
WebKitDOMDOMWindow *dom_window;
WebKitDOMElement *active;
GVariant *variant;
char *message;
if (WEBKIT_DOM_IS_DOM_WINDOW(target)) {
g_object_get(target, "document", &doc, NULL);
} else {
/* target is a doc document */
doc = WEBKIT_DOM_DOCUMENT(target);
}
dom_window = webkit_dom_document_get_default_view(doc);
if (!dom_window) {
return;
}
active = webkit_dom_document_get_active_element(doc);
/* Don't do anything if there is no active element */
if (!active) {
return;
}
if (WEBKIT_DOM_IS_HTML_IFRAME_ELEMENT(active)) {
WebKitDOMHTMLIFrameElement *iframe;
WebKitDOMDocument *subdoc;
iframe = WEBKIT_DOM_HTML_IFRAME_ELEMENT(active);
subdoc = webkit_dom_html_iframe_element_get_content_document(iframe);
add_onload_event_observers(subdoc, page);
return;
}
/* Check if the active element is an editable element. */
variant = g_variant_new("(tb)", webkit_web_page_get_id(page),
ext_dom_is_editable(active));
message = g_variant_print(variant, FALSE);
g_variant_unref(variant);
if (!webkit_dom_dom_window_webkit_message_handlers_post_message(dom_window, "focus", message)) {
g_warning("Error sending focus message");
}
g_free(message);
g_object_unref(dom_window);
}
static gboolean
set_to_keyfile (GKeyfileSettingsBackend *kfsb,
const gchar *key,
GVariant *value)
{
gchar *group, *name;
if (g_hash_table_contains (kfsb->system_locks, key))
return FALSE;
if (convert_path (kfsb, key, &group, &name))
{
if (value)
{
gchar *str = g_variant_print (value, FALSE);
g_key_file_set_value (kfsb->keyfile, group, name, str);
g_variant_unref (g_variant_ref_sink (value));
g_free (str);
}
else
{
if (*name == '\0')
{
gchar **groups;
gint i;
groups = g_key_file_get_groups (kfsb->keyfile, NULL);
for (i = 0; groups[i]; i++)
if (group_name_matches (groups[i], group))
g_key_file_remove_group (kfsb->keyfile, groups[i], NULL);
g_strfreev (groups);
}
else
g_key_file_remove_key (kfsb->keyfile, group, name, NULL);
}
g_free (group);
g_free (name);
return TRUE;
}
return FALSE;
}
static void
_handle_agent_method_call (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
GTlmNfc* self = GTLM_NFC(user_data);
gchar *parameters_str;
parameters_str = g_variant_print (parameters, TRUE);
g_debug ("Agent received method call: %s\n\tParameters: %s\n\tSender: %s\n\tObject path: %s\n\tInteface name: %s",
method_name, parameters_str, sender, object_path, interface_name);
g_free (parameters_str);
if (g_strcmp0(method_name, "GetNDEF") != 0) {
goto out;
}
GVariant* parameters_dict = g_variant_get_child_value(parameters, 0);
if (parameters_dict == NULL)
{
g_debug ("Error getting parameters dict");
g_signal_emit(self, signals[SIG_NO_RECORD_FOUND], 0);
goto out;
}
gchar* payload_data;
if (g_variant_lookup(parameters_dict, "Payload", "^ay", &payload_data) == FALSE) {
g_debug ("Error getting raw Payload data");
g_signal_emit(self, signals[SIG_NO_RECORD_FOUND], 0);
g_variant_unref(parameters_dict);
goto out;
}
g_variant_unref(parameters_dict);
_decode_username_password(self, payload_data);
g_free(payload_data);
out:
g_dbus_method_invocation_return_value (invocation, NULL);
}
static void log_key(const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg, uint32_t key, int op, GVariant *data)
{
const char *opstr;
const struct sr_key_info *srci;
/* Don't log SR_CONF_DEVICE_OPTIONS, it's verbose and not too useful. */
if (key == SR_CONF_DEVICE_OPTIONS)
return;
opstr = op == SR_CONF_GET ? "get" : op == SR_CONF_SET ? "set" : "list";
srci = sr_key_info_get(SR_KEY_CONFIG, key);
sr_spew("sr_config_%s(): key %d (%s) sdi %p cg %s -> %s", opstr, key,
srci ? srci->id : "NULL", sdi, cg ? cg->name : "NULL",
data ? g_variant_print(data, TRUE) : "NULL");
}
static void get_option(void)
{
struct sr_dev_inst *sdi;
struct sr_channel_group *cg;
const struct sr_config_info *ci;
GSList *devices;
GVariant *gvar;
GHashTable *devargs;
int ret;
char *s;
struct sr_dev_driver *driver;
if (!(devices = device_scan())) {
g_critical("No devices found.");
return;
}
sdi = devices->data;
g_slist_free(devices);
driver = sr_dev_inst_driver_get(sdi);
if (sr_dev_open(sdi) != SR_OK) {
g_critical("Failed to open device.");
return;
}
cg = select_channel_group(sdi);
if (!(ci = sr_config_info_name_get(opt_get)))
g_critical("Unknown option '%s'", opt_get);
if ((devargs = parse_generic_arg(opt_config, FALSE)))
set_dev_options(sdi, devargs);
else devargs = NULL;
if ((ret = maybe_config_get(driver, sdi, cg, ci->key, &gvar)) != SR_OK)
g_critical("Failed to get '%s': %s", opt_get, sr_strerror(ret));
s = g_variant_print(gvar, FALSE);
printf("%s\n", s);
g_free(s);
g_variant_unref(gvar);
sr_dev_close(sdi);
if (devargs)
g_hash_table_destroy(devargs);
}
static void
build_json_dictionary (JsonBuilder *builder,
const GVariantType *entry_type,
GVariant *dict)
{
const GVariantType *key_type;
GVariantIter iter;
GVariant *child;
GVariant *key;
GVariant *value;
gboolean is_string;
gchar *key_string;
json_builder_begin_object (builder);
key_type = g_variant_type_key (entry_type);
is_string = (g_variant_type_equal (key_type, G_VARIANT_TYPE_STRING) ||
g_variant_type_equal (key_type, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_type_equal (key_type, G_VARIANT_TYPE_SIGNATURE));
g_variant_iter_init (&iter, dict);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
key = g_variant_get_child_value (child, 0);
value = g_variant_get_child_value (child, 1);
if (is_string)
{
json_builder_set_member_name (builder, g_variant_get_string (key, NULL));
}
else
{
key_string = g_variant_print (key, FALSE);
json_builder_set_member_name (builder, key_string);
g_free (key_string);
}
build_json (builder, value);
g_variant_unref (key);
g_variant_unref (value);
}
json_builder_end_object (builder);
}
static char *
serialize_secret (const char *token,
const char *token_secret)
{
GVariantBuilder *builder;
GVariant *variant;
char *secret;
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
g_variant_builder_add (builder, "ms", token);
g_variant_builder_add (builder, "ms", token_secret);
variant = g_variant_builder_end (builder);
secret = g_variant_print (variant, TRUE);
g_variant_unref (variant);
return secret;
}
void
common_utils_debug_dump_hashtable(GHashTable* hasht)
{
GHashTableIter iter;
gpointer _key, _val;
g_debug("Debug Dump of HashTable");
if (!hasht) {
g_debug("--| hashtable is NULL");
return;
}
g_hash_table_iter_init(&iter, hasht);
while (g_hash_table_iter_next(&iter, &_key, &_val)) {
const char *key = (const char *)_key;
GVariant *val = _val;
g_debug("--| %s: %s", key, g_variant_print(val, TRUE));
}
}
static void
print_setting (const char *setting_name, GVariant *setting)
{
GVariantIter iter;
const char *property_name;
GVariant *value;
char *printed_value;
g_print (" %s:\n", setting_name);
g_variant_iter_init (&iter, setting);
while (g_variant_iter_next (&iter, "{&sv}", &property_name, &value)) {
printed_value = g_variant_print (value, FALSE);
if (strcmp (printed_value, "[]") != 0)
g_print (" %s: %s\n", property_name, printed_value);
g_free (printed_value);
g_variant_unref (value);
}
}
void get(SoupServer *server,
SoupMessage *msg,
const char *path)
{
struct btval key, val;
key.data = (void*)path+1;
key.size = strlen(path)-1;
key.free_data = FALSE;
key.mp = NULL;
g_debug ("GET\n Path=%s\n Fetching key %s", path, (char*)key.data);
const struct btree_stat *stat = btree_stat(btree);
show_dbstats("",stat);
if (0 == btree_get(btree,&key,&val)) {
g_debug ("data checksum is %s", g_compute_checksum_for_data(G_CHECKSUM_MD5, val.data, val.size));
/* we need to make the data 64 bits aligned for gvariant.
Best plan is to make all data aligned in the store, but
for now, lets just copy it to somewhere aligned.
TODO: think about fragmentation. it may just be ok, as so far
we delete everything we malloc in this function, despite the
lifetimes being interleaved.
*/
char *buf = g_slice_alloc(val.size + 8);
char *data = ALIGN_64(buf);
memcpy (data, val.data, val.size);
g_debug ("aligned data checksum is %s", g_compute_checksum_for_data(G_CHECKSUM_MD5, data, val.size));
GVariant *gv = g_variant_new_from_data(G_VARIANT_TYPE_VARIANT, data, val.size, TRUE, NULL, NULL);
char *debug = g_variant_print (gv, TRUE);
g_debug ("converted to %s", debug);
g_free (debug);
int length;
char* ret = json_gvariant_serialize_data(gv, &length);
g_variant_unref(gv);
g_slice_free1 (val.size + 8, buf);
soup_message_set_status (msg, SOUP_STATUS_OK);
/*TODO: does soup do anything sensible with it's memory management of responses to reduce the risk of fragmentation? probably not..*/
soup_message_set_response (msg, "application/json", SOUP_MEMORY_TAKE, ret, length);
} else {
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
}
}
void _on_property_changed (GDBusObjectManagerClient *manager,
GDBusObjectProxy *object_proxy,
GDBusProxy *interface_proxy,
GVariant *changed_properties,
GStrv invalidated_properties,
gpointer user_data)
{
gchar *parameters_str;
parameters_str = g_variant_print (changed_properties, TRUE);
g_debug("Property of object %s changed:\n%s",
g_dbus_object_get_object_path(G_DBUS_OBJECT(object_proxy)), parameters_str);
g_debug("Invalidated properties:");
while (*invalidated_properties != NULL) {
g_print(*invalidated_properties);
invalidated_properties++;
}
g_free(parameters_str);
}
static void
input_req_event(void *opaque, event_t *e)
{
connman_service_t *cs = opaque;
if(cs->cs_input_req_inv == NULL)
return;
if(event_is_action(e, ACTION_OK)) {
rstr_t *username = prop_get_string(cs->cs_input_req_prop, "username", NULL);
rstr_t *password = prop_get_string(cs->cs_input_req_prop, "password", NULL);
GVariant *result;
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "Passphrase",
g_variant_new_string(rstr_get(password)));
if(cs->cs_input_req_want_identity)
g_variant_builder_add(builder, "{sv}", "Identity",
g_variant_new_string(rstr_get(username)));
result = g_variant_new("(a{sv})", builder);
TRACE(TRACE_DEBUG, "CONNMAN", "Auth response: %s",
g_variant_print(result, TRUE));
g_dbus_method_invocation_return_value(cs->cs_input_req_inv, result);
g_variant_builder_unref(builder);
rstr_release(username);
rstr_release(password);
connman_stop_input_request(cs);
}
if(event_is_action(e, ACTION_CANCEL)) {
g_dbus_method_invocation_return_dbus_error(cs->cs_input_req_inv,
"net.connman.Agent.Error.Canceled",
"Canceled by user");
connman_stop_input_request(cs);
}
}
/*****************************************************************************
* neardal_tag_prv_read_properties: Get Neard Tag Properties
****************************************************************************/
static errorCode_t neardal_tag_prv_read_properties(TagProp *tagProp)
{
errorCode_t err = NEARDAL_SUCCESS;
GVariant *tmp = NULL;
GVariant *tmpOut = NULL;
gsize len;
NEARDAL_TRACEIN();
NEARDAL_ASSERT_RET(tagProp != NULL, NEARDAL_ERROR_INVALID_PARAMETER);
NEARDAL_ASSERT_RET(tagProp->proxy != NULL
, NEARDAL_ERROR_GENERAL_ERROR);
tmp = g_datalist_get_data(&(neardalMgr.dbus_data), tagProp->name);
if (tmp == NULL) {
err = NEARDAL_ERROR_NO_TAG;
NEARDAL_TRACE_ERR("Unable to read tag's properties\n");
goto exit;
}
NEARDAL_TRACEF("Reading:\n%s\n", g_variant_print(tmp, TRUE));
tmpOut = g_variant_lookup_value(tmp, "TagType", G_VARIANT_TYPE_ARRAY);
if (tmpOut != NULL) {
tagProp->tagType = g_variant_dup_strv(tmpOut, &len);
tagProp->tagTypeLen = len;
if (len == 0) {
g_strfreev(tagProp->tagType);
tagProp->tagType = NULL;
}
}
tmpOut = g_variant_lookup_value(tmp, "Type", G_VARIANT_TYPE_STRING);
if (tmpOut != NULL)
tagProp->type = g_variant_dup_string(tmpOut, NULL);
tmpOut = g_variant_lookup_value(tmp, "ReadOnly",
G_VARIANT_TYPE_BOOLEAN);
if (tmpOut != NULL)
tagProp->readOnly = g_variant_get_boolean(tmpOut);
exit:
return err;
}
void post(SoupServer *server,
SoupMessage *msg,
const char *path)
{
JsonParser *parser = json_parser_new ();
GError *err = NULL;
g_debug("POST\n path= %s\nbody = '%s'", path, msg->request_body->data);
if (json_parser_load_from_data (parser, msg->request_body->data, -1, &err)) {
g_debug("parsed sucessfully");
GVariant *gv = json_gvariant_deserialize(json_parser_get_root(parser), NULL, NULL);
if (gv) {
char *debug = g_variant_print (gv, TRUE);
g_debug ("converted to %s", debug);
g_free (debug);
//We need to store the signature, so package in a v
GVariant *packaged = g_variant_new_variant(gv);
struct btval key;
key.data = (void*)path+1;
key.size = strlen(path)-1;
key.free_data = FALSE;
key.mp = NULL;
struct btval val;
val.data =(void*) g_variant_get_data(packaged);
val.size = g_variant_get_size(packaged);
val.free_data = FALSE;
val.mp = NULL;
g_debug ("inserting with key %s", (char*)key.data);
g_debug ("data checksum is %s", g_compute_checksum_for_data(G_CHECKSUM_MD5, val.data, val.size));
int success = btree_put(btree, &key, &val,0);
if (0!=success) {
g_debug("put failed: %s)", strerror(errno));
}
g_variant_unref (packaged);
g_variant_unref (gv);
}
} else {
g_debug("failed to parse json: %s", err->message);
g_error_free(err);
}
soup_message_set_status (msg, SOUP_STATUS_OK);
}
static void
set_online_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
UrfDeviceOfono *modem = URF_DEVICE_OFONO (user_data);
UrfDeviceOfonoPrivate *priv = URF_DEVICE_OFONO_GET_PRIVATE (modem);
GVariant *result;
GError *error = NULL;
result = g_dbus_proxy_call_finish (priv->proxy, res, &error);
if (!error) {
g_debug ("online change successful: %s",
g_variant_print (result, TRUE));
} else {
g_warning ("Could not set Online property in oFono: %s",
error ? error->message : "(unknown error)");
}
}
static void printProperties (GDBusProxy *proxy)
{
gchar **property_names;
guint n;
debug(" properties:\n");
property_names = g_dbus_proxy_get_cached_property_names (proxy);
for (n = 0; property_names != NULL && property_names[n] != NULL; n++) {
const gchar *key = property_names[n];
GVariant *value;
gchar *value_str;
value = g_dbus_proxy_get_cached_property (proxy, key);
value_str = g_variant_print (value, TRUE);
debug(" %s -> %s\n", key, value_str);
g_variant_unref (value);
g_free (value_str);
}
g_strfreev (property_names);
}
static void
modem_signal_cb (GDBusProxy *proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
UrfDeviceOfono *modem = URF_DEVICE_OFONO (user_data);
UrfDeviceOfonoPrivate *priv = URF_DEVICE_OFONO_GET_PRIVATE (modem);
if (g_strcmp0 (signal_name, "PropertyChanged") == 0) {
gchar *prop_name;
GVariant *prop_value = NULL;
g_debug ("properties changed for %s: %s",
priv->object_path,
g_variant_print (parameters, TRUE));
g_variant_get_child (parameters, 0, "s", &prop_name);
g_variant_get_child (parameters, 1, "v", &prop_value);
if (prop_value)
g_hash_table_replace (priv->properties,
g_strdup (prop_name),
g_variant_ref (prop_value));
if (g_strcmp0 ("Powered", prop_name) == 0) {
gboolean powered = FALSE;
powered = g_variant_get_boolean (prop_value);
if (powered)
set_soft (URF_DEVICE (modem), priv->soft);
}
g_free (prop_name);
g_variant_unref (prop_value);
}
}
static void
get_properties_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
UrfDeviceOfono *modem = URF_DEVICE_OFONO (user_data);
UrfDeviceOfonoPrivate *priv = URF_DEVICE_OFONO_GET_PRIVATE (modem);
GVariant *result, *properties, *variant = NULL;
GVariantIter iter;
GError *error = NULL;
gchar *key;
result = g_dbus_proxy_call_finish (priv->proxy, res, &error);
if (!error) {
properties = g_variant_get_child_value (result, 0);
g_debug ("%zd properties for %s", g_variant_n_children (properties), priv->object_path);
g_debug ("%s", g_variant_print (properties, TRUE));
g_variant_iter_init (&iter, properties);
while (g_variant_iter_next (&iter, "{sv}", &key, &variant)) {
if (g_strcmp0 ("Powered", key) == 0 &&
g_variant_get_boolean (variant) == TRUE) {
set_soft (URF_DEVICE (modem), priv->soft);
}
g_hash_table_insert (priv->properties, g_strdup (key),
g_variant_ref (variant));
g_variant_unref (variant);
g_free (key);
}
g_variant_unref (properties);
g_variant_unref (result);
} else {
g_warning ("Error getting properties: %s",
error ? error->message : "(unknown error)");
}
}
/**
* @memberof GstSwitchController
*
* Remoting method stub of "get_preview_ports".
*/
static GVariant *
gst_switch_controller__get_preview_ports (GstSwitchController * controller,
GDBusConnection * connection, GVariant * parameters)
{
GVariant *result = NULL;
if (controller->server) {
GArray *serves = NULL, *types = NULL;
GArray *ports =
gst_switch_server_get_preview_sink_ports (controller->server, &serves,
&types);
int n;
GVariantBuilder *builder;
GVariant *value;
gchar *res;
builder = g_variant_builder_new (G_VARIANT_TYPE ("a(iii)"));
for (n = 0; n < ports->len; ++n) {
g_variant_builder_add (builder, "(iii)",
g_array_index (ports, gint, n),
g_array_index (serves, gint, n), g_array_index (types, gint, n));
}
value = g_variant_builder_end (builder);
//result = g_variant_new_tuple (&value, 1);
res = g_variant_print (value, FALSE);
result = g_variant_new ("(s)", res);
/*
INFO ("value: %s (%d)", g_variant_get_type_string (value),
g_variant_n_children (value));
INFO ("result: %s, %s", g_variant_get_type_string (result), res);
*/
g_free (res);
g_array_free (ports, TRUE);
g_array_free (types, TRUE);
}
return result;
}
/**
* CacheEntrySerialize:
* @self: #CacheEntry to serialize.
*
* Returns: Human-readable string representing @self.
*/
gchar *CacheEntrySerialize(CacheEntry *self) {
GVariantBuilder builder;
const gchar *algorithm = NULL;
GVariant *result_variant = NULL;
gchar *result = NULL;
g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(&builder, "{sv}", "version",
g_variant_new_int32(self->version));
g_variant_builder_add(&builder, "{sv}", "tries",
g_variant_new_int32(self->tries));
algorithm = CacheUtilHashalgToString(self->algorithm);
if (algorithm)
g_variant_builder_add(&builder, "{sv}", "algorithm",
g_variant_new_string(algorithm));
struct {const gchar *name; gchar *value;} attrs[] = {
{"salt", CacheUtilBytesToString(self->salt)},
{"hash", CacheUtilBytesToString(self->hash)},
{"last_verified", CacheUtilDatetimeToString(self->last_verified)},
{"last_used", CacheUtilDatetimeToString(self->last_used)},
{"last_tried", CacheUtilDatetimeToString(self->last_tried)},
};
for (guint i = 0; i < G_N_ELEMENTS(attrs); i++) {
if (attrs[i].value) {
g_variant_builder_add(&builder, "{sv}", attrs[i].name,
g_variant_new_string(attrs[i].value));
g_free(attrs[i].value);
}
}
result_variant = g_variant_builder_end(&builder);
result = g_variant_print(result_variant, TRUE);
g_variant_unref(result_variant);
return result;
}
static void
on_interface_proxy_properties_changed (GDBusObjectManagerClient *manager,
GDBusObjectProxy *object_proxy,
GDBusProxy *interface_proxy,
GVariant *changed_properties,
const gchar *const *invalidated_properties,
gpointer user_data)
{
GVariantIter iter;
const gchar *key;
GVariant *value;
gchar *s;
g_print ("Properties Changed on %s:\n", g_dbus_object_get_object_path (G_DBUS_OBJECT (object_proxy)));
g_variant_iter_init (&iter, changed_properties);
while (g_variant_iter_next (&iter, "{&sv}", &key, &value))
{
s = g_variant_print (value, TRUE);
g_print (" %s -> %s\n", key, s);
g_variant_unref (value);
g_free (s);
}
}
