static void update_property(const gchar *name, GVariant *value, void *user_data)
{
struct ofono_sim_manager *sim = user_data;
gchar *pin_type_str = NULL;
gchar *subscriber_number = NULL;
int n;
GVariant *child, *prop_value, *prop_key;
enum ofono_sim_pin pin_type;
g_message("[SIM:%s] property %s changed", sim->path, name);
if (g_str_equal(name, "Present"))
sim->present = g_variant_get_boolean(value);
else if (g_str_equal(name, "SubscriberIdentity"))
sim->imsi = g_variant_dup_string(value, NULL);
else if (g_str_equal(name, "MobileCountryCode"))
sim->mcc = g_variant_dup_string(value, NULL);
else if (g_str_equal(name, "MobileNetworkCode"))
sim->mnc = g_variant_dup_string(value, NULL);
else if (g_str_equal(name, "PinRequired")) {
pin_type_str = g_variant_dup_string(value, NULL);
sim->pin_required = parse_ofono_sim_pin_type(pin_type_str);
g_free(pin_type_str);
}
else if (g_str_equal(name, "LockedPins")) {
for (n = 0; n < g_variant_n_children(value); n++) {
child = g_variant_get_child_value(value, n);
pin_type_str = g_variant_dup_string(child, NULL);
pin_type = parse_ofono_sim_pin_type(pin_type_str);
g_free(pin_type_str);
sim->locked_pins[pin_type] = (pin_type != OFONO_SIM_PIN_TYPE_INVALID);
}
}
else if (g_str_equal(name, "Retries")) {
memset(sim->pin_retries, 0, sizeof(sim->pin_retries));
for (n = 0; n < g_variant_n_children(value); n++) {
child = g_variant_get_child_value(value, n);
prop_key = g_variant_get_child_value(child, 0);
prop_value = g_variant_get_child_value(child, 1);
pin_type_str = g_variant_dup_string(prop_key, NULL);
pin_type = parse_ofono_sim_pin_type(pin_type_str);
g_free(pin_type_str);
sim->pin_retries[pin_type] = (int) g_variant_get_byte(prop_value);
}
}
else if (g_str_equal(name, "FixedDialing")) {
sim->fixed_dialing = g_variant_get_boolean(value);
}
else if (g_str_equal(name, "MobileCountryCode")) {
if (sim->mcc)
g_free(sim->mcc);
sim->mcc = g_variant_dup_string(value, NULL);
}
else if (g_str_equal(name, "MobileNetworkCode")) {
if (sim->mnc)
g_free(sim->mnc);
sim->mnc = g_variant_dup_string(value, NULL);
}
else if (g_str_equal(name, "CardIdentifier")) {
if (sim->card_identifier)
g_free(sim->card_identifier);
sim->card_identifier = g_variant_dup_string(value, NULL);
}
else if (g_str_equal(name, "SubscriberIdentity")) {
if (sim->subscriber_identity)
g_free(sim->subscriber_identity);
sim->subscriber_identity = g_variant_dup_string(value, NULL);
}
else if (g_str_equal(name, "SubscriberNumbers")) {
if (sim->subscriber_numbers) {
g_slist_free_full(sim->subscriber_numbers, g_free);
sim->subscriber_numbers = NULL;
}
for (n = 0; n < g_variant_n_children(value); n++) {
child = g_variant_get_child_value(value, n);
subscriber_number = g_variant_dup_string(child, NULL);
sim->subscriber_numbers = g_slist_append(sim->subscriber_numbers, subscriber_number);
}
}
if (sim->prop_changed_cb)
sim->prop_changed_cb(name, sim->prop_changed_data);
}
void show_dev_detail(void)
{
struct sr_dev_inst *sdi;
const struct sr_config_info *srci;
struct sr_channel *ch;
struct sr_channel_group *channel_group, *cg;
GSList *devices, *cgl, *chl;
GVariant *gvar_opts, *gvar_dict, *gvar_list, *gvar;
gsize num_opts, num_elements;
double dlow, dhigh, dcur_low, dcur_high;
const uint64_t *uint64, p, q, low, high;
uint64_t cur_low, cur_high;
const int32_t *int32, *opts;
unsigned int num_devices, o, i;
char *tmp_str;
char *s, c;
const char **stropts;
if (!(devices = device_scan())) {
g_critical("No devices found.");
return;
}
num_devices = g_slist_length(devices);
if (num_devices > 1) {
g_critical("%d devices found. Use --scan to show them, "
"and select one to show.", num_devices);
return;
}
sdi = devices->data;
print_dev_line(sdi);
if (sr_dev_open(sdi) != SR_OK) {
g_critical("Failed to open device.");
return;
}
if ((sr_config_list(sdi->driver, NULL, NULL, SR_CONF_SCAN_OPTIONS,
&gvar_opts) == SR_OK)) {
opts = g_variant_get_fixed_array(gvar_opts, &num_elements,
sizeof(int32_t));
printf("Supported driver options:\n");
for (i = 0; i < num_elements; i++) {
if (!(srci = sr_config_info_get(opts[i])))
continue;
printf(" %s\n", srci->id);
}
g_variant_unref(gvar_opts);
}
/* Selected channels and channel group may affect which options are
* returned, or which values for them. */
select_channels(sdi);
channel_group = select_channel_group(sdi);
if ((sr_config_list(sdi->driver, sdi, channel_group, SR_CONF_DEVICE_OPTIONS,
&gvar_opts)) != SR_OK)
/* Driver supports no device instance options. */
return;
if (sdi->channel_groups) {
printf("Channel groups:\n");
for (cgl = sdi->channel_groups; cgl; cgl = cgl->next) {
cg = cgl->data;
printf(" %s: channel%s", cg->name,
g_slist_length(cg->channels) > 1 ? "s" : "");
for (chl = cg->channels; chl; chl = chl->next) {
ch = chl->data;
printf(" %s", ch->name);
}
printf("\n");
}
}
printf("Supported configuration options");
if (sdi->channel_groups) {
if (!channel_group)
printf(" across all channel groups");
else
printf(" on channel group %s", channel_group->name);
}
printf(":\n");
opts = g_variant_get_fixed_array(gvar_opts, &num_opts, sizeof(int32_t));
for (o = 0; o < num_opts; o++) {
if (!(srci = sr_config_info_get(opts[o])))
continue;
if (srci->key == SR_CONF_TRIGGER_MATCH) {
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar_list) != SR_OK) {
printf("\n");
continue;
}
int32 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(int32_t));
printf(" Supported triggers: ");
for (i = 0; i < num_elements; i++) {
switch(int32[i]) {
case SR_TRIGGER_ZERO:
c = '0';
break;
case SR_TRIGGER_ONE:
c = '1';
break;
case SR_TRIGGER_RISING:
c = 'r';
break;
case SR_TRIGGER_FALLING:
c = 'f';
break;
case SR_TRIGGER_EDGE:
c = 'e';
break;
case SR_TRIGGER_OVER:
c = 'o';
break;
case SR_TRIGGER_UNDER:
c = 'u';
break;
default:
c = 0;
break;
}
if (c)
printf("%c ", c);
}
printf("\n");
g_variant_unref(gvar_list);
} else if (srci->key == SR_CONF_LIMIT_SAMPLES) {
/* If implemented in config_list(), this denotes the
* maximum number of samples a device can send. This
* really applies only to logic analyzers, and then
* only to those that don't support compression, or
* have it turned off by default. The values returned
* are the low/high limits. */
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar) != SR_OK) {
continue;
}
g_variant_get(gvar, "(tt)", &low, &high);
g_variant_unref(gvar);
printf(" Maximum number of samples: %"PRIu64"\n", high);
} else if (srci->key == SR_CONF_SAMPLERATE) {
/* Supported samplerates */
printf(" %s", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group, SR_CONF_SAMPLERATE,
&gvar_dict) != SR_OK) {
printf("\n");
continue;
}
if ((gvar_list = g_variant_lookup_value(gvar_dict,
"samplerates", G_VARIANT_TYPE("at")))) {
uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
printf(" - supported samplerates:\n");
for (i = 0; i < num_elements; i++) {
if (!(s = sr_samplerate_string(uint64[i])))
continue;
printf(" %s\n", s);
g_free(s);
}
g_variant_unref(gvar_list);
} else if ((gvar_list = g_variant_lookup_value(gvar_dict,
"samplerate-steps", G_VARIANT_TYPE("at")))) {
uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
/* low */
if (!(s = sr_samplerate_string(uint64[0])))
continue;
printf(" (%s", s);
g_free(s);
/* high */
if (!(s = sr_samplerate_string(uint64[1])))
continue;
printf(" - %s", s);
g_free(s);
/* step */
if (!(s = sr_samplerate_string(uint64[2])))
continue;
printf(" in steps of %s)\n", s);
g_free(s);
g_variant_unref(gvar_list);
}
g_variant_unref(gvar_dict);
} else if (srci->key == SR_CONF_BUFFERSIZE) {
/* Supported buffer sizes */
printf(" %s", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group,
SR_CONF_BUFFERSIZE, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
printf(" - supported buffer sizes:\n");
for (i = 0; i < num_elements; i++)
printf(" %"PRIu64"\n", uint64[i]);
g_variant_unref(gvar_list);
} else if (srci->key == SR_CONF_TIMEBASE) {
/* Supported time bases */
printf(" %s", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group,
SR_CONF_TIMEBASE, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
printf(" - supported time bases:\n");
num_elements = g_variant_n_children(gvar_list);
for (i = 0; i < num_elements; i++) {
gvar = g_variant_get_child_value(gvar_list, i);
g_variant_get(gvar, "(tt)", &p, &q);
s = sr_period_string(p * q);
printf(" %s\n", s);
g_free(s);
}
g_variant_unref(gvar_list);
} else if (srci->key == SR_CONF_VDIV) {
/* Supported volts/div values */
printf(" %s", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group,
SR_CONF_VDIV, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
printf(" - supported volts/div:\n");
num_elements = g_variant_n_children(gvar_list);
for (i = 0; i < num_elements; i++) {
gvar = g_variant_get_child_value(gvar_list, i);
g_variant_get(gvar, "(tt)", &p, &q);
s = sr_voltage_string(p, q);
printf(" %s\n", s);
g_free(s);
}
g_variant_unref(gvar_list);
} else if (srci->datatype == SR_T_STRING) {
printf(" %s: ", srci->id);
if (sr_config_get(sdi->driver, sdi, channel_group, srci->key,
&gvar) == SR_OK) {
tmp_str = g_strdup(g_variant_get_string(gvar, NULL));
g_variant_unref(gvar);
} else
tmp_str = NULL;
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar) != SR_OK) {
printf("\n");
continue;
}
stropts = g_variant_get_strv(gvar, &num_elements);
for (i = 0; i < num_elements; i++) {
if (i)
printf(", ");
printf("%s", stropts[i]);
if (tmp_str && !strcmp(tmp_str, stropts[i]))
printf(" (current)");
}
printf("\n");
g_free(stropts);
g_free(tmp_str);
g_variant_unref(gvar);
} else if (srci->datatype == SR_T_UINT64_RANGE) {
printf(" %s: ", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar_list) != SR_OK) {
printf("\n");
continue;
}
if (sr_config_get(sdi->driver, sdi, NULL, srci->key, &gvar) == SR_OK) {
g_variant_get(gvar, "(tt)", &cur_low, &cur_high);
g_variant_unref(gvar);
} else {
cur_low = 0;
cur_high = 0;
}
num_elements = g_variant_n_children(gvar_list);
for (i = 0; i < num_elements; i++) {
gvar = g_variant_get_child_value(gvar_list, i);
g_variant_get(gvar, "(tt)", &low, &high);
g_variant_unref(gvar);
if (i)
printf(", ");
printf("%"PRIu64"-%"PRIu64, low, high);
if (low == cur_low && high == cur_high)
printf(" (current)");
}
printf("\n");
g_variant_unref(gvar_list);
} else if (srci->datatype == SR_T_BOOL) {
printf(" %s: ", srci->id);
if (sr_config_get(sdi->driver, sdi, NULL, srci->key,
&gvar) == SR_OK) {
if (g_variant_get_boolean(gvar))
printf("on (current), off\n");
else
printf("on, off (current)\n");
g_variant_unref(gvar);
} else
printf("on, off\n");
} else if (srci->datatype == SR_T_DOUBLE_RANGE) {
printf(" %s: ", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar_list) != SR_OK) {
printf("\n");
continue;
}
if (sr_config_get(sdi->driver, sdi, NULL, srci->key, &gvar) == SR_OK) {
g_variant_get(gvar, "(dd)", &dcur_low, &dcur_high);
g_variant_unref(gvar);
} else {
dcur_low = 0;
dcur_high = 0;
}
num_elements = g_variant_n_children(gvar_list);
for (i = 0; i < num_elements; i++) {
gvar = g_variant_get_child_value(gvar_list, i);
g_variant_get(gvar, "(dd)", &dlow, &dhigh);
g_variant_unref(gvar);
if (i)
printf(", ");
printf("%.1f-%.1f", dlow, dhigh);
if (dlow == dcur_low && dhigh == dcur_high)
printf(" (current)");
}
printf("\n");
g_variant_unref(gvar_list);
} else {
/* Everything else */
printf(" %s\n", srci->id);
}
}
g_variant_unref(gvar_opts);
sr_dev_close(sdi);
g_slist_free(devices);
}
// Get the (key,value) pairs back from KWallet.
GHashTable *dt_pwstorage_kwallet_get(const backend_kwallet_context_t *context, const gchar *slot)
{
GHashTable *table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
GError *error = NULL;
// Is there an entry in the wallet?
gboolean has_entry = FALSE;
int wallet_handle = get_wallet_handle(context);
/* signature:
*
* in i handle,
* in s folder,
* in s key,
* in s appid,
*
* out b arg_0
*/
GVariant *ret = g_dbus_proxy_call_sync(context->proxy, "hasEntry",
g_variant_new("(isss)", wallet_handle, kwallet_folder, slot, app_id),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if(check_error(error))
{
g_variant_unref(ret);
return table;
}
GVariant *child = g_variant_get_child_value(ret, 0);
has_entry = g_variant_get_boolean(child);
g_variant_unref(child);
g_variant_unref(ret);
if(!has_entry) return table;
/* signature:
*
* in i handle,
* in s folder,
* in s key,
* in s appid,
*
* out a{sv} arg_0)
*/
ret = g_dbus_proxy_call_sync(context->proxy, "readMapList",
g_variant_new("(isss)", wallet_handle, kwallet_folder, slot, app_id),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if(check_error(error))
{
g_variant_unref(ret);
return table;
}
child = g_variant_get_child_value(ret, 0);
// we are only interested in the first child. i am not even sure that there can legally be more than one
if(g_variant_n_children(child) < 1)
{
g_variant_unref(child);
g_variant_unref(ret);
return table;
}
GVariant *element = g_variant_get_child_value(child, 0);
GVariant *v = NULL;
g_variant_get(element, "{sv}", NULL, &v);
const gchar *byte_array = g_variant_get_data(v);
if(!byte_array)
{
g_variant_unref(v);
g_variant_unref(element);
g_variant_unref(child);
g_variant_unref(ret);
return table;
}
int entries = GINT_FROM_BE(*((int *)byte_array));
byte_array += sizeof(gint);
for(int i = 0; i < entries; i++)
{
guint length;
gchar *key = array2string(byte_array, &length);
byte_array += length;
gchar *value = array2string(byte_array, &length);
byte_array += length;
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_kwallet_get] reading (%s, %s)\n", (gchar *)key, (gchar *)value);
g_hash_table_insert(table, key, value);
}
g_variant_unref(v);
g_variant_unref(element);
g_variant_unref(child);
g_variant_unref(ret);
return table;
}
static void sGetEntries(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation, eMode mode)
{
#if VDRVERSNUM > 20300
LOCK_CHANNELS_READ;
const cChannels *channels = Channels;
#else
cChannels *channels = &Channels;
#endif
const cChannel *channel = NULL;
guint64 atTime = 0;
GVariant *first = g_variant_get_child_value(Parameters, 0);
const char *c = NULL;
if (!sGetChannel(first, &c, channels, &channel)) {
cString reply = cString::sprintf("channel \"%s\" not defined", c);
esyslog("dbus2vdr: %s.GetEntries: %s", DBUS_VDR_EPG_INTERFACE, *reply);
sReturnError(Invocation, 501, *reply);
g_variant_unref(first);
return;
}
if (mode == dmmAtTime) {
GVariant *second = g_variant_get_child_value(Parameters, 1);
g_variant_get(second, "t", &atTime);
g_variant_unref(second);
if (atTime == 0) {
cString reply = cString::sprintf("missing time");
esyslog("dbus2vdr: %s.GetEntries: %s", DBUS_VDR_EPG_INTERFACE, *reply);
sReturnError(Invocation, 501, *reply);
g_variant_unref(first);
return;
}
}
g_variant_unref(first);
const cSchedules *scheds = NULL;
#if VDRVERSNUM > 20300
cStateKey StateKey;
scheds = cSchedules::GetSchedulesRead(StateKey, 1000);
#else
cSchedulesLock sl(false, 1000);
if (!sl.Locked()) {
sReturnError(Invocation, 550, "got no lock on schedules");
return;
}
scheds = cSchedules::Schedules(sl);
#endif
if (scheds == NULL) {
sReturnError(Invocation, 550, "got no schedules");
return;
}
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("(isaa(sv))"));
g_variant_builder_add(builder, "i", 250);
g_variant_builder_add(builder, "s", "");
GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("aa(sv)"));
bool next = false;
if (channel == NULL) {
channel = channels->First();
next = true;
}
while (channel) {
const cSchedule *s = scheds->GetSchedule(channel, false);
if (s != NULL) {
const cEvent *e = NULL;
switch (mode) {
case dmmPresent:
e = s->GetPresentEvent();
break;
case dmmFollowing:
e = s->GetFollowingEvent();
break;
case dmmAtTime:
e = s->GetEventAround(atTime);
break;
default:
e = NULL;
break;
}
if (e != NULL)
sAddEvent(array, *e);
}
if (next)
channel = channels->Next(channel);
else
break;
}
#if VDRVERSNUM > 20300
StateKey.Remove();
#endif
g_variant_builder_add_value(builder, g_variant_builder_end(array));
g_dbus_method_invocation_return_value(Invocation, g_variant_builder_end(builder));
g_variant_builder_unref(array);
g_variant_builder_unref(builder);
};
// get the handle for connections to KWallet
static int get_wallet_handle(const backend_kwallet_context_t *context)
{
// Open the wallet.
int handle = invalid_kwallet_handle;
GError *error = NULL;
/* signature:
*
* in s wallet,
* in x wId,
* in s appid,
*
* out i arg_0
*/
GVariant *ret = g_dbus_proxy_call_sync(context->proxy, "open",
g_variant_new("(sxs)", context->wallet_name, 0LL, app_id),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if(check_error(error))
{
g_variant_unref(ret);
return invalid_kwallet_handle;
}
GVariant *child = g_variant_get_child_value(ret, 0);
handle = g_variant_get_int32(child);
g_variant_unref(child);
g_variant_unref(ret);
// Check if our folder exists.
gboolean has_folder = FALSE;
/* signature:
*
* in i handle,
* in s folder,
* in s appid,
*
* out b arg_0
*/
ret = g_dbus_proxy_call_sync(context->proxy, "hasFolder",
g_variant_new("(iss)", handle, kwallet_folder, app_id), G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
if(check_error(error))
{
g_variant_unref(ret);
return invalid_kwallet_handle;
}
child = g_variant_get_child_value(ret, 0);
has_folder = g_variant_get_boolean(child);
g_variant_unref(child);
g_variant_unref(ret);
// Create it if it didn't.
if(!has_folder)
{
gboolean success = FALSE;
/* signature:
*
* in i handle,
* in s folder,
* in s appid,
*
* out b arg_0
*/
ret = g_dbus_proxy_call_sync(context->proxy, "createFolder",
g_variant_new("(iss)", handle, kwallet_folder, app_id),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if(check_error(error))
{
g_variant_unref(ret);
return invalid_kwallet_handle;
}
GVariant *child = g_variant_get_child_value(ret, 0);
success = g_variant_get_boolean(child);
g_variant_unref(child);
g_variant_unref(ret);
if(!success) return invalid_kwallet_handle;
}
return handle;
}
// Store (key,value) pairs from a GHashTable in the kwallet.
// Every 'slot' has to take care of it's own data.
gboolean dt_pwstorage_kwallet_set(const backend_kwallet_context_t *context, const gchar *slot,
GHashTable *table)
{
printf("slot %s\n", slot);
GArray *byte_array = g_array_new(FALSE, FALSE, sizeof(gchar));
GHashTableIter iter;
g_hash_table_iter_init(&iter, table);
gpointer key, value;
guint size = g_hash_table_size(table);
size = GINT_TO_BE(size);
g_array_append_vals(byte_array, &size, sizeof(guint) / sizeof(gchar));
while(g_hash_table_iter_next(&iter, &key, &value))
{
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_kwallet_set] storing (%s, %s)\n", (gchar *)key, (gchar *)value);
gsize length;
gchar *new_key = char2qstring(key, &length);
if(new_key == NULL)
{
g_free(g_array_free(byte_array, FALSE));
return FALSE;
}
g_array_append_vals(byte_array, new_key, length);
g_free(new_key);
gchar *new_value = char2qstring(value, &length);
if(new_value == NULL)
{
g_free(g_array_free(byte_array, FALSE));
return FALSE;
}
g_array_append_vals(byte_array, new_value, length);
g_free(new_value);
}
int wallet_handle = get_wallet_handle(context);
GError *error = NULL;
/* signature:
*
* in i handle,
* in s folder,
* in s key,
* in ay value,
* in s appid,
*
* out i arg_0
*/
GVariant *ret = g_dbus_proxy_call_sync(
context->proxy, "writeMap",
g_variant_new("(iss@ays)", wallet_handle, kwallet_folder, slot,
g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING, byte_array->data, byte_array->len,
TRUE, g_free, byte_array->data),
app_id),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
g_array_free(byte_array, FALSE);
if(check_error(error))
{
g_variant_unref(ret);
return FALSE;
}
GVariant *child = g_variant_get_child_value(ret, 0);
int return_code = g_variant_get_int32(child);
g_variant_unref(child);
g_variant_unref(ret);
if(return_code != 0)
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_kwallet_set] Warning: bad return code %d from kwallet\n",
return_code);
return return_code == 0;
}
static void
flickr_credentials_mgr_goa_on_managed_objects(GObject* mgr_proxy, GAsyncResult* result, gpointer user_data) {
/* UserCode on_managed_objects { */
FlickrCredentialsLoadClosure *closure = (FlickrCredentialsLoadClosure *) user_data;
FlickrCredentialsManagerGOA *self = FLICKR_CREDENTIALS_MANAGER_GOA (closure->credentials);
gboolean error_occurred = FALSE;
GError *error = NULL;
if (!result) {
error_occurred = TRUE;
goto exit;
}
GVariant *result_data = g_dbus_proxy_call_finish ((GDBusProxy *) mgr_proxy, result, NULL);
if (!result_data) {
error_occurred = TRUE;
goto exit;
}
GVariant *content = g_variant_get_child_value (result_data, 0);
g_variant_unref (result_data);
GVariantIter iter;
GVariant *child;
GVariant *object_path;
GVariant *interfaces;
GVariant *account;
GVariant *provider_type;
gboolean done = FALSE;
g_variant_iter_init (&iter, content);
while ((child = g_variant_iter_next_value(&iter))) {
/* Check whether child is an account: */
interfaces = g_variant_get_child_value (child, 1);
account = g_variant_lookup_value (
interfaces,
"org.gnome.OnlineAccounts.Account",
NULL
);
if (account) {
/* Is account a flickr account? */
provider_type = g_variant_lookup_value (account, "ProviderType", NULL);
if (provider_type) {
if (g_strcmp0 (g_variant_get_string (provider_type, NULL), "flickr") == 0) {
object_path = g_variant_get_child_value (child, 0);
self->priv->object_path = g_strdup (g_variant_get_string (object_path, NULL));
g_variant_unref (object_path);
flickr_credentials_mgr_goa_get_access_data (
self,
interfaces,
closure,
&error
);
error_occurred = error ? TRUE : FALSE;
done = TRUE;
}
g_variant_unref (provider_type);
}
g_variant_unref (account);
}
g_variant_unref (interfaces);
if (done) {
break;
}
}
g_variant_unref (content);
exit:
g_object_unref (mgr_proxy);
if (error_occurred) {
closure->callback (closure->credentials, FALSE, error, closure->user_data);
flickr_credentials_load_closure_free (closure);
}
if (error) {
g_error_free (error);
}
/* } UserCode */
}
static gint64
arv_rtkit_get_int_property (GDBusConnection *connection, const char* propname, GError **error) {
GDBusMessage *message;
GDBusMessage *reply;
GError *local_error = NULL;
GVariant *body;
GVariant *parameter;
GVariant *variant;
const GVariantType *variant_type;
gint64 value;
message = g_dbus_message_new_method_call (RTKIT_SERVICE_NAME,
RTKIT_OBJECT_PATH,
"org.freedesktop.DBus.Properties",
"Get");
g_dbus_message_set_body (message, g_variant_new ("(ss)", "org.freedesktop.RealtimeKit1", propname));
reply = g_dbus_connection_send_message_with_reply_sync (connection, message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE, 1000, NULL, NULL,
&local_error);
g_object_unref (message);
if (local_error != NULL) {
g_propagate_error (error, local_error);
return 0;
}
if (g_dbus_message_get_message_type (reply) != G_DBUS_MESSAGE_TYPE_METHOD_RETURN) {
local_error = g_error_new (ARV_RTKIT_ERROR, ARV_RTKIT_ERROR_PERMISSION_DENIED,
"%s", g_dbus_message_get_error_name (reply));
g_propagate_error (error, local_error);
g_object_unref (reply);
return 0;
}
if (!g_variant_type_equal ("v", g_dbus_message_get_signature (reply))) {
local_error = g_error_new (ARV_RTKIT_ERROR, ARV_RTKIT_ERROR_WRONG_REPLY,
"Invalid reply signature");
g_propagate_error (error, local_error);
g_object_unref (reply);
return 0;
}
body = g_dbus_message_get_body (reply);
parameter = g_variant_get_child_value (body, 0);
variant = g_variant_get_variant (parameter);
variant_type = g_variant_get_type (variant);
if (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT32))
value = g_variant_get_int32 (variant);
else if (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT64))
value = g_variant_get_int64 (variant);
else
value = 0;
g_variant_unref (parameter);
g_variant_unref (variant);
g_object_unref (reply);
return value;
}
gboolean
flatpak_builtin_build_commit_from (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(GFile) dst_repofile = NULL;
g_autoptr(OstreeRepo) dst_repo = NULL;
g_autoptr(GFile) src_repofile = NULL;
g_autoptr(OstreeRepo) src_repo = NULL;
g_autofree char *src_repo_uri = NULL;
const char *dst_repo_arg;
const char **dst_refs;
int n_dst_refs = 0;
g_autoptr(FlatpakRepoTransaction) transaction = NULL;
g_autoptr(GPtrArray) src_refs = NULL;
g_autoptr(GPtrArray) resolved_src_refs = NULL;
OstreeRepoCommitState src_commit_state;
struct timespec ts;
guint64 timestamp;
int i;
context = g_option_context_new (_("DST-REPO [DST-REF…] - Make a new commit from existing commits"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
if (!flatpak_option_context_parse (context, options, &argc, &argv, FLATPAK_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
return FALSE;
if (argc < 2)
return usage_error (context, _("DST-REPO must be specified"), error);
dst_repo_arg = argv[1];
dst_refs = (const char **) argv + 2;
n_dst_refs = argc - 2;
if (opt_src_repo == NULL && n_dst_refs != 1)
return usage_error (context, _("If --src-repo is not specified, exactly one destination ref must be specified"), error);
if (opt_src_ref != NULL && n_dst_refs != 1)
return usage_error (context, _("If --src-ref is specified, exactly one destination ref must be specified"), error);
if (opt_src_repo == NULL && opt_src_ref == NULL)
return flatpak_fail (error, _("Either --src-repo or --src-ref must be specified."));
if (opt_timestamp)
{
if (!parse_datetime (&ts, opt_timestamp, NULL))
return flatpak_fail (error, _("Could not parse '%s'"), opt_timestamp);
}
dst_repofile = g_file_new_for_commandline_arg (dst_repo_arg);
if (!g_file_query_exists (dst_repofile, cancellable))
return flatpak_fail (error, _("'%s' is not a valid repository"), dst_repo_arg);
dst_repo = ostree_repo_new (dst_repofile);
if (!ostree_repo_open (dst_repo, cancellable, error))
return FALSE;
if (opt_disable_fsync)
ostree_repo_set_disable_fsync (dst_repo, TRUE);
if (opt_src_repo)
{
src_repofile = g_file_new_for_commandline_arg (opt_src_repo);
if (!g_file_query_exists (src_repofile, cancellable))
return flatpak_fail (error, _("'%s' is not a valid repository"), opt_src_repo);
src_repo_uri = g_file_get_uri (src_repofile);
src_repo = ostree_repo_new (src_repofile);
if (!ostree_repo_open (src_repo, cancellable, error))
return FALSE;
}
else
{
src_repo = g_object_ref (dst_repo);
}
src_refs = g_ptr_array_new_with_free_func (g_free);
if (opt_src_ref)
{
g_assert (n_dst_refs == 1);
g_ptr_array_add (src_refs, g_strdup (opt_src_ref));
}
else
{
g_assert (opt_src_repo != NULL);
if (n_dst_refs == 0)
{
g_autofree const char **keys = NULL;
g_autoptr(GHashTable) all_src_refs = NULL;
if (!ostree_repo_list_refs (src_repo, NULL, &all_src_refs,
cancellable, error))
return FALSE;
keys = (const char **) g_hash_table_get_keys_as_array (all_src_refs, NULL);
for (i = 0; keys[i] != NULL; i++)
{
if (g_str_has_prefix (keys[i], "runtime/") ||
g_str_has_prefix (keys[i], "app/"))
g_ptr_array_add (src_refs, g_strdup (keys[i]));
}
n_dst_refs = src_refs->len;
dst_refs = (const char **) src_refs->pdata;
}
else
{
for (i = 0; i < n_dst_refs; i++)
g_ptr_array_add (src_refs, g_strdup (dst_refs[i]));
}
}
resolved_src_refs = g_ptr_array_new_with_free_func (g_free);
for (i = 0; i < src_refs->len; i++)
{
const char *src_ref = g_ptr_array_index (src_refs, i);
char *resolved_ref;
if (!ostree_repo_resolve_rev (src_repo, src_ref, FALSE, &resolved_ref, error))
return FALSE;
g_ptr_array_add (resolved_src_refs, resolved_ref);
}
if (src_repo_uri != NULL)
{
OstreeRepoPullFlags pullflags = 0;
GVariantBuilder builder;
g_autoptr(OstreeAsyncProgress) progress = NULL;
g_auto(GLnxConsoleRef) console = { 0, };
g_autoptr(GVariant) options = NULL;
gboolean res;
if (opt_untrusted)
pullflags |= OSTREE_REPO_PULL_FLAGS_UNTRUSTED;
glnx_console_lock (&console);
if (console.is_tty)
progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, &console);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder, "{s@v}", "flags",
g_variant_new_variant (g_variant_new_int32 (pullflags)));
g_variant_builder_add (&builder, "{s@v}", "refs",
g_variant_new_variant (g_variant_new_strv ((const char * const *) resolved_src_refs->pdata,
resolved_src_refs->len)));
g_variant_builder_add (&builder, "{s@v}", "depth",
g_variant_new_variant (g_variant_new_int32 (0)));
options = g_variant_ref_sink (g_variant_builder_end (&builder));
res = ostree_repo_pull_with_options (dst_repo, src_repo_uri,
options,
progress,
cancellable, error);
if (progress)
ostree_async_progress_finish (progress);
if (!res)
return FALSE;
}
/* By now we have the commit with commit_id==resolved_ref and dependencies in dst_repo. We now create a new
* commit based on the toplevel tree ref from that commit.
* This is equivalent to:
* ostree commit --skip-if-unchanged --repo=${destrepo} --tree=ref=${resolved_ref}
*/
transaction = flatpak_repo_transaction_start (dst_repo, cancellable, error);
if (transaction == NULL)
return FALSE;
for (i = 0; i < resolved_src_refs->len; i++)
{
const char *dst_ref = dst_refs[i];
const char *resolved_ref = g_ptr_array_index (resolved_src_refs, i);
g_autofree char *dst_parent = NULL;
g_autoptr(GFile) dst_parent_root = NULL;
g_autoptr(GFile) src_ref_root = NULL;
g_autoptr(GVariant) src_commitv = NULL;
g_autoptr(GVariant) dst_commitv = NULL;
g_autoptr(OstreeMutableTree) mtree = NULL;
g_autoptr(GFile) dst_root = NULL;
g_autoptr(GVariant) commitv_metadata = NULL;
g_autoptr(GVariant) metadata = NULL;
const char *subject;
const char *body;
g_autofree char *commit_checksum = NULL;
GVariantBuilder metadata_builder;
gint j;
const char *dst_collection_id = NULL;
const char *main_collection_id = NULL;
g_autoptr(GPtrArray) collection_ids = NULL;
if (!ostree_repo_resolve_rev (dst_repo, dst_ref, TRUE, &dst_parent, error))
return FALSE;
if (dst_parent != NULL &&
!ostree_repo_read_commit (dst_repo, dst_parent, &dst_parent_root, NULL, cancellable, error))
return FALSE;
if (!ostree_repo_read_commit (dst_repo, resolved_ref, &src_ref_root, NULL, cancellable, error))
return FALSE;
if (!ostree_repo_load_commit (dst_repo, resolved_ref, &src_commitv, &src_commit_state, error))
return FALSE;
if (src_commit_state & OSTREE_REPO_COMMIT_STATE_PARTIAL)
return flatpak_fail (error, _("Can't commit from partial source commit."));
/* Don't create a new commit if this is the same tree */
if (!opt_force && dst_parent_root != NULL && g_file_equal (dst_parent_root, src_ref_root))
{
g_print (_("%s: no change\n"), dst_ref);
continue;
}
mtree = ostree_mutable_tree_new ();
if (!ostree_repo_write_directory_to_mtree (dst_repo, src_ref_root, mtree, NULL,
cancellable, error))
return FALSE;
if (!ostree_repo_write_mtree (dst_repo, mtree, &dst_root, cancellable, error))
return FALSE;
commitv_metadata = g_variant_get_child_value (src_commitv, 0);
g_variant_get_child (src_commitv, 3, "&s", &subject);
if (opt_subject)
subject = (const char *) opt_subject;
g_variant_get_child (src_commitv, 4, "&s", &body);
if (opt_body)
body = (const char *) opt_body;
dst_collection_id = ostree_repo_get_collection_id (dst_repo);
collection_ids = g_ptr_array_new_with_free_func (g_free);
if (dst_collection_id)
{
main_collection_id = dst_collection_id;
g_ptr_array_add (collection_ids, g_strdup (dst_collection_id));
}
if (opt_extra_collection_ids != NULL)
{
for (j = 0; opt_extra_collection_ids[j] != NULL; j++)
{
const char *cid = opt_extra_collection_ids[j];
if (main_collection_id == NULL)
main_collection_id = cid; /* Fall back to first arg */
if (g_strcmp0 (cid, dst_collection_id) != 0)
g_ptr_array_add (collection_ids, g_strdup (cid));
}
}
g_ptr_array_sort (collection_ids, (GCompareFunc)flatpak_strcmp0_ptr);
/* Copy old metadata */
g_variant_builder_init (&metadata_builder, G_VARIANT_TYPE ("a{sv}"));
/* Bindings. xa.ref is deprecated but added anyway for backwards compatibility. */
g_variant_builder_add (&metadata_builder, "{sv}", "ostree.collection-binding",
g_variant_new_string (main_collection_id ? main_collection_id : ""));
if (collection_ids->len > 0)
{
g_autoptr(GVariantBuilder) cr_builder = g_variant_builder_new (G_VARIANT_TYPE ("a(ss)"));
for (j = 0; j < collection_ids->len; j++)
g_variant_builder_add (cr_builder, "(ss)", g_ptr_array_index (collection_ids, j), dst_ref);
g_variant_builder_add (&metadata_builder, "{sv}", "ostree.collection-refs-binding",
g_variant_builder_end (cr_builder));
}
g_variant_builder_add (&metadata_builder, "{sv}", "ostree.ref-binding",
g_variant_new_strv (&dst_ref, 1));
g_variant_builder_add (&metadata_builder, "{sv}", "xa.ref", g_variant_new_string (dst_ref));
/* Record the source commit. This is nice to have, but it also
means the commit-from gets a different commit id, which
avoids problems with e.g. sharing .commitmeta files
(signatures) */
g_variant_builder_add (&metadata_builder, "{sv}", "xa.from_commit", g_variant_new_string (resolved_ref));
for (j = 0; j < g_variant_n_children (commitv_metadata); j++)
{
g_autoptr(GVariant) child = g_variant_get_child_value (commitv_metadata, j);
g_autoptr(GVariant) keyv = g_variant_get_child_value (child, 0);
const char *key = g_variant_get_string (keyv, NULL);
if (strcmp (key, "xa.ref") == 0 ||
strcmp (key, "xa.from_commit") == 0 ||
strcmp (key, "ostree.collection-binding") == 0 ||
strcmp (key, "ostree.collection-refs-binding") == 0 ||
strcmp (key, "ostree.ref-binding") == 0)
continue;
if (opt_endoflife &&
strcmp (key, OSTREE_COMMIT_META_KEY_ENDOFLIFE) == 0)
continue;
g_variant_builder_add_value (&metadata_builder, child);
}
if (opt_endoflife && *opt_endoflife)
g_variant_builder_add (&metadata_builder, "{sv}", OSTREE_COMMIT_META_KEY_ENDOFLIFE,
g_variant_new_string (opt_endoflife));
timestamp = ostree_commit_get_timestamp (src_commitv);
if (opt_timestamp)
timestamp = ts.tv_sec;
metadata = g_variant_ref_sink (g_variant_builder_end (&metadata_builder));
if (!ostree_repo_write_commit_with_time (dst_repo, dst_parent, subject, body, metadata,
OSTREE_REPO_FILE (dst_root),
timestamp,
&commit_checksum, cancellable, error))
return FALSE;
g_print ("%s: %s\n", dst_ref, commit_checksum);
if (!ostree_repo_load_commit (dst_repo, commit_checksum, &dst_commitv, NULL, error))
return FALSE;
/* This doesn't copy the detached metadata. I'm not sure if this is a problem.
* The main thing there is commit signatures, and we can't copy those, as the commit hash changes.
*/
if (opt_gpg_key_ids)
{
char **iter;
for (iter = opt_gpg_key_ids; iter && *iter; iter++)
{
const char *keyid = *iter;
g_autoptr(GError) my_error = NULL;
if (!ostree_repo_sign_commit (dst_repo,
commit_checksum,
keyid,
opt_gpg_homedir,
cancellable,
&my_error) &&
!g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_EXISTS))
{
g_propagate_error (error, g_steal_pointer (&my_error));
return FALSE;
}
}
}
if (dst_collection_id != NULL)
{
OstreeCollectionRef ref = { (char *) dst_collection_id, (char *) dst_ref };
ostree_repo_transaction_set_collection_ref (dst_repo, &ref, commit_checksum);
}
else
{
ostree_repo_transaction_set_ref (dst_repo, NULL, dst_ref, commit_checksum);
}
if (opt_extra_collection_ids)
{
for (j = 0; opt_extra_collection_ids[j] != NULL; j++)
{
OstreeCollectionRef ref = { (char *) opt_extra_collection_ids[j], (char *) dst_ref };
ostree_repo_transaction_set_collection_ref (dst_repo, &ref, commit_checksum);
}
}
/* Copy + Rewrite any deltas */
{
const char *from[2];
gsize j, n_from = 0;
if (dst_parent != NULL)
from[n_from++] = dst_parent;
from[n_from++] = NULL;
for (j = 0; j < n_from; j++)
{
g_autoptr(GError) local_error = NULL;
if (!rewrite_delta (src_repo, resolved_ref, dst_repo, commit_checksum, dst_commitv, from[j], &local_error))
g_debug ("Failed to copy delta: %s", local_error->message);
}
}
}
if (!ostree_repo_commit_transaction (dst_repo, NULL, cancellable, error))
return FALSE;
if (opt_update_appstream &&
!flatpak_repo_generate_appstream (dst_repo, (const char **) opt_gpg_key_ids, opt_gpg_homedir, 0, cancellable, error))
return FALSE;
if (!opt_no_update_summary &&
!flatpak_repo_update (dst_repo,
(const char **) opt_gpg_key_ids,
opt_gpg_homedir,
cancellable,
error))
return FALSE;
return TRUE;
}
static gboolean
rewrite_delta (OstreeRepo *src_repo,
const char *src_commit,
OstreeRepo *dst_repo,
const char *dst_commit,
GVariant *dst_commitv,
const char *from,
GError **error)
{
g_autoptr(GFile) src_delta_file = NULL;
g_autoptr(GFile) dst_delta_file = NULL;
g_autofree char *src_detached_key = _ostree_get_relative_static_delta_path (from, src_commit, "commitmeta");
g_autofree char *dst_detached_key = _ostree_get_relative_static_delta_path (from, dst_commit, "commitmeta");
g_autofree char *src_delta_dir = _ostree_get_relative_static_delta_path (from, src_commit, NULL);
g_autofree char *dst_delta_dir = _ostree_get_relative_static_delta_path (from, dst_commit, NULL);
g_autofree char *src_superblock_path = _ostree_get_relative_static_delta_path (from, src_commit, "superblock");
g_autofree char *dst_superblock_path = _ostree_get_relative_static_delta_path (from, dst_commit, "superblock");
GMappedFile *mfile = NULL;
g_auto(GVariantBuilder) superblock_builder = FLATPAK_VARIANT_BUILDER_INITIALIZER;
g_autoptr(GVariant) src_superblock = NULL;
g_autoptr(GVariant) dst_superblock = NULL;
g_autoptr(GBytes) bytes = NULL;
g_autoptr(GVariant) dst_detached = NULL;
g_autoptr(GVariant) src_metadata = NULL;
g_autoptr(GVariant) src_recurse = NULL;
g_autoptr(GVariant) src_parts = NULL;
g_auto(GVariantDict) dst_metadata_dict = FLATPAK_VARIANT_DICT_INITIALIZER;
int i;
src_delta_file = g_file_resolve_relative_path (ostree_repo_get_path (src_repo), src_superblock_path);
mfile = g_mapped_file_new (flatpak_file_get_path_cached (src_delta_file), FALSE, NULL);
if (mfile == NULL)
return TRUE; /* No superblock, not an error */
bytes = g_mapped_file_get_bytes (mfile);
g_mapped_file_unref (mfile);
src_superblock = g_variant_ref_sink (g_variant_new_from_bytes (G_VARIANT_TYPE (OSTREE_STATIC_DELTA_SUPERBLOCK_FORMAT), bytes, FALSE));
src_metadata = g_variant_get_child_value (src_superblock, 0);
src_recurse = g_variant_get_child_value (src_superblock, 5);
src_parts = g_variant_get_child_value (src_superblock, 6);
if (g_variant_n_children (src_recurse) != 0)
return flatpak_fail (error, "Recursive deltas not supported, ignoring");
g_variant_builder_init (&superblock_builder, G_VARIANT_TYPE (OSTREE_STATIC_DELTA_SUPERBLOCK_FORMAT));
g_variant_dict_init (&dst_metadata_dict, src_metadata);
g_variant_dict_remove (&dst_metadata_dict, src_detached_key);
if (ostree_repo_read_commit_detached_metadata (dst_repo, dst_commit, &dst_detached, NULL, NULL) &&
dst_detached != NULL)
g_variant_dict_insert_value (&dst_metadata_dict, dst_detached_key, dst_detached);
g_variant_builder_add_value (&superblock_builder, g_variant_dict_end (&dst_metadata_dict));
g_variant_builder_add_value (&superblock_builder, g_variant_get_child_value (src_superblock, 1)); /* timestamp */
g_variant_builder_add_value (&superblock_builder, from ? ostree_checksum_to_bytes_v (from) : new_bytearray ((guchar *) "", 0));
g_variant_builder_add_value (&superblock_builder, ostree_checksum_to_bytes_v (dst_commit));
g_variant_builder_add_value (&superblock_builder, dst_commitv);
g_variant_builder_add_value (&superblock_builder, src_recurse);
g_variant_builder_add_value (&superblock_builder, src_parts);
g_variant_builder_add_value (&superblock_builder, g_variant_get_child_value (src_superblock, 7)); /* fallback */
dst_superblock = g_variant_ref_sink (g_variant_builder_end (&superblock_builder));
if (!glnx_shutil_mkdir_p_at (ostree_repo_get_dfd (dst_repo), dst_delta_dir, 0755, NULL, error))
return FALSE;
for (i = 0; i < g_variant_n_children (src_parts); i++)
{
g_autofree char *src_part_path = g_strdup_printf ("%s/%d", src_delta_dir, i);
g_autofree char *dst_part_path = g_strdup_printf ("%s/%d", dst_delta_dir, i);
if (!glnx_file_copy_at (ostree_repo_get_dfd (src_repo),
src_part_path,
NULL,
ostree_repo_get_dfd (dst_repo),
dst_part_path,
GLNX_FILE_COPY_OVERWRITE | GLNX_FILE_COPY_NOXATTRS,
NULL, error))
return FALSE;
}
dst_delta_file = g_file_resolve_relative_path (ostree_repo_get_path (dst_repo), dst_superblock_path);
if (!flatpak_variant_save (dst_delta_file, dst_superblock, NULL, error))
return FALSE;
return TRUE;
}
JSValueRef dbus_to_js(JSContextRef ctx, GVariant *dbus)
{
JSValueRef jsvalue = NULL;
GVariantClass type = g_variant_classify(dbus);
switch (type) {
case G_VARIANT_CLASS_STRING:
case G_VARIANT_CLASS_OBJECT_PATH:
case G_VARIANT_CLASS_SIGNATURE: {
JSStringRef js_string = JSStringCreateWithUTF8CString(
g_variant_get_string(dbus, NULL));
jsvalue = JSValueMakeString(ctx, js_string);
JSStringRelease(js_string);
return jsvalue;
}
case G_VARIANT_CLASS_BYTE:
return JSValueMakeNumber(ctx, g_variant_get_byte(dbus));
case G_VARIANT_CLASS_DOUBLE:
return JSValueMakeNumber(ctx, g_variant_get_double(dbus));
case G_VARIANT_CLASS_INT16:
return JSValueMakeNumber(ctx, g_variant_get_int16(dbus));
case G_VARIANT_CLASS_UINT16:
return JSValueMakeNumber(ctx, g_variant_get_uint16(dbus));
case G_VARIANT_CLASS_INT32:
return JSValueMakeNumber(ctx, g_variant_get_int32(dbus));
case G_VARIANT_CLASS_UINT32:
return JSValueMakeNumber(ctx, g_variant_get_uint32(dbus));
case G_VARIANT_CLASS_INT64:
return JSValueMakeNumber(ctx, g_variant_get_int64(dbus));
case G_VARIANT_CLASS_UINT64:
return JSValueMakeNumber(ctx, g_variant_get_uint64(dbus));
case G_VARIANT_CLASS_BOOLEAN:
return JSValueMakeBoolean(ctx, g_variant_get_boolean(dbus));
case G_VARIANT_CLASS_HANDLE:
g_warning("[%s] does not support FD type\n", __func__);
return JSValueMakeNumber(ctx, g_variant_get_uint32(dbus));
case G_VARIANT_CLASS_VARIANT: {
GVariant* v = g_variant_get_variant(dbus);
jsvalue = dbus_to_js(ctx, v);
g_variant_unref(v);
return jsvalue;
}
case G_VARIANT_CLASS_DICT_ENTRY:
/*g_assert_not_reached();*/
break;
case G_VARIANT_CLASS_ARRAY: {
if (g_variant_type_is_dict_entry(
g_variant_type_element(g_variant_get_type(dbus)))) {
jsvalue = JSObjectMake(ctx, NULL, NULL);
for (size_t i=0; i<g_variant_n_children(dbus); i++) {
GVariant *dic = g_variant_get_child_value(dbus, i);
GVariant *key= g_variant_get_child_value (dic, 0);
GVariant *value = g_variant_get_child_value (dic, 1);
JSValueRef js_key = dbus_to_js(ctx, key);
JSValueRef js_value = dbus_to_js(ctx, value);
JSStringRef key_str = JSValueToStringCopy(ctx, js_key,
NULL);
JSObjectSetProperty(ctx, (JSObjectRef)jsvalue,
key_str, js_value, 0, NULL);
JSStringRelease(key_str);
g_variant_unref(key);
g_variant_unref(value);
g_variant_unref(dic);
}
return jsvalue;
} else {
int n = g_variant_n_children(dbus);
JSValueRef *args = g_new(JSValueRef, n);
for (int i=0; i < n; i++) {
GVariant* v = g_variant_get_child_value(dbus, i);
args[i] = dbus_to_js(ctx, v);
g_variant_unref(v);
}
jsvalue = JSObjectMakeArray(ctx, n, args, NULL);
g_free(args);
return jsvalue;
}
}
case G_VARIANT_CLASS_TUPLE: {
int n = g_variant_n_children(dbus);
jsvalue = JSObjectMakeArray(ctx, 0, NULL, NULL);
for (int i=0; i < n; i++) {
GVariant* v = g_variant_get_child_value(dbus, i);
JSObjectSetPropertyAtIndex(ctx, (JSObjectRef)jsvalue,
i, dbus_to_js(ctx, v), NULL);
g_variant_unref(v);
}
return jsvalue;
}
case G_VARIANT_CLASS_MAYBE:
g_assert_not_reached();
}
g_warning("[%s] does not support signature type:%c\n", __func__, type);
return JSValueMakeUndefined(ctx);
}
