/* Get a list of entries from an array. */
GSList *
gconf_dbus_utils_get_entries (DBusMessageIter *iter, const gchar *dir)
{
GSList *entries;
DBusMessageIter array_iter;
entries = NULL;
dbus_message_iter_recurse (iter, &array_iter);
/* Loop through while there are structs (entries). */
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRUCT)
{
gchar *key;
GConfValue *value;
gboolean is_default;
gboolean is_writable;
gchar *schema_name;
GConfEntry *entry;
if (!utils_get_entry_values_stringified (&array_iter,
&key,
&value,
&is_default,
&is_writable,
&schema_name))
break;
entry = gconf_entry_new_nocopy (gconf_concat_dir_and_key (dir, key), value);
gconf_entry_set_is_default (entry, is_default);
gconf_entry_set_is_writable (entry, is_writable);
if (schema_name)
gconf_entry_set_schema_name (entry, schema_name);
entries = g_slist_prepend (entries, entry);
dbus_message_iter_next (&array_iter);
}
return entries;
}
static void check_networks(DBusMessageIter *array)
{
DBusMessageIter value;
if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
return;
dbus_message_iter_recurse(array, &value);
while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_OBJECT_PATH) {
const char *path;
dbus_message_iter_get_basic(&value, &path);
add_network(path);
dbus_message_iter_next(&value);
}
}
static DBusMessage*
service_method_create_with_master_password (GkdSecretService *self, DBusMessage *message)
{
DBusError derr = DBUS_ERROR_INIT;
DBusMessageIter iter, array;
DBusMessage *reply = NULL;
GkdSecretSecret *secret = NULL;
GckAttributes *attrs = NULL;
gchar *path;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}(oayays)"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
attrs = gck_attributes_new ();
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, attrs)) {
gck_attributes_unref (attrs);
return dbus_message_new_error (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties argument");
}
dbus_message_iter_next (&iter);
secret = gkd_secret_secret_parse (self, message, &iter, &derr);
if (secret == NULL) {
gck_attributes_unref (attrs);
return gkd_secret_error_to_reply (message, &derr);
}
gck_attributes_add_boolean (attrs, CKA_TOKEN, TRUE);
path = gkd_secret_create_with_secret (attrs, secret, &derr);
gck_attributes_unref (attrs);
gkd_secret_secret_free (secret);
if (path == NULL)
return gkd_secret_error_to_reply (message, &derr);
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
g_free (path);
return reply;
}
static bool parse_input_request(DBusMessageIter *arg, void *user_data)
{
struct agent_input_data *data = user_data;
const char *name;
printf("parse_input_request\n");
if (cui_dbus_get_basic(arg, DBUS_TYPE_STRING, &name) != 0)
return FALSE;
dbus_message_iter_next(arg);
if (g_strcmp0(name, "Passphrase") == 0)
data->passphrase = TRUE;
else if (g_strcmp0(name, "WPS") == 0)
data->wpspin = TRUE;
else if (g_strcmp0(name, "Name") == 0)
data->hidden = TRUE;
else if (g_strcmp0(name, "Identity") == 0)
data->identity = TRUE;
else if (g_strcmp0(name, "Username") == 0)
data->login = TRUE;
else if (g_strcmp0(name, "PreviousPassphrase") == 0) {
DBusMessageIter dict;
const char **value;
const char *type;
dbus_message_iter_recurse(arg, &dict);
cui_dbus_get_dict_entry_basic(&dict,
"Type", DBUS_TYPE_STRING, &type);
if (g_strcmp0(type, "psk") == 0)
value = &data->previous_passphrase;
else if (g_strcmp0(type, "wpspin") == 0)
value = &data->previous_wpspin;
cui_dbus_get_dict_entry_basic(&dict,
"Value", DBUS_TYPE_STRING, &value);
}
return FALSE;
}
static gboolean audio_changed(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct modem_data *modem = user_data;
DBusMessageIter iter, value;
const char *key;
if (dbus_message_iter_init(msg, &iter) == FALSE)
return TRUE;
dbus_message_iter_get_basic(&iter, &key);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &value);
audio_set(modem, key, &value);
return TRUE;
}
void
decode_string(DBusMessageIter *iter, int *err, const char **pval)
{
const char *tmp = 0;
if( err != 0 )
{
if( dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING )
{
dbus_message_iter_get_basic(iter, &tmp);
dbus_message_iter_next(iter);
}
else
{
SET_ERR;
}
}
*pval = tmp;
}
static DBusMessage *set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct monitor *monitor = data;
const char *property;
DBusMessageIter iter;
DBusMessageIter sub;
const char *level;
if (!dbus_message_iter_init(msg, &iter))
return btd_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return btd_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return btd_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &sub);
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)
return btd_error_invalid_args(msg);
dbus_message_iter_get_basic(&sub, &level);
if (g_str_equal("ImmediateAlertLevel", property)) {
if (monitor->enabled.findme == FALSE &&
monitor->enabled.pathloss == FALSE)
return btd_error_not_available(msg);
return set_immediate_alert(conn, msg, level, data);
} else if (g_str_equal("LinkLossAlertLevel", property)) {
if (monitor->enabled.linkloss == FALSE)
return btd_error_not_available(msg);
return set_link_loss_alert(conn, msg, level, data);
}
return btd_error_invalid_args(msg);
}
void handle_signal_callback(gpointer no_used_key, struct SignalInfo* info, DBusMessage *msg)
{
NOUSED(no_used_key);
DBusMessageIter iter;
dbus_message_iter_init(msg, &iter);
int num = g_slist_length(info->signatures);
JSValueRef *params = g_new(JSValueRef, num);
for (int i=0; i<num; i++) {
params[i] = dbus_to_js(get_global_context(), &iter);
if (!dbus_message_iter_next(&iter)) {
}
}
g_assert(info->callback != NULL);
JSObjectCallAsFunction(get_global_context(),
info->callback, NULL,
num, params, NULL);
g_free(params);
}
static gboolean call_added(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct modem_data *modem = user_data;
DBusMessageIter iter, dict;
const char *path;
if (dbus_message_iter_init(msg, &iter) == FALSE)
return TRUE;
dbus_message_iter_get_basic(&iter, &path);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &dict);
create_call(modem, path, &iter);
return TRUE;
}
/*
* Phdc Manager requests to be removed from the existing list of managers.
*/
static DBusMessage *dbus_unregister_phdc_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct near_phdc_data *mgr;
DBusMessageIter iter;
const char *path, *role, *sender;
DBG("conn %p", conn);
if (!dbus_message_iter_init(msg, &iter))
return error_invalid_arguments(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH)
return error_invalid_arguments(msg);
sender = dbus_message_get_sender(msg);
dbus_message_iter_get_basic(&iter, &path);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return error_invalid_arguments(msg);
dbus_message_iter_get_basic(&iter, &role);
/* look for specific path */
mgr = search_mgr_list_by_path(path);
if (!mgr)
return error_not_found(msg);
DBG("%s", mgr->sender);
if (strncmp(sender, mgr->sender, strlen(mgr->sender)))
return error_permission_denied(msg);
/* remove it */
near_p2p_unregister(mgr->p2p_driver);
g_hash_table_remove(mgr_list, mgr->p2p_driver->service_name);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static void ring_callback (plugin_t *p, DBusMessage *msg, void *data)
{
at_modem_t *m = data;
DBusMessageIter call;
/* Skip call object path */
if (!dbus_message_iter_init (msg, &call)
|| dbus_message_iter_get_arg_type (&call) != DBUS_TYPE_OBJECT_PATH)
return;
dbus_message_iter_next (&call);
/* Only care about incoming or waiting calls */
const char *str = ofono_dict_find_string (&call, "State");
if (str == NULL)
return;
if (!strcmp (str, "incoming"))
incoming_call (p, &call, m);
if (!strcmp (str, "waiting"))
waiting_call (p, &call, m);
}
void
decode_bool(DBusMessageIter *iter, int *err, int *pval)
{
dbus_bool_t val = 0;
if( *err == 0 )
{
if( dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_BOOLEAN )
{
dbus_message_iter_get_basic(iter, &val);
dbus_message_iter_next(iter);
}
else
{
SET_ERR;
}
}
*pval = (val != 0);
}
void handleDD(DBusMessage *msg, double *a, double *b) {
DBusMessageIter args;
if (!dbus_message_iter_init(msg, &args)) {
fprintf(stderr, ERR_ARGS_EMPTY);
} else if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&args)) {
fprintf(stderr, ERR_ARG_TYPE_D);
}
dbus_message_iter_get_basic(&args, a);
if (!dbus_message_iter_next(&args)) {
fprintf(stderr, ERR_ARGS_MISSING);
} else if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&args)) {
fprintf(stderr, ERR_ARG_TYPE_D);
}
dbus_message_iter_get_basic(&args, b);
}
/**
* DemarshalSetPropertyValue() extracts the new property value from a
* org.freedesktop.DBus.Properties.Set method call message.
*
* @return int VLC_SUCCESS on success
* @param DBusMessage *p_msg a org.freedesktop.DBus.Properties.Set method call
* @param void *p_arg placeholder for the demarshalled value
*/
int DemarshalSetPropertyValue( DBusMessage *p_msg, void *p_arg )
{
int i_type;
bool b_valid_input = FALSE;
DBusMessageIter in_args, variant;
dbus_message_iter_init( p_msg, &in_args );
do
{
i_type = dbus_message_iter_get_arg_type( &in_args );
if( DBUS_TYPE_VARIANT == i_type )
{
dbus_message_iter_recurse( &in_args, &variant );
dbus_message_iter_get_basic( &variant, p_arg );
b_valid_input = TRUE;
}
} while( dbus_message_iter_next( &in_args ) );
return b_valid_input ? VLC_SUCCESS : VLC_EGENERIC;
}
t_ilm_bool getDouble(t_ilm_message message, t_ilm_float* value)
{
t_ilm_bool returnValue = ILM_FALSE;
dbusmessage* msg = (dbusmessage*)message;
t_ilm_int type = dbus_message_iter_get_arg_type(&msg->iter);
if (DBUS_TYPE_DOUBLE == type)
{
dbus_message_iter_get_basic(&msg->iter, value);
dbus_message_iter_next(&msg->iter);
returnValue = ILM_TRUE;
}
else
{
printf("ERROR: expected: DBUS_TYPE_DOUBLE,received ");
printTypeName(type);
}
return returnValue;
}
u_int32 get_pim_next_rp_static(struct pim_rp_set *info)
{
DBusMessage *query = NULL, *reply = NULL;
DBusError err = {0};
u_int32 op_ret = 0;
char *ifname;
DBusMessageIter iter;
query = dbus_message_new_method_call(PIMD_DBUS_BUSNAME,
PIMD_DBUS_OBJPATH,
PIMD_DBUS_INTERFACE,
PIMD_DBUS_INTERFACE_METHOD_SHOW_RP_STATIC);
dbus_error_init(&err);
dbus_message_append_args(query,
DBUS_TYPE_UINT32, &info->rp_addr,
DBUS_TYPE_UINT32, &info->grp_addr,
DBUS_TYPE_INVALID);
reply = dbus_connection_send_with_reply_and_block(dcli_dbus_connection,query,-1, &err);
dbus_message_unref(query);
if (NULL == reply) {
printf("failed get reply.\n");
if (dbus_error_is_set(&err)) {
dbus_error_free(&err);
}
return 1;
}
dbus_message_iter_init(reply,&iter);
dbus_message_iter_get_basic(&iter,&op_ret);
if (0==op_ret || 4==op_ret){
if(0==op_ret){
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter,&info->rp_addr);
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter,&ifname);
strcpy(info->iif_name, ifname);
}
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter,&info->grp_addr);
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter,&info->masklen);
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter,&info->priority);
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter,&info->holdtime);
}
dbus_message_unref(reply);
return op_ret;
}
static void bt_property_changed(DBusMessage * msg, gchar *type)
{
DBusMessageIter msg_i, var_i;
const gchar *path = dbus_message_get_path(msg);
const gchar *property_name;
const gchar *val;
/* OHM_DEBUG(DBG_BT, "bluetooth property changed!\n\n"); */
dbus_message_iter_init(msg, &msg_i);
if (dbus_message_iter_get_arg_type(&msg_i) != DBUS_TYPE_STRING) {
return;
}
/* get the name of the property */
dbus_message_iter_get_basic(&msg_i, &property_name);
if (strcmp(property_name, "State") == 0) {
dbus_message_iter_next(&msg_i);
if (dbus_message_iter_get_arg_type(&msg_i) != DBUS_TYPE_VARIANT) {
/* OHM_DEBUG(DBG_BT, "The property value is not variant\n"); */
return;
}
dbus_message_iter_recurse(&msg_i, &var_i);
if (dbus_message_iter_get_arg_type(&var_i) != DBUS_TYPE_STRING) {
OHM_DEBUG(DBG_BT, "The variant value is not string\n");
return;
}
dbus_message_iter_get_basic(&var_i, &val);
if (val)
bt_state_changed(type, path, val);
}
return;
}
static DBusMessage *agent_request_input_method(DBusConnection *dbus_cnx,
DBusMessage *msg, void *data)
{
struct agent_input_data arg_data;
DBusMessageIter arg;
const char *path;
printf("agent_request_input_method\n");
if (agent_if == NULL || agent_if->input_cb == NULL)
goto error;
memset(&arg_data, 0, sizeof(struct agent_input_data));
if (dbus_message_iter_init(msg, &arg) == FALSE)
goto error;
if (cui_dbus_get_basic(&arg, DBUS_TYPE_OBJECT_PATH, &path) != 0)
goto error;
dbus_message_iter_next(&arg);
cui_dbus_foreach_dict_entry(&arg, parse_input_request, &arg_data);
if (arg_data.hidden == FALSE &&
arg_data.identity == FALSE &&
arg_data.passphrase == FALSE &&
arg_data.login == FALSE)
goto error;
agent_if->pending_reply = dbus_message_ref(msg);
agent_if->input_cb(path, arg_data.hidden, arg_data.identity,
arg_data.passphrase, arg_data.previous_passphrase,
arg_data.wpspin, arg_data.previous_wpspin,
arg_data.login);
return NULL;
error:
return g_dbus_create_error(msg, CONNMAN_ERROR ".Canceled", NULL);
}
static DBusMessage *agent_request_input(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct agent_data *request = user_data;
DBusMessageIter iter, dict;
char *service, *str;
if (handle_message(message, request, agent_request_input) == false)
return NULL;
dbus_message_iter_init(message, &iter);
dbus_message_iter_get_basic(&iter, &str);
service = strip_path(str);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &dict);
__connmanctl_save_rl();
if (strcmp(request->interface, AGENT_INTERFACE) == 0)
fprintf(stdout, "Agent RequestInput %s\n", service);
else
fprintf(stdout, "VPN Agent RequestInput %s\n", service);
__connmanctl_dbus_print(&dict, " ", " = ", "\n");
fprintf(stdout, "\n");
parse_agent_request(request, &iter);
request->reply = dbus_message_new_method_return(message);
dbus_message_iter_init_append(request->reply, &request->iter);
dbus_message_iter_open_container(&request->iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
&request->dict);
request_input_next(request);
return NULL;
}
static void iter_append_iter(DBusMessageIter *base, DBusMessageIter *iter)
{
int type;
type = dbus_message_iter_get_arg_type(iter);
if (dbus_type_is_basic(type)) {
const void *value;
dbus_message_iter_get_basic(iter, &value);
dbus_message_iter_append_basic(base, type, &value);
} else if (dbus_type_is_container(type)) {
DBusMessageIter iter_sub, base_sub;
char *sig;
dbus_message_iter_recurse(iter, &iter_sub);
switch (type) {
case DBUS_TYPE_ARRAY:
case DBUS_TYPE_VARIANT:
sig = dbus_message_iter_get_signature(&iter_sub);
break;
default:
sig = NULL;
break;
}
dbus_message_iter_open_container(base, type, sig, &base_sub);
if (sig != NULL)
dbus_free(sig);
while (dbus_message_iter_get_arg_type(&iter_sub) !=
DBUS_TYPE_INVALID) {
iter_append_iter(&base_sub, &iter_sub);
dbus_message_iter_next(&iter_sub);
}
dbus_message_iter_close_container(base, &base_sub);
}
}
bool dsme_dbus_message_get_variant_bool(const DsmeDbusMessage* msg)
{
// FIXME: caller can't tell apart FALSE from error
dbus_bool_t b = FALSE;
if( msg ) {
DBusMessageIter *iter = (DBusMessageIter *)&msg->iter;
DBusMessageIter subiter;
if( dsme_dbus_check_arg_type(iter, DBUS_TYPE_VARIANT) ) {
dbus_message_iter_recurse (iter, &subiter);
if( dsme_dbus_check_arg_type(&subiter, DBUS_TYPE_BOOLEAN) ) {
dbus_message_iter_get_basic(&subiter, &b);
}
}
dbus_message_iter_next(iter);
}
return b;
}
int
decode_triplet(DBusMessageIter *iter, const char **pkey, const char **pval, const char **ptype)
{
int err = -1;
DBusMessageIter memb;
if( dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRUCT )
{
dbus_message_iter_recurse(iter, &memb);
if( !decode_string(&memb, pkey) &&
!decode_string(&memb, pval) &&
!decode_string(&memb, ptype) )
{
dbus_message_iter_next(iter);
err = 0;
}
}
return err;
}
static gboolean adapter_changed(DBusConnection *conn,
DBusMessage *message, void *user_data)
{
const char *path = dbus_message_get_path(message);
struct connman_device *device;
DBusMessageIter iter, value;
const char *key;
DBG("path %s", path);
device = g_hash_table_lookup(bluetooth_devices, path);
if (device == NULL)
return TRUE;
if (dbus_message_iter_init(message, &iter) == FALSE)
return TRUE;
dbus_message_iter_get_basic(&iter, &key);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &value);
if (g_str_equal(key, "Powered") == TRUE) {
dbus_bool_t val;
dbus_message_iter_get_basic(&value, &val);
connman_device_set_powered(device, val);
if (val == TRUE)
check_pending_networks(path);
} else if (g_str_equal(key, "Discovering") == TRUE) {
dbus_bool_t val;
dbus_message_iter_get_basic(&value, &val);
connman_device_set_scanning(device, val);
} else if (g_str_equal(key, "Devices") == TRUE) {
check_networks(&value);
}
return TRUE;
}
static DBusMessage *register_endpoint(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct media_adapter *adapter = data;
DBusMessageIter args, props;
const char *sender, *path, *uuid;
gboolean delay_reporting = FALSE;
uint8_t codec;
uint8_t *capabilities;
int size = 0;
int err;
sender = dbus_message_get_sender(msg);
dbus_message_iter_init(msg, &args);
dbus_message_iter_get_basic(&args, &path);
dbus_message_iter_next(&args);
if (media_adapter_find_endpoint(adapter, sender, path, NULL) != NULL)
return btd_error_already_exists(msg);
dbus_message_iter_recurse(&args, &props);
if (dbus_message_iter_get_arg_type(&props) != DBUS_TYPE_DICT_ENTRY)
return btd_error_invalid_args(msg);
if (parse_properties(&props, &uuid, &delay_reporting, &codec,
&capabilities, &size) < 0)
return btd_error_invalid_args(msg);
if (media_endpoint_create(adapter, sender, path, uuid, delay_reporting,
codec, capabilities, size, &err) == NULL) {
if (err == -EPROTONOSUPPORT)
return btd_error_not_supported(msg);
else
return btd_error_invalid_args(msg);
}
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static gboolean has_hfp_ag_uuid(DBusMessageIter *array)
{
DBusMessageIter value;
if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
return FALSE;
dbus_message_iter_recurse(array, &value);
while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {
const char *uuid;
dbus_message_iter_get_basic(&value, &uuid);
if (g_str_equal(uuid, HFP_AG_UUID) == TRUE)
return TRUE;
dbus_message_iter_next(&value);
}
return FALSE;
}
static dbus_bool_t has_pan(DBusMessageIter *array)
{
DBusMessageIter value;
if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
return FALSE;
dbus_message_iter_recurse(array, &value);
while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {
const char *uuid;
dbus_message_iter_get_basic(&value, &uuid);
if (g_strcmp0(uuid, UUID_NAP) == 0)
return TRUE;
dbus_message_iter_next(&value);
}
return FALSE;
}
static connman_bool_t proxy_get_nap(GDBusProxy *proxy)
{
DBusMessageIter iter, value;
if (proxy == NULL)
return FALSE;
if (g_dbus_proxy_get_property(proxy, "UUIDs", &iter) == FALSE)
return FALSE;
dbus_message_iter_recurse(&iter, &value);
while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {
const char *uuid;
dbus_message_iter_get_basic(&value, &uuid);
if (strcmp(uuid, BLUETOOTH_PAN_NAP) == 0)
return TRUE;
dbus_message_iter_next(&value);
}
return FALSE;
}
gboolean whiteboard_cmd_iter_get(WhiteBoardCmdIter* iter, const gchar** key,
const gchar** value)
{
gchar* key_arg = NULL;
gchar* value_arg = NULL;
gint arg_type = 0;
DBusMessageIter temp_iter;
whiteboard_log_debug_fb();
g_return_val_if_fail(iter != NULL, FALSE);
/* Make a copy of the DBusMessageIter so that we don't move the
original iter until whiteboard_cmd_iter_next is called. */
temp_iter = iter->iter;
/* There should be a key string next in line */
arg_type = dbus_message_iter_get_arg_type(&temp_iter);
if (arg_type == DBUS_TYPE_STRING)
dbus_message_iter_get_basic(&temp_iter, &key_arg);
dbus_message_iter_next(&temp_iter);
/* And now there should be the value string for the key */
arg_type = dbus_message_iter_get_arg_type(&temp_iter);
if (arg_type == DBUS_TYPE_STRING)
dbus_message_iter_get_basic(&temp_iter, &value_arg);
if (key != NULL)
*key = key_arg;
if (value != NULL)
*value = value_arg;
whiteboard_log_debug_fe();
return ((key == NULL || *key != NULL) &&
(value == NULL || *value != NULL)) ? TRUE : FALSE;
}
static GSList *get_user_networks(DBusMessageIter *array)
{
DBusMessageIter entry;
GSList *list = NULL;
dbus_message_iter_recurse(array, &entry);
while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
const char *val;
struct vpn_route *route;
dbus_message_iter_get_basic(&entry, &val);
route = parse_user_route(val);
if (route != NULL)
list = g_slist_prepend(list, route);
dbus_message_iter_next(&entry);
}
return list;
}
void CUDisks2Provider::ParseDriveProperty(Drive *drive, const char *key, DBusMessageIter *varIter)
{
switch (dbus_message_iter_get_arg_type(varIter))
{
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t value;
if (strcmp(key, "Removable") == 0)
{
dbus_message_iter_get_basic(varIter, &value);
drive->m_isRemovable = static_cast<bool>(value);
}
break;
}
case DBUS_TYPE_ARRAY:
{
DBusMessageIter arrIter;
if (strcmp(key, "MediaCompatibility") == 0)
{
dbus_message_iter_recurse(varIter, &arrIter);
while (dbus_message_iter_get_arg_type(&arrIter) == DBUS_TYPE_STRING)
{
const char *compatibility;
dbus_message_iter_get_basic(&arrIter, &compatibility);
drive->m_mediaCompatibility.push_back(std::string(compatibility));
dbus_message_iter_next(&arrIter);
}
}
break;
}
default:
break;
}
}
