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