static int get_all_properties_by_unit_path(DBusConnection *conn, const char *unit_path, int(*callback)(const char *name, const char *value, void *arg), void *cbarg) { int ret = 1; DBusMessage *msg = NULL; DBusPendingCall *pending = NULL; msg = dbus_message_new_method_call( "org.freedesktop.systemd1", unit_path, "org.freedesktop.DBus.Properties", "GetAll" ); if (msg == NULL) { dI("Failed to create dbus_message via dbus_message_new_method_call!\n"); goto cleanup; } DBusMessageIter args, property_iter; const char *interface = "org.freedesktop.systemd1.Unit"; dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &interface)) { dI("Failed to append interface '%s' string parameter to dbus message!\n", interface); goto cleanup; } if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) { dI("Failed to send message via dbus!\n"); goto cleanup; } if (pending == NULL) { dI("Invalid dbus pending call!\n"); goto cleanup; } dbus_connection_flush(conn); dbus_message_unref(msg); msg = NULL; dbus_pending_call_block(pending); msg = dbus_pending_call_steal_reply(pending); if (msg == NULL) { dI("Failed to steal dbus pending call reply.\n"); goto cleanup; } dbus_pending_call_unref(pending); pending = NULL; if (!dbus_message_iter_init(msg, &args)) { dI("Failed to initialize iterator over received dbus message.\n"); goto cleanup; } if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY && dbus_message_iter_get_element_type(&args) != DBUS_TYPE_DICT_ENTRY) { dI("Expected array of dict_entry argument in reply. Instead received: %s.\n", dbus_message_type_to_string(dbus_message_iter_get_arg_type(&args))); goto cleanup; } dbus_message_iter_recurse(&args, &property_iter); do { DBusMessageIter dict_entry, value_variant; dbus_message_iter_recurse(&property_iter, &dict_entry); if (dbus_message_iter_get_arg_type(&dict_entry) != DBUS_TYPE_STRING) { dI("Expected string as key in dict_entry. Instead received: %s.\n", dbus_message_type_to_string(dbus_message_iter_get_arg_type(&dict_entry))); goto cleanup; } _DBusBasicValue value; dbus_message_iter_get_basic(&dict_entry, &value); char *property_name = oscap_strdup(value.str); if (dbus_message_iter_next(&dict_entry) == false) { dW("Expected another field in dict_entry."); oscap_free(property_name); goto cleanup; } if (dbus_message_iter_get_arg_type(&dict_entry) != DBUS_TYPE_VARIANT) { dI("Expected variant as value in dict_entry. Instead received: %s.\n", dbus_message_type_to_string(dbus_message_iter_get_arg_type(&dict_entry))); oscap_free(property_name); goto cleanup; } dbus_message_iter_recurse(&dict_entry, &value_variant); int cbret = 0; const int arg_type = dbus_message_iter_get_arg_type(&value_variant); // DBUS_TYPE_ARRAY is a special case, we report each element as one value entry if (arg_type == DBUS_TYPE_ARRAY) { DBusMessageIter array; dbus_message_iter_recurse(&value_variant, &array); do { char *element = dbus_value_to_string(&array); if (element == NULL) continue; const int elementcbret = callback(property_name, element, cbarg); if (elementcbret > cbret) cbret = elementcbret; oscap_free(element); } while (dbus_message_iter_next(&array)); } else { char *property_value = dbus_value_to_string(&value_variant); cbret = callback(property_name, property_value, cbarg); oscap_free(property_value); } oscap_free(property_name); if (cbret != 0) { goto cleanup; } } while (dbus_message_iter_next(&property_iter)); dbus_message_unref(msg); msg = NULL; ret = 0; cleanup: if (pending != NULL) dbus_pending_call_unref(pending); if (msg != NULL) dbus_message_unref(msg); return ret; }
void notify(DBusMessage * dmsg) { DBusMessage *reply; DBusMessageIter args; DBusMessageIter hints; DBusMessageIter hint; char *hint_name; int i; int id; const char *appname = NULL; const char *summary = NULL; const char *body = NULL; const char *icon = NULL; const char *fgcolor = NULL; const char *bgcolor = NULL; int urgency = 1; int progress = -1; notification *n = malloc(sizeof(notification)); dbus_uint32_t replaces_id = 0; dbus_int32_t expires = -1; dbus_serial++; dbus_message_iter_init(dmsg, &args); _extract_basic(DBUS_TYPE_STRING, &args, &appname); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_UINT32, &args, &replaces_id); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_STRING, &args, &icon); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_STRING, &args, &summary); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_STRING, &args, &body); dbus_message_iter_next(&args); dbus_message_iter_next(&args); dbus_message_iter_recurse(&args, &hints); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_INT32, &args, &expires); while (dbus_message_iter_get_arg_type(&hints) != DBUS_TYPE_INVALID) { dbus_message_iter_recurse(&hints, &hint); while (dbus_message_iter_get_arg_type(&hint) != DBUS_TYPE_INVALID) { if (dbus_message_iter_get_arg_type(&hint) != DBUS_TYPE_STRING) { dbus_message_iter_next(&hint); continue; } dbus_message_iter_get_basic(&hint, &hint_name); _extract_hint(DBUS_TYPE_BYTE, "urgency", hint_name, &hint, &urgency); _extract_hint(DBUS_TYPE_STRING, "fgcolor", hint_name, &hint, &fgcolor); _extract_hint(DBUS_TYPE_STRING, "bgcolor", hint_name, &hint, &bgcolor); _extract_hint(DBUS_TYPE_INT32, "value", hint_name, &hint, &progress); if (!progress) _extract_hint(DBUS_TYPE_UINT32, "value", hint_name, &hint, &progress); dbus_message_iter_next(&hint); } dbus_message_iter_next(&hints); } if (expires > 0) { /* do some rounding */ expires = (expires + 500) / 1000; if (expires < 1) { expires = 1; } } n->appname = appname != NULL ? strdup(appname) : ""; n->summary = summary != NULL ? strdup(summary) : ""; n->body = body != NULL ? strdup(body) : ""; n->icon = icon != NULL ? strdup(icon) : ""; n->timeout = expires; n->progress = (progress < 0 || progress > 100) ? 0 : progress + 1; n->urgency = urgency; n->dbus_client = strdup(dbus_message_get_sender(dmsg)); for (i = 0; i < ColLast; i++) { n->color_strings[i] = NULL; } n->color_strings[ColFG] = fgcolor == NULL ? NULL : strdup(fgcolor); n->color_strings[ColBG] = bgcolor == NULL ? NULL : strdup(bgcolor); id = init_notification(n, replaces_id); if (id > 0) map_win(); reply = dbus_message_new_method_return(dmsg); dbus_message_iter_init_append(reply, &args); dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &id); dbus_connection_send(dbus_conn, reply, &dbus_serial); dbus_message_unref(reply); }
int man_portal_sta_get_by_ip(portal_user_info_s *station, unsigned int *next_addr) { int ret; DBusMessage *query, *reply; DBusMessageIter iter; DBusMessageIter iter_array; DBusError err; int index = 0; char BUSNAME[PATH_LEN]; char OBJPATH[PATH_LEN]; char INTERFACE[PATH_LEN]; char *ch; index = 0; ReInitDbusPath(index,ASD_DBUS_BUSNAME,BUSNAME); ReInitDbusPath(index,ASD_DBUS_SECURITY_OBJPATH,OBJPATH); ReInitDbusPath(index,ASD_DBUS_SECURITY_INTERFACE,INTERFACE); dbus_error_init(&err); query = dbus_message_new_method_call(BUSNAME,OBJPATH,INTERFACE,ASD_DBUS_SECURITY_METHOD_GET_PORTAL_STA); dbus_message_iter_init_append (query, &iter); dbus_message_iter_append_basic ( &iter, DBUS_TYPE_UINT32, &station->ipaddr); reply = dbus_connection_send_with_reply_and_block (dcli_dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply) { if (dbus_error_is_set(&err)) { dbus_error_free(&err); } return CMD_FAILURE; } dbus_message_iter_init(reply,&iter); dbus_message_iter_get_basic(&iter,&ret); if(ret != CMD_SUCCESS){ return ret; } if(ASD_DBUS_SUCCESS == ret) { dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,&station->state); dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,&ch); memset(station->id, 0, NAME_LEN+1); strncpy(station->id, ch, NAME_LEN); dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,&(station->ipaddr)); dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,&(station->netif_index)); dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,next_addr); } return ret; }
static void show_notification (DB_playItem_t *track) { char title[1024]; char content[1024]; char format[200]; char format_content[200]; deadbeef->conf_get_str ("notify.format", NOTIFY_DEFAULT_TITLE, format, sizeof (format)); deadbeef->conf_get_str ("notify.format_content", NOTIFY_DEFAULT_CONTENT, format_content, sizeof (format_content)); deadbeef->pl_format_title (track, -1, title, sizeof (title), -1, format); deadbeef->pl_format_title (track, -1, content, sizeof (content), -1, format_content); // escape & // char esc_title[1024]; char esc_content[1024]; // esc_xml (title, esc_title, sizeof (esc_title)); esc_xml (content, esc_content, sizeof (esc_content)); DBusMessage *msg = dbus_message_new_method_call (E_NOTIFICATION_BUS_NAME, E_NOTIFICATION_PATH, E_NOTIFICATION_INTERFACE, "Notify"); deadbeef->pl_lock (); if (last_track) { deadbeef->pl_item_unref (last_track); last_track = 0; } last_track = track; deadbeef->pl_item_ref (last_track); request_timer = time (NULL); deadbeef->pl_unlock (); const char *v_appname = "DeaDBeeF"; dbus_uint32_t v_id = 0; char *v_iconname = NULL; if (deadbeef->conf_get_int("notify.albumart", 0) && artwork_plugin) { deadbeef->pl_lock (); const char *album = deadbeef->pl_find_meta (track, "album"); const char *artist = deadbeef->pl_find_meta (track, "artist"); const char *fname = deadbeef->pl_find_meta (track, ":URI"); if (!album || !*album) { album = deadbeef->pl_find_meta (track, "title"); } v_iconname = artwork_plugin->get_album_art (fname, artist, album, deadbeef->conf_get_int ("notify.albumart_size", 64), cover_avail_callback, NULL); deadbeef->pl_unlock (); } if (!v_iconname) { v_iconname = strdup ("deadbeef"); } const char *v_summary = title; const char *v_body = esc_content; dbus_int32_t v_timeout = -1; dbus_message_append_args (msg , DBUS_TYPE_STRING, &v_appname , DBUS_TYPE_UINT32, &replaces_id , DBUS_TYPE_STRING, &v_iconname , DBUS_TYPE_STRING, &v_summary , DBUS_TYPE_STRING, &v_body , DBUS_TYPE_INVALID ); DBusMessageIter iter, sub; // actions dbus_message_iter_init_append(msg, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub); dbus_message_iter_close_container(&iter, &sub); // hints dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub); dbus_message_iter_close_container(&iter, &sub); dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &v_timeout); intptr_t tid = 0; if ((tid=deadbeef->thread_start(notify_thread, msg)) != 0) { dbus_message_ref (msg); deadbeef->thread_detach (tid); } dbus_message_unref (msg); if (v_iconname) { free (v_iconname); } }
void ofono_ussd_notify(struct ofono_ussd *ussd, int status, int dcs, const unsigned char *data, int data_len) { DBusConnection *conn = ofono_dbus_get_connection(); const char *ussdstr = "USSD"; char *utf8_str = NULL; const char *str; const char sig[] = { DBUS_TYPE_STRING, 0 }; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter variant; DBG("status: %d %s, state: %d %s", status, ussd_status_name(status), ussd->state, ussd_state_name(ussd->state)); if (ussd->req && (status == OFONO_USSD_STATUS_NOTIFY || status == OFONO_USSD_STATUS_TERMINATED || status == OFONO_USSD_STATUS_TIMED_OUT || status == OFONO_USSD_STATUS_NOT_SUPPORTED)) { ussd_request_finish(ussd, ussd_status_to_failure_code(status), dcs, data, data_len); ussd_change_state(ussd, USSD_STATE_IDLE); return; } if (status == OFONO_USSD_STATUS_TERMINATED) { ussd_change_state(ussd, USSD_STATE_IDLE); if (ussd->pending == NULL) return; reply = __ofono_error_network_terminated(ussd->pending); goto out; } if (status == OFONO_USSD_STATUS_NOT_SUPPORTED) { ussd_change_state(ussd, USSD_STATE_IDLE); if (ussd->pending == NULL) return; reply = __ofono_error_not_supported(ussd->pending); goto out; } if (status == OFONO_USSD_STATUS_TIMED_OUT) { ussd_change_state(ussd, USSD_STATE_IDLE); if (ussd->pending == NULL) return; reply = __ofono_error_timed_out(ussd->pending); goto out; } if (data && data_len > 0) utf8_str = ussd_decode(dcs, data_len, data); str = utf8_str; /* TODO: Rework this in the Agent framework */ if (ussd->state == USSD_STATE_ACTIVE) { reply = dbus_message_new_method_return(ussd->pending); if (str == NULL) str = ""; dbus_message_iter_init_append(reply, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &ussdstr); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sig, &variant); dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &str); dbus_message_iter_close_container(&iter, &variant); if (status == OFONO_USSD_STATUS_ACTION_REQUIRED) ussd_change_state(ussd, USSD_STATE_USER_ACTION); else ussd_change_state(ussd, USSD_STATE_IDLE); } else if (ussd->state == USSD_STATE_RESPONSE_SENT) { reply = dbus_message_new_method_return(ussd->pending); if (str == NULL) str = ""; dbus_message_append_args(reply, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID); if (status == OFONO_USSD_STATUS_ACTION_REQUIRED) ussd_change_state(ussd, USSD_STATE_USER_ACTION); else ussd_change_state(ussd, USSD_STATE_IDLE); } else if (ussd->state == USSD_STATE_IDLE) { const char *signal_name; const char *path = __ofono_atom_get_path(ussd->atom); int new_state; if (status == OFONO_USSD_STATUS_ACTION_REQUIRED) { new_state = USSD_STATE_USER_ACTION; signal_name = "RequestReceived"; } else { new_state = USSD_STATE_IDLE; signal_name = "NotificationReceived"; } if (str == NULL) str = ""; g_dbus_emit_signal(conn, path, OFONO_SUPPLEMENTARY_SERVICES_INTERFACE, signal_name, DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID); ussd_change_state(ussd, new_state); goto free; } else { ofono_error("Received an unsolicited USSD but can't handle."); DBG("USSD is: status: %d, %s", status, str); goto free; } out: g_dbus_send_message(conn, reply); dbus_message_unref(ussd->pending); ussd->pending = NULL; free: g_free(utf8_str); }
int main(int argc, char** args) { DBusMessage* msg; DBusMessageIter dmargs; DBusPendingCall *pending; DBusError err; DBusConnection* conn; int ret; char* param = "Hello"; /* Init the dbus_error */ dbus_error_init(&err); /* Connect to the bus */ conn = dbus_bus_get(DBUS_BUS_SESSION, &err); if (dbus_error_is_set(&err)) { LOGE("Connection error: %s\n", err.message); dbus_error_free(&err); } if (conn == NULL) { return -1; } /* Request a name on the bus */ ret = dbus_bus_request_name(conn, TEST_DBUS_CLIENT_NAME, DBUS_NAME_FLAG_REPLACE_EXISTING, &err); if (dbus_error_is_set(&err)) { LOGE("Name error: %s\n", err.message); dbus_error_free(&err); } if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) { return -1; } /* call server */ msg = dbus_message_new_method_call(TEST_DBUS_SERVER_NAME, TEST_DBUS_SERVER_OBJ, TEST_METHOD_TYPE, TEST_METHOD); if (msg == NULL) { LOGE("Message null\n"); return -1; } dbus_message_iter_init_append(msg, &dmargs); if (!dbus_message_iter_append_basic(&dmargs, DBUS_TYPE_STRING, ¶m)) { LOGE("OOM\n"); return -1; } if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) { LOGE("OOM\n"); return -1; } if (pending == NULL) { LOGE("Pending call null\n"); return -1; } dbus_connection_flush(conn); LOGE("Message sent\n"); dbus_message_unref(msg); /* Close the dbus connection */ dbus_connection_close(conn); return 0; }
bool dbus_proc_property(const char *method, DBusMessage *msg, DBusMessage *reply, DBusError *error, struct gsh_dbus_interface **interfaces) { const char *interface; const char *prop_name; bool retval = false; struct gsh_dbus_interface **iface; struct gsh_dbus_prop **prop; DBusMessageIter reply_iter; dbus_message_iter_init_append(reply, &reply_iter); if (strcmp(method, "GetAll") == 0) { DBusMessageIter getall_dict, dict_entry, val_iter; if (!dbus_message_get_args (msg, error, DBUS_TYPE_STRING, &interface, DBUS_TYPE_INVALID)) goto err_out; iface = lookup_interface(interface, interfaces, error); if (*iface == NULL) goto err_out; if (!dbus_message_iter_open_container (&reply_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, &getall_dict)) goto getall_err; for (prop = (*iface)->props; prop && *prop; prop++) { prop_name = (*prop)->name; if ((*prop)->access == DBUS_PROP_READ || (*prop)->access == DBUS_PROP_READWRITE) { if (!dbus_message_iter_open_container (&getall_dict, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry)) goto getall_err; if (!dbus_message_iter_append_basic (&dict_entry, DBUS_TYPE_STRING, &prop_name)) goto getall_err; if (!dbus_message_iter_open_container (&dict_entry, DBUS_TYPE_VARIANT, (*prop)->type, &val_iter)) goto getall_err; if (!(*prop)->get(&val_iter)) goto getall_err; if (!dbus_message_iter_close_container (&dict_entry, &val_iter)) goto getall_err; if (!dbus_message_iter_close_container (&getall_dict, &dict_entry)) goto getall_err; } else { dbus_set_error(error, DBUS_ERROR_PROPERTY_READ_ONLY, "%s of %s from %s (write only?)", method, prop_name, interface); /** @todo@ check does write only make sense?? */ goto err_out; } } if (!dbus_message_iter_close_container (&reply_iter, &getall_dict)) goto getall_err; return true; /* DONE! */ } else if (strcmp(method, "Get") == 0) { if (!dbus_message_get_args (msg, error, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, &prop_name, DBUS_TYPE_INVALID)) goto err_out; iface = lookup_interface(interface, interfaces, error); if (*iface == NULL) goto err_out; prop = lookup_property(prop_name, iface, error); if (*prop == NULL) goto err_out; if ((*prop)->access == DBUS_PROP_READ || (*prop)->access == DBUS_PROP_READWRITE) { DBusMessageIter variant_iter; if (!dbus_message_iter_open_container (&reply_iter, DBUS_TYPE_VARIANT, (*prop)->type, &variant_iter)) { dbus_set_error_const(error, DBUS_ERROR_FAILED, "Couldn't open Get container"); goto err_out; } retval = (*prop)->get(&variant_iter); if (retval == false || !dbus_message_iter_close_container(&reply_iter, &variant_iter)) { dbus_set_error_const(error, DBUS_ERROR_FAILED, "Couldn't close Get container"); goto err_out; } } else { dbus_set_error(error, DBUS_ERROR_PROPERTY_READ_ONLY, "%s of %s from %s (write only?)", method, prop_name, interface); /** @todo@ check does write only make sense?? */ goto err_out; } return true; /* DONE! */ } else if (strcmp(method, "Set") == 0) { DBusMessageIter iter_args; if (!dbus_message_iter_init(msg, &iter_args) || dbus_message_iter_get_arg_type(&iter_args) != DBUS_TYPE_STRING) { goto invalid_args; } dbus_message_iter_get_basic(&iter_args, &interface); if (!dbus_message_iter_next(&iter_args) || dbus_message_iter_get_arg_type(&iter_args) != DBUS_TYPE_STRING) { goto invalid_args; } dbus_message_iter_get_basic(&iter_args, &prop_name); if (!dbus_message_iter_next(&iter_args) || dbus_message_iter_get_arg_type(&iter_args) != DBUS_TYPE_VARIANT || dbus_message_iter_has_next(&iter_args)) { goto invalid_args; } iface = lookup_interface(interface, interfaces, error); if (*iface == NULL) goto err_out; prop = lookup_property(prop_name, iface, error); if (*prop == NULL) goto err_out; if ((*prop)->access == DBUS_PROP_WRITE || (*prop)->access == DBUS_PROP_READWRITE) { DBusMessageIter arg; dbus_message_iter_recurse(&iter_args, &arg); return (*prop)->set(&arg); /* DONE! */ } else { dbus_set_error(error, DBUS_ERROR_PROPERTY_READ_ONLY, "%s of %s from %s", method, prop_name, interface); goto err_out; } } else { dbus_set_error(error, DBUS_ERROR_UNKNOWN_METHOD, "Requested method: %s", method); } return retval; getall_err: dbus_set_error(error, DBUS_ERROR_FAILED, "GetAll container failure"); goto err_out; invalid_args: dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "Method %s", method); err_out: return retval; }
static void mediaplayer_register(const char *id) { DBusMessage* msg; DBusMessageIter args, element; DBusPendingCall* pending; char *name=NULL; static const char *prop="Identity"; struct MEDIAPLAYER **mp; char player[256]; for(mp=&mediaplayer; *mp; mp=&((*mp)->next)) { if(!strcmp(id, (*mp)->id)) return; } sprintf(player, "%s.%s", mpris.interface, id); if(!(msg=dbus_message_new_method_call(player, mpris.object, dbus.interface_prop, "Get"))) goto do_register; dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mpris.interface)) { dbus_message_unref(msg); goto do_register; } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &prop)) { dbus_message_unref(msg); goto do_register; } if(!dbus_connection_send_with_reply(dbus.session.connection, msg, &pending, -1)) { dbus_message_unref(msg); goto do_register; } if(!pending) { dbus_message_unref(msg); goto do_register; } dbus_connection_flush(dbus.session.connection); dbus_message_unref(msg); dbus_pending_call_block(pending); if (!(msg=dbus_pending_call_steal_reply(pending))) { dbus_pending_call_unref(pending); goto do_register; } dbus_pending_call_unref(pending); if(!dbus_message_iter_init(msg, &args)) { dbus_message_unref(msg); goto do_register; } else if(dbus_message_iter_get_arg_type(&args)!=DBUS_TYPE_VARIANT) { dbus_message_unref(msg); goto do_register; } dbus_message_iter_recurse(&args, &element); dbus_message_iter_get_basic(&element, &name); dbus_message_unref(msg); do_register: *mp=malloc(sizeof(struct MEDIAPLAYER)); (*mp)->id=malloc(strlen(id)+1); if(name) { (*mp)->name=malloc(strlen(name)+1); strcpy((void *) (*mp)->name, name); } else (*mp)->name=NULL; (*mp)->next=NULL; strcpy((void *) (*mp)->id, id); }
static void unregister_profile_setup(DBusMessageIter *iter, void *user_data) { const char *path = PROFILE_PATH; dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path); }
static void append_arg (DBusMessageIter *iter, int type, const char *value) { dbus_uint16_t uint16; dbus_int16_t int16; dbus_uint32_t uint32; dbus_int32_t int32; dbus_uint64_t uint64; dbus_int64_t int64; double d; unsigned char byte; dbus_bool_t v_BOOLEAN; /* FIXME - we are ignoring OOM returns on all these functions */ switch (type) { case DBUS_TYPE_BYTE: byte = strtoul (value, NULL, 0); dbus_message_iter_append_basic (iter, DBUS_TYPE_BYTE, &byte); break; case DBUS_TYPE_DOUBLE: d = strtod (value, NULL); dbus_message_iter_append_basic (iter, DBUS_TYPE_DOUBLE, &d); break; case DBUS_TYPE_INT16: int16 = strtol (value, NULL, 0); dbus_message_iter_append_basic (iter, DBUS_TYPE_INT16, &int16); break; case DBUS_TYPE_UINT16: uint16 = strtoul (value, NULL, 0); dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT16, &uint16); break; case DBUS_TYPE_INT32: int32 = strtol (value, NULL, 0); dbus_message_iter_append_basic (iter, DBUS_TYPE_INT32, &int32); break; case DBUS_TYPE_UINT32: uint32 = strtoul (value, NULL, 0); dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT32, &uint32); break; case DBUS_TYPE_INT64: int64 = strtoll (value, NULL, 0); dbus_message_iter_append_basic (iter, DBUS_TYPE_INT64, &int64); break; case DBUS_TYPE_UINT64: uint64 = strtoull (value, NULL, 0); dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT64, &uint64); break; case DBUS_TYPE_STRING: dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &value); break; case DBUS_TYPE_OBJECT_PATH: dbus_message_iter_append_basic (iter, DBUS_TYPE_OBJECT_PATH, &value); break; case DBUS_TYPE_BOOLEAN: if (strcmp (value, "true") == 0) { v_BOOLEAN = TRUE; dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &v_BOOLEAN); } else if (strcmp (value, "false") == 0) { v_BOOLEAN = FALSE; dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &v_BOOLEAN); } else { fprintf (stderr, "%s: Expected \"true\" or \"false\" instead of \"%s\"\n", appname, value); exit (1); } break; default: fprintf (stderr, "%s: Unsupported data type %c\n", appname, (char) type); exit (1); } }
static struct TRACK mediaplayer_get_track(const char *id) { int current_type; DBusMessage* msg; DBusMessageIter args, array, dict, element, var, artist; DBusPendingCall* pending; static const char *prop="Metadata"; char player[256]; struct TRACK track={ "Unknown", "Unknown", "Unknown", }; sprintf(player, "%s%s", mpris.base, id); if(!(msg=dbus_message_new_method_call(player, mpris.object, dbus.interface_prop, "Get"))) return track; dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mpris.interface_player)) { dbus_message_unref(msg); return track; } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &prop)) { dbus_message_unref(msg); return track; } if(!dbus_connection_send_with_reply(dbus.session.connection, msg, &pending, -1)) { dbus_message_unref(msg); return track; } if(!pending) { dbus_message_unref(msg); return track; } dbus_connection_flush(dbus.session.connection); dbus_message_unref(msg); dbus_pending_call_block(pending); if(!(msg=dbus_pending_call_steal_reply(pending))) { dbus_pending_call_unref(pending); return track; } dbus_pending_call_unref(pending); if(!dbus_message_iter_init(msg, &args)) { dbus_message_unref(msg); return track; } if(dbus_message_iter_get_arg_type(&args)!=DBUS_TYPE_VARIANT) { dbus_message_unref(msg); return track; } dbus_message_iter_recurse(&args, &array); if(dbus_message_iter_get_arg_type(&array)!=DBUS_TYPE_ARRAY) { dbus_message_unref(msg); return track; } for(dbus_message_iter_recurse(&array, &dict); (current_type=dbus_message_iter_get_arg_type(&dict))!=DBUS_TYPE_INVALID; dbus_message_iter_next(&dict)) { char *element_key, *element_value; int element_type; dbus_message_iter_recurse(&dict, &element); if(dbus_message_iter_get_arg_type(&element)!=DBUS_TYPE_STRING) continue; dbus_message_iter_get_basic(&element, &element_key); dbus_message_iter_next(&element); if(dbus_message_iter_get_arg_type(&element)!=DBUS_TYPE_VARIANT) continue; dbus_message_iter_recurse(&element, &var); element_type=dbus_message_iter_get_arg_type(&var); if(element_type==DBUS_TYPE_STRING) { dbus_message_iter_get_basic(&var, &element_value); if(!strcmp(element_key, "xesam:album")) snprintf(track.album, TRACK_ELEMENT_LENGTH, "%s", element_value); else if(!strcmp(element_key, "xesam:title")) snprintf(track.title, TRACK_ELEMENT_LENGTH, "%s", element_value); } else if(element_type==DBUS_TYPE_ARRAY) { /*just handle one artist for now*/ dbus_message_iter_recurse(&var, &artist); if(dbus_message_iter_get_arg_type(&artist)!=DBUS_TYPE_STRING) continue; dbus_message_iter_get_basic(&artist, &element_value); if(!strcmp(element_key, "xesam:artist")) snprintf(track.artist, TRACK_ELEMENT_LENGTH, "%s", element_value); } } dbus_message_unref(msg); return track; }
DBusHandlerResult handle_dbus_message( DBusConnection *connection, DBusMessage *message, void *data ) { int eax; int esi; int msg_type; switch ( msg_type ) { default: break; case 4: break; case 3: break; case 2: break; case 1: { char *method_name; char *interface_name; if ( dbus_message_get_member( &message ) ) { if ( interface_name ) { /* phantom */ size_t __s1_len; /* phantom */ size_t __s2_len; strcmp( "org.seul.geda.pcb", interface_name ); if ( 1 ) { /* phantom */ size_t __s1_len; /* phantom */ size_t __s2_len; method_name[0] = dbus_message_get_member( &message ); strcmp( "GetFilename", dbus_message_get_member( &message ) ); if ( !1 ) { __fprintf_chk( stderr, 1, "pcb_dbus: Interface '%s' has no method '%s'\n", dbus_message_get_interface( &message ), ebp_184 ); return 1; } else { if ( dbus_message_new_method_return( &message ) ) { dbus_message_iter_init_append( dbus_message_new_method_return( &message ), ebp_112 ); if ( PCB->Filename ) { if ( lrealpath( &PCB->Filename ) == 0 ) goto B38; else { if ( dbus_message_iter_append_basic( ebp_112, 115, ebp_32 ) ) { free( ebp_32 ); } else { __fprintf_chk( stderr, 1, "pcb_dbus: Couldn't append return filename string to message reply, Out Of Memory!\n" ); free( ebp_32 ); dbus_message_unref( &ebx ); return 0; } } } else { } B38:; if ( calloc( 1, 1 ) ) { } else { __fprintf_chk( stderr, 1, ebp_192, ebp_192 ); } } else { } } } else { /* phantom */ size_t __s1_len; /* phantom */ size_t __s2_len; strcmp( "org.seul.geda.pcb.actions", interface_name ); if ( 1 ) { /* phantom */ size_t __s1_len; /* phantom */ size_t __s2_len; method_name[0] = ebp_140; strcmp( "ExecAction", ebp_140 ); if ( !1 ) { __fprintf_chk( stderr, 1, "pcb_dbus: Interface '%s' has no method '%s'\n", dbus_message_get_interface( &message ), ebp_184 ); } else { dbus_error_init( ebp_56 ); if ( dbus_message_get_args( &message, ebp_56, 115, ebp_32, 97, (long long)115, (long long)( ebp_40 ) ) ) { hid_actionv( (char*)calloc( 1, 1 ), ebp_40, ebp_36 ); dbus_free_string_array( 0 ); if ( dbus_message_new_method_return( &message ) ) { dbus_message_iter_init_append( dbus_message_new_method_return( &message ), ebp_112 ); if ( dbus_message_iter_append_basic( ebp_112, 117, ebp_28 ) ) { } else { } } } else { __fprintf_chk( stderr, 1, "Failed to read method arguments\n" ); if ( 0 ) { dbus_free_string_array( 0 ); } } } } else { /* phantom */ size_t __s1_len; /* phantom */ size_t __s2_len; strcmp( "org.freedesktop.DBus.Introspectable", interface_name ); if ( !1 ) { __fprintf_chk( stderr, 1, "pcb_dbus: Interface '%s' was not recognised\n", dbus_message_iter_append_basic( ebp_112, 117, ebp_28 ) ); } { /* phantom */ size_t __s1_len; /* phantom */ size_t __s2_len; method_name[0] = dbus_message_get_member( &message ); strcmp( "Introspect", dbus_message_get_member( &message ) ); if ( !1 ) { __fprintf_chk( stderr, 1, "pcb_dbus: Interface '%s' has no method '%s'\n", dbus_message_get_interface( &message ), ebp_184 ); } else { if ( dbus_message_new_method_return( &message ) ) { dbus_message_iter_init_append( dbus_message_new_method_return( &message ), ebp_112 ); if ( dbus_message_iter_append_basic( ebp_112, 115, pcb_dbus_introspect_xml ) ) { if ( dbus_connection_send( &pcb_dbus_conn, (DBusMessage*)dbus_message_get_interface( &message ), 0 ) ) { dbus_message_unref( &ebx ); return 0; } } else { } } } } } } if ( dbus_connection_send( ebp_200, ebp_200, ebp_196 ) ) { dbus_message_unref( &ebx ); return 0; } } else { } } else { } } break; } __fprintf_chk( stderr, 1, ebp_192, ebp_192 ); }
gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy, const char *name, int type, const void *value, GDBusResultFunction function, void *user_data, GDBusDestroyFunction destroy) { struct set_property_data *data; GDBusClient *client; DBusMessage *msg; DBusMessageIter iter, variant; DBusPendingCall *call; char type_as_str[2]; if (proxy == NULL || name == NULL || value == NULL) return FALSE; if (dbus_type_is_basic(type) == FALSE) return FALSE; client = proxy->client; if (client == NULL) return FALSE; data = g_try_new0(struct set_property_data, 1); if (data == NULL) return FALSE; data->function = function; data->user_data = user_data; data->destroy = destroy; msg = dbus_message_new_method_call(client->service_name, proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "Set"); if (msg == NULL) { g_free(data); return FALSE; } type_as_str[0] = (char) type; type_as_str[1] = '\0'; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &proxy->interface); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, type_as_str, &variant); dbus_message_iter_append_basic(&variant, type, value); dbus_message_iter_close_container(&iter, &variant); if (g_dbus_send_message_with_reply(client->dbus_conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); g_free(data); return FALSE; } dbus_pending_call_set_notify(call, set_property_reply, data, g_free); dbus_pending_call_unref(call); dbus_message_unref(msg); return TRUE; }
/** * Listens for signals on the bus */ int sedbus_send_avc(DBusConnection* conn, char *avc) { DBusMessage* msg; DBusMessageIter args; DBusPendingCall* pending; char* reply = NULL; msg = dbus_message_new_method_call(BUSNAME, PATH, INTERFACE, "avc"); // method name if (NULL == msg) { fprintf(stderr, "Can't communicate with setroubleshootd\n"); return -1; } // append arguments dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &avc)) { fprintf(stderr, "Out Of Memory!\n"); return -1; } // send message and get a handle for a reply if ( ! dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout fprintf(stderr, "Out Of Memory!\n"); return -1; } if (NULL == pending) { fprintf(stderr, "Pending Call Null\n"); return -1; } dbus_connection_flush(conn); // free message dbus_message_unref(msg); // block until we receive a reply dbus_pending_call_block(pending); // get the reply message msg = dbus_pending_call_steal_reply(pending); if (NULL == msg) { fprintf(stderr, "Reply Null\n"); exit(1); } // free the pending message handle dbus_pending_call_unref(pending); // read the parameters if (!dbus_message_iter_init(msg, &args)) fprintf(stderr, "Message has no arguments!\n"); else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args)) fprintf(stderr, "Argument is not boolean!\n"); else dbus_message_iter_get_basic(&args, &reply); printf("Send: %s\n", avc); printf("Got Reply: %s\n", reply); // free reply and close connection dbus_message_unref(msg); return 0; }
/** * Call a method on a remote object */ void query(char* param) { DBusMessage* msg; DBusMessageIter args; DBusConnection* conn; DBusError err; DBusPendingCall* pending; int ret; dbus_bool_t stat; dbus_uint32_t level; printf("Calling remote method with %s\n", param); // initialiset the errors dbus_error_init(&err); // connect to the system bus and check for errors conn = dbus_bus_get(DBUS_BUS_SESSION, &err); if (dbus_error_is_set(&err)) { fprintf(stderr, "Connection Error (%s)\n", err.message); dbus_error_free(&err); } if (NULL == conn) { exit(1); } // request our name on the bus ret = dbus_bus_request_name(conn, "test.method.caller", DBUS_NAME_FLAG_REPLACE_EXISTING , &err); if (dbus_error_is_set(&err)) { fprintf(stderr, "Name Error (%s)\n", err.message); dbus_error_free(&err); } if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) { exit(1); } // create a new method call and check for errors msg = dbus_message_new_method_call("test.method.server", // target for the method call "/test/method/Object", // object to call on "test.method.Type", // interface to call on "Method"); // method name if (NULL == msg) { fprintf(stderr, "Message Null\n"); exit(1); } // append arguments dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, ¶m)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } // send message and get a handle for a reply if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (NULL == pending) { fprintf(stderr, "Pending Call Null\n"); exit(1); } dbus_connection_flush(conn); printf("Request Sent\n"); // free message dbus_message_unref(msg); // block until we recieve a reply dbus_pending_call_block(pending); // get the reply message msg = dbus_pending_call_steal_reply(pending); if (NULL == msg) { fprintf(stderr, "Reply Null\n"); exit(1); } // free the pending message handle dbus_pending_call_unref(pending); // read the parameters if (!dbus_message_iter_init(msg, &args)) fprintf(stderr, "Message has no arguments!\n"); else if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&args)) fprintf(stderr, "Argument is not boolean!\n"); else dbus_message_iter_get_basic(&args, &stat); if (!dbus_message_iter_next(&args)) fprintf(stderr, "Message has too few arguments!\n"); else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)) fprintf(stderr, "Argument is not int!\n"); else dbus_message_iter_get_basic(&args, &level); printf("Got Reply: %d, %d\n", stat, level); // free reply dbus_message_unref(msg); }
EINA_LIST_FOREACH(e_intl_language_list(), l, str) { DBG("language: %s", str); dbus_message_iter_append_basic(&arr, DBUS_TYPE_STRING, &str); }
static int add_device(DBusMessage *message, DBusMessage *reply, DBusError *error) { DBusMessageIter iter, reply_iter, subiter; InputOption *tmpo = NULL, *options = NULL; char *tmp = NULL; int ret, err; DeviceIntPtr dev = NULL; dbus_message_iter_init_append(reply, &reply_iter); if (!dbus_message_iter_init(message, &iter)) { ErrorF("[config/dbus] couldn't initialise iterator\n"); MALFORMED_MESSAGE(); } options = xcalloc(sizeof(*options), 1); if (!options) { ErrorF("[config/dbus] couldn't allocate option\n"); return BadAlloc; } options->key = xstrdup("_source"); options->value = xstrdup("client/dbus"); if (!options->key || !options->value) { ErrorF("[config/dbus] couldn't allocate first key/value pair\n"); ret = BadAlloc; goto unwind; } /* signature should be [ss][ss]... */ while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_ARRAY) { tmpo = xcalloc(sizeof(*tmpo), 1); if (!tmpo) { ErrorF("[config/dbus] couldn't allocate option\n"); ret = BadAlloc; goto unwind; } tmpo->next = options; options = tmpo; dbus_message_iter_recurse(&iter, &subiter); if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING) MALFORMED_MESSAGE(); dbus_message_iter_get_basic(&subiter, &tmp); if (!tmp) MALFORMED_MESSAGE(); /* The _ prefix refers to internal settings, and may not be given by * the client. */ if (tmp[0] == '_') { ErrorF("[config/dbus] attempted subterfuge: option name %s given\n", tmp); MALFORMED_MESSAGE(); } options->key = xstrdup(tmp); if (!options->key) { ErrorF("[config/dbus] couldn't duplicate key!\n"); ret = BadAlloc; goto unwind; } if (!dbus_message_iter_has_next(&subiter)) MALFORMED_MESSAGE(); dbus_message_iter_next(&subiter); if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING) MALFORMED_MESSAGE(); dbus_message_iter_get_basic(&subiter, &tmp); if (!tmp) MALFORMED_MESSAGE(); options->value = xstrdup(tmp); if (!options->value) { ErrorF("[config/dbus] couldn't duplicate option!\n"); ret = BadAlloc; goto unwind; } dbus_message_iter_next(&iter); } ret = NewInputDeviceRequest(options, &dev); if (ret != Success) { DebugF("[config/dbus] NewInputDeviceRequest failed\n"); goto unwind; } if (!dev) { DebugF("[config/dbus] NewInputDeviceRequest provided no device\n"); ret = BadImplementation; goto unwind; } /* XXX: If we fail halfway through, we don't seem to have any way to * empty the iterator, so you'll end up with some device IDs, * plus an error. This seems to be a shortcoming in the D-Bus * API. */ for (; dev; dev = dev->next) { if (!dbus_message_iter_append_basic(&reply_iter, DBUS_TYPE_INT32, &dev->id)) { ErrorF("[config/dbus] couldn't append to iterator\n"); ret = BadAlloc; goto unwind; } } unwind: if (ret != Success) { if (dev) RemoveDevice(dev); err = -ret; dbus_message_iter_append_basic(&reply_iter, DBUS_TYPE_INT32, &err); } while (options) { tmpo = options; options = options->next; if (tmpo->key) xfree(tmpo->key); if (tmpo->value) xfree(tmpo->value); xfree(tmpo); } return ret; }
/* Helper for utils_append_value, writes a list. The "list" is a struct with the * list type and an array with the values directly in it. */ static void utils_append_value_helper_list (DBusMessageIter *main_iter, const GConfValue *value) { DBusMessageIter struct_iter; DBusMessageIter array_iter; GConfValueType list_type; const gchar *array_type; GSList *list; d(g_print ("Append value (list)\n")); g_assert (value->type == GCONF_VALUE_LIST); dbus_message_iter_open_container (main_iter, DBUS_TYPE_STRUCT, NULL, /* for struct */ &struct_iter); /* Write the list type. */ list_type = gconf_value_get_list_type (value); dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_INT32, &list_type); /* And the value. */ switch (list_type) { case GCONF_VALUE_INT: array_type = DBUS_TYPE_INT32_AS_STRING; break; case GCONF_VALUE_STRING: array_type = DBUS_TYPE_STRING_AS_STRING; break; case GCONF_VALUE_FLOAT: array_type = DBUS_TYPE_DOUBLE_AS_STRING; break; case GCONF_VALUE_BOOL: array_type = DBUS_TYPE_BOOLEAN_AS_STRING; break; case GCONF_VALUE_SCHEMA: array_type = DBUS_TYPE_STRUCT_AS_STRING; break; default: array_type = NULL; g_assert_not_reached (); } dbus_message_iter_open_container (&struct_iter, DBUS_TYPE_ARRAY, array_type, &array_iter); list = gconf_value_get_list (value); switch (list_type) { case GCONF_VALUE_STRING: while (list) { const gchar *s; s = gconf_value_get_string (list->data); dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_STRING, &s); list = list->next; } break; case GCONF_VALUE_INT: while (list) { gint32 i; i = gconf_value_get_int (list->data); dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_INT32, &i); list = list->next; } break; case GCONF_VALUE_FLOAT: while (list) { gdouble d; d = gconf_value_get_float (list->data); dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_DOUBLE, &d); list = list->next; } break; case GCONF_VALUE_BOOL: while (list) { gboolean b; b = gconf_value_get_bool (list->data); dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_BOOLEAN, &b); list = list->next; } break; case GCONF_VALUE_SCHEMA: while (list) { GConfSchema *schema; schema = gconf_value_get_schema (list->data); utils_append_schema (&array_iter, schema); list = list->next; } break; default: g_assert_not_reached (); } dbus_message_iter_close_container (&struct_iter, &array_iter); dbus_message_iter_close_container (main_iter, &struct_iter); }
/*static*/ void BoolCodec::encode(DBusMessageIter& iter, bool b) { dbus_bool_t _b = b; dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &_b); }
static void colord_create_profile( cups_array_t *profiles, /* I - Profiles array */ const char *printer_name, /* I - Printer name */ const char *qualifier, /* I - Profile qualifier */ const char *colorspace, /* I - Profile colorspace */ char **format, /* I - Profile qualifier format */ const char *iccfile, /* I - ICC filename */ const char *scope) /* I - The scope of the profile, e.g. 'normal', 'temp' or 'disk' */ { DBusMessage *message = NULL; /* D-Bus request */ DBusMessage *reply = NULL; /* D-Bus reply */ DBusMessageIter args; /* D-Bus method arguments */ DBusMessageIter dict; /* D-Bus method arguments */ DBusError error; /* D-Bus error */ char *idstr; /* Profile ID string */ size_t idstrlen; /* Profile ID allocated length */ const char *profile_path; /* Device object path */ char format_str[1024]; /* Qualifier format as a string */ /* * Create the profile... */ message = dbus_message_new_method_call(COLORD_DBUS_SERVICE, COLORD_DBUS_PATH, COLORD_DBUS_INTERFACE, "CreateProfile"); idstrlen = strlen(printer_name) + 1 + strlen(qualifier) + 1; if ((idstr = malloc(idstrlen)) == NULL) goto out; snprintf(idstr, idstrlen, "%s-%s", printer_name, qualifier); cupsdLogMessage(CUPSD_LOG_DEBUG, "Using profile ID \"%s\".", idstr); dbus_message_iter_init_append(message, &args); dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &idstr); dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &scope); snprintf(format_str, sizeof(format_str), "%s.%s.%s", format[0], format[1], format[2]); dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "{ss}", &dict); colord_dict_add_strings(&dict, "Qualifier", qualifier); colord_dict_add_strings(&dict, "Format", format_str); colord_dict_add_strings(&dict, "Colorspace", colorspace); if (iccfile) colord_dict_add_strings(&dict, "Filename", iccfile); dbus_message_iter_close_container(&args, &dict); /* * Send the CreateProfile request synchronously... */ dbus_error_init(&error); cupsdLogMessage(CUPSD_LOG_DEBUG, "Calling CreateProfile(%s,%s)", idstr, scope); reply = dbus_connection_send_with_reply_and_block(colord_con, message, COLORD_DBUS_TIMEOUT, &error); if (!reply) { cupsdLogMessage(CUPSD_LOG_WARN, "CreateProfile failed: %s:%s", error.name, error.message); dbus_error_free(&error); goto out; } /* * Get reply data... */ dbus_message_iter_init(reply, &args); if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH) { cupsdLogMessage(CUPSD_LOG_WARN, "CreateProfile failed: Incorrect reply type."); goto out; } dbus_message_iter_get_basic(&args, &profile_path); cupsdLogMessage(CUPSD_LOG_DEBUG, "Created profile \"%s\".", profile_path); cupsArrayAdd(profiles, strdup(profile_path)); out: if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); if (idstr) free(idstr); }
static void sms_history_sms_send_status( struct ofono_history_context *context, const struct ofono_uuid *uuid, time_t when, enum ofono_history_sms_status s) { if ((s == OFONO_HISTORY_SMS_STATUS_DELIVERED) || (s == OFONO_HISTORY_SMS_STATUS_DELIVER_FAILED)) { DBusMessage *signal; DBusMessageIter iter; DBusMessageIter dict; const char *uuid_str; char *msg_uuid_str; size_t msg_len; struct ofono_atom *atom; const char *path; DBusConnection *conn; int delivered; atom = __ofono_modem_find_atom(context->modem, OFONO_ATOM_TYPE_SMS); if (atom == NULL) return; path = __ofono_atom_get_path(atom); if (path == NULL) return; conn = ofono_dbus_get_connection(); if (conn == NULL) return; delivered = (s == OFONO_HISTORY_SMS_STATUS_DELIVERED); uuid_str = ofono_uuid_to_str(uuid); /* sizeof adds extra space for one '\0' */ msg_len = strlen(path) + sizeof(msg_prefix) + strlen(uuid_str); msg_uuid_str = g_try_malloc(msg_len); if (msg_uuid_str == NULL) return; /* modem path + msg_prefix + UUID as string */ snprintf(msg_uuid_str, msg_len, "%s%s%s", path, msg_prefix, uuid_str); DBG("SMS %s delivery success: %d", msg_uuid_str, delivered); signal = dbus_message_new_signal(path, OFONO_MESSAGE_MANAGER_INTERFACE, "StatusReport"); if (signal != NULL) { dbus_message_iter_init_append(signal, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &msg_uuid_str); dbus_message_iter_open_container( &iter, DBUS_TYPE_ARRAY, OFONO_PROPERTIES_ARRAY_SIGNATURE, &dict); ofono_dbus_dict_append(&dict, "Delivered", DBUS_TYPE_BOOLEAN, &delivered); dbus_message_iter_close_container(&iter, &dict); g_dbus_send_message(conn, signal); } g_free(msg_uuid_str); } }
static char * /* O - Device path or NULL */ colord_find_device( const char *device_id) /* I - Device ID string */ { DBusMessage *message = NULL; /* D-Bus request */ DBusMessage *reply = NULL; /* D-Bus reply */ DBusMessageIter args; /* D-Bus method arguments */ DBusError error; /* D-Bus error */ const char *device_path_tmp; /* Device object path */ char *device_path = NULL; /* Device object path */ message = dbus_message_new_method_call(COLORD_DBUS_SERVICE, COLORD_DBUS_PATH, COLORD_DBUS_INTERFACE, "FindDeviceById"); dbus_message_iter_init_append(message, &args); dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &device_id); /* * Send the FindDeviceById request synchronously... */ dbus_error_init(&error); cupsdLogMessage(CUPSD_LOG_DEBUG, "Calling FindDeviceById(%s)", device_id); reply = dbus_connection_send_with_reply_and_block(colord_con, message, COLORD_DBUS_TIMEOUT, &error); if (!reply) { cupsdLogMessage(CUPSD_LOG_DEBUG, "FindDeviceById failed: %s:%s", error.name, error.message); dbus_error_free(&error); goto out; } /* * Get reply data... */ dbus_message_iter_init(reply, &args); if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH) { cupsdLogMessage(CUPSD_LOG_WARN, "FindDeviceById failed: Incorrect reply type."); goto out; } dbus_message_iter_get_basic(&args, &device_path_tmp); if (device_path_tmp) device_path = strdup(device_path_tmp); out: if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); return (device_path); }
static void service_inject_struct(DBusMessageIter *body) { xdbus_any_t arg = XDBUS_ANY_INIT; DBusMessageIter sub; dbus_message_iter_open_container(body, DBUS_TYPE_STRUCT, 0, &sub); arg.o = 255; dbus_message_iter_append_basic(&sub, DBUS_TYPE_BYTE, &arg); arg.b = true; dbus_message_iter_append_basic(&sub, DBUS_TYPE_BOOLEAN, &arg); arg.i16 = 0x7fff; dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT16, &arg); arg.i32 = 0x7fffffff; dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &arg); arg.i64 = 0x7fffffffffffffff; dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT64, &arg); arg.u16 = 0xffff; dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT16, &arg); arg.u32 = 0xffffffff; dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &arg); arg.u64 = 0xffffffffffffffff; dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT64, &arg); arg.d = 3.75; dbus_message_iter_append_basic(&sub, DBUS_TYPE_DOUBLE, &arg); arg.s = "string"; dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &arg); arg.s = "/obj/path"; dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &arg); arg.s = "sointu"; dbus_message_iter_append_basic(&sub, DBUS_TYPE_SIGNATURE, &arg); dbus_message_iter_close_container(body, &sub); }
static void colord_create_device( cupsd_printer_t *p, /* I - Printer */ ppd_file_t *ppd, /* I - PPD file */ cups_array_t *profiles, /* I - Profiles array */ const char *colorspace, /* I - Device colorspace, e.g. 'rgb' */ char **format, /* I - Device qualifier format */ const char *relation, /* I - Profile relation, either 'soft' or 'hard' */ const char *scope) /* I - The scope of the device, e.g. 'normal', 'temp' or 'disk' */ { DBusMessage *message = NULL; /* D-Bus request */ DBusMessage *reply = NULL; /* D-Bus reply */ DBusMessageIter args; /* D-Bus method arguments */ DBusMessageIter dict; /* D-Bus method arguments */ DBusError error; /* D-Bus error */ const char *device_path; /* Device object path */ const char *profile_path; /* Profile path */ char *default_profile_path = NULL; /* Default profile path */ char device_id[1024]; /* Device ID as understood by colord */ char format_str[1024]; /* Qualifier format as a string */ /* * Create the device... */ snprintf(device_id, sizeof(device_id), "cups-%s", p->name); device_path = device_id; message = dbus_message_new_method_call(COLORD_DBUS_SERVICE, COLORD_DBUS_PATH, COLORD_DBUS_INTERFACE, "CreateDevice"); dbus_message_iter_init_append(message, &args); dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &device_path); dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &scope); snprintf(format_str, sizeof(format_str), "%s.%s.%s", format[0], format[1], format[2]); dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "{ss}", &dict); colord_dict_add_strings(&dict, "Colorspace", colorspace); colord_dict_add_strings(&dict, "Mode", COLORD_MODE_PHYSICAL); if (ppd->manufacturer) colord_dict_add_strings(&dict, "Vendor", ppd->manufacturer); if (ppd->modelname) colord_dict_add_strings(&dict, "Model", ppd->modelname); if (p->sanitized_device_uri) colord_dict_add_strings(&dict, "Serial", p->sanitized_device_uri); colord_dict_add_strings(&dict, "Format", format_str); colord_dict_add_strings(&dict, "Kind", COLORD_KIND_PRINTER); dbus_message_iter_close_container(&args, &dict); /* * Send the CreateDevice request synchronously... */ dbus_error_init(&error); cupsdLogMessage(CUPSD_LOG_DEBUG, "Calling CreateDevice(%s,%s)", device_id, scope); reply = dbus_connection_send_with_reply_and_block(colord_con, message, COLORD_DBUS_TIMEOUT, &error); if (!reply) { cupsdLogMessage(CUPSD_LOG_WARN, "CreateDevice failed: %s:%s", error.name, error.message); dbus_error_free(&error); goto out; } /* * Get reply data... */ dbus_message_iter_init(reply, &args); if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH) { cupsdLogMessage(CUPSD_LOG_WARN, "CreateDevice failed: Incorrect reply type."); goto out; } dbus_message_iter_get_basic(&args, &device_path); cupsdLogMessage(CUPSD_LOG_DEBUG, "Created device \"%s\".", device_path); /* * Add profiles... */ for (profile_path = cupsArrayFirst(profiles); profile_path; profile_path = cupsArrayNext(profiles)) { colord_device_add_profile(device_path, profile_path, relation); } out: if (default_profile_path) free(default_profile_path); if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); }
bool dp_pack_pam_response(DBusMessage *msg, struct pam_data *pd) { dbus_bool_t dbret; struct response_data *resp; DBusMessageIter iter; DBusMessageIter array_iter; DBusMessageIter struct_iter; DBusMessageIter data_iter; uint32_t pam_status; uint32_t resp_type; dbus_message_iter_init_append(msg, &iter); /* Append the PAM status */ pam_status = pd->pam_status; dbret = dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &pam_status); if (!dbret) { return false; } /* Append the lockout of account */ dbret = dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &pd->account_locked); if (!dbret) { return false; } /* Create an array of response structures */ dbret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(uay)", &array_iter); if (!dbret) { return false; } resp = pd->resp_list; while (resp != NULL) { /* Create a DBUS struct */ dbret = dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter); if (!dbret) { return false; } /* Add the response type */ resp_type = resp->type; dbret = dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_UINT32, &resp_type); if (!dbret) { return false; } /* Add the response message */ dbret = dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "y", &data_iter); if (!dbret) { return false; } dbret = dbus_message_iter_append_fixed_array(&data_iter, DBUS_TYPE_BYTE, &(resp->data), resp->len); if (!dbret) { return false; } dbret = dbus_message_iter_close_container(&struct_iter, &data_iter); if (!dbret) { return false; } resp = resp->next; dbret = dbus_message_iter_close_container(&array_iter, &struct_iter); if (!dbret) { return false; } } /* Close the struct array */ dbret = dbus_message_iter_close_container(&iter, &array_iter); if (!dbret) { return false; } return true; }
static void process_properties_from_interface(struct generic_data *data, struct interface_data *iface) { GSList *l; DBusMessage *signal; DBusMessageIter iter, dict, array; GSList *invalidated; data->pending_prop = FALSE; if (iface->pending_prop == NULL) return; signal = dbus_message_new_signal(data->path, DBUS_INTERFACE_PROPERTIES, "PropertiesChanged"); if (signal == NULL) { error("Unable to allocate new " DBUS_INTERFACE_PROPERTIES ".PropertiesChanged signal"); return; } iface->pending_prop = g_slist_reverse(iface->pending_prop); dbus_message_iter_init_append(signal, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface->name); dbus_message_iter_open_container(&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, &dict); invalidated = NULL; for (l = iface->pending_prop; l != NULL; l = l->next) { GDBusPropertyTable *p = l->data; if (p->get == NULL) continue; if (p->exists != NULL && !p->exists(p, iface->user_data)) { invalidated = g_slist_prepend(invalidated, p); continue; } append_property(iface, p, &dict); } dbus_message_iter_close_container(&iter, &dict); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &array); for (l = invalidated; l != NULL; l = g_slist_next(l)) { GDBusPropertyTable *p = l->data; dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &p->name); } g_slist_free(invalidated); dbus_message_iter_close_container(&iter, &array); g_slist_free(iface->pending_prop); iface->pending_prop = NULL; /* Use dbus_connection_send to avoid recursive calls to g_dbus_flush */ dbus_connection_send(data->conn, signal, NULL); dbus_message_unref(signal); }
static void push_data(DBusConnection *bus) { char **l_set = NULL, **l_unset = NULL, **t; int c_set = 0, c_unset = 0, p; DBusError error; DBusMessage *m = NULL, *reply = NULL; DBusMessageIter iter, sub; dbus_error_init(&error); assert(bus); l_set = new0(char*, _PROP_MAX); l_unset = new0(char*, _PROP_MAX); if (!l_set || !l_unset) { log_oom(); goto finish; } for (p = 0; p < _PROP_MAX; p++) { assert(names[p]); if (isempty(data[p])) l_unset[c_set++] = (char*) names[p]; else { char *s; if (asprintf(&s, "%s=%s", names[p], data[p]) < 0) { log_oom(); goto finish; } l_set[c_unset++] = s; } } assert(c_set + c_unset == _PROP_MAX); m = dbus_message_new_method_call("org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnsetAndSetEnvironment"); if (!m) { log_error("Could not allocate message."); goto finish; } dbus_message_iter_init_append(m, &iter); if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) { log_oom(); goto finish; } STRV_FOREACH(t, l_unset) if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t)) { log_oom(); goto finish; } if (!dbus_message_iter_close_container(&iter, &sub) || !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) { log_oom(); goto finish; } STRV_FOREACH(t, l_set) if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t)) { log_oom(); goto finish; } if (!dbus_message_iter_close_container(&iter, &sub)) { log_oom(); goto finish; } reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error); if (!reply) { log_error("Failed to set locale information: %s", bus_error_message(&error)); goto finish; } finish: if (m) dbus_message_unref(m); if (reply) dbus_message_unref(reply); dbus_error_free(&error); strv_free(l_set); free(l_unset); }
/** * Connect to the DBUS bus and send a broadcast signal */ void sendsignal(char* sigvalue) { DBusMessage* msg; DBusMessageIter args; DBusConnection* conn; DBusError err; int ret; dbus_uint32_t serial = 0; printf("Sending signal with value %s\n", sigvalue); // initialise the error value dbus_error_init(&err); // connect to the DBUS system bus, and check for errors conn = dbus_bus_get(DBUS_BUS_SESSION, &err); if (dbus_error_is_set(&err)) { fprintf(stderr, "Connection Error (%s)\n", err.message); dbus_error_free(&err); } if (NULL == conn) { exit(1); } // register our name on the bus, and check for errors ret = dbus_bus_request_name(conn, "test.signal.source", DBUS_NAME_FLAG_REPLACE_EXISTING , &err); if (dbus_error_is_set(&err)) { fprintf(stderr, "Name Error (%s)\n", err.message); dbus_error_free(&err); } if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) { exit(1); } // create a signal & check for errors msg = dbus_message_new_signal("/test/signal/Object", // object name of the signal "test.signal.Type", // interface name of the signal "Test"); // name of the signal if (NULL == msg) { fprintf(stderr, "Message Null\n"); exit(1); } // append arguments onto signal dbus_message_iter_init_append(msg, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &sigvalue)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } // send the message and flush the connection if (!dbus_connection_send(conn, msg, &serial)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } dbus_connection_flush(conn); printf("Signal Sent\n"); // free the message dbus_message_unref(msg); }
static vlc_keystore_entry* kwallet_read_password_list( vlc_keystore* p_keystore, char* psz_entry_name, unsigned int* pi_count ) { vlc_keystore_sys* p_sys = p_keystore->p_sys; DBusMessage* msg = NULL; DBusMessage* repmsg = NULL; DBusMessageIter args; DBusMessageIter sub_iter; DBusMessageIter dict_iter; DBusMessageIter var_iter; vlc_keystore_entry* p_entries = NULL; size_t i_size; uint8_t* p_secret_decoded; char* p_reply; char* p_secret; int i = 0; /* init */ *pi_count = 0; if ( !( msg = vlc_dbus_new_method( p_keystore, "readPasswordList" ) ) ) { msg_Err( p_keystore, "kwallet_read_password_list : vlc_dbus_new_method failed" ); goto error; } /* argument init */ dbus_message_iter_init_append( msg, &args ); if ( !dbus_message_iter_append_basic( &args, DBUS_TYPE_INT32, &p_sys->i_handle ) || !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &psz_folder ) || !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &psz_entry_name ) || !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &p_sys->psz_app_id ) ) goto error; /* sending message */ if ( !( repmsg = vlc_dbus_send_message( p_keystore, msg ) ) ) { msg_Err( p_keystore, "kwallet_read_password_list : vlc_dbus_send_message failed" ); goto error; } /* handling reply */ if ( !dbus_message_iter_init( repmsg, &args ) ) { msg_Err( p_keystore, "kwallet_read_password_list : Message has no arguments" ); goto error; } else if ( dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY ) { msg_Err( p_keystore, "kwallet_read_password_list : Wrong reply type" ); goto error; } else { /* calculating p_entries's size */ dbus_message_iter_recurse( &args, &sub_iter ); do { if ( dbus_message_iter_get_arg_type( &sub_iter ) != DBUS_TYPE_DICT_ENTRY ) continue; dbus_message_iter_recurse( &sub_iter, &dict_iter ); if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_STRING ) continue; dbus_message_iter_next(&dict_iter); if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_VARIANT ) continue; ++( *pi_count ); } while ( dbus_message_iter_next( &sub_iter ) ); if ( *pi_count == 0 ) goto error; if ( !( p_entries = calloc( *pi_count, sizeof( vlc_keystore_entry ) ) ) ) goto error; dbus_message_iter_init( repmsg, &args ); /* recurse into the reply array */ dbus_message_iter_recurse( &args, &sub_iter ); do { if ( dbus_message_iter_get_arg_type( &sub_iter ) != DBUS_TYPE_DICT_ENTRY ) { msg_Err( p_keystore, "Wrong type not DBUS_TYPE_DICT_ENTRY" ); continue; } /* recurse into the dict-entry in the array */ dbus_message_iter_recurse( &sub_iter, &dict_iter ); if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_STRING ) { msg_Err( p_keystore, "First type of Dict-Entry is not a string" ); continue; } dbus_message_iter_get_basic( &dict_iter, &p_reply ); dbus_message_iter_next(&dict_iter); if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_VARIANT ) { msg_Err( p_keystore, "Second type of Dict-Entry is not a variant" ); continue; } /* recurse into the variant in the dict-entry */ dbus_message_iter_recurse( &dict_iter, &var_iter ); dbus_message_iter_get_basic( &var_iter, &p_secret ); i_size = vlc_b64_decode_binary( &p_secret_decoded, p_secret); if ( key2values( p_reply, &p_entries[i] ) ) goto error; if ( ( vlc_keystore_entry_set_secret( &p_entries[i], p_secret_decoded, i_size ) ) ) goto error; free(p_secret_decoded); i += 1; } while ( dbus_message_iter_next( &sub_iter ) ); } dbus_message_unref( msg ); dbus_message_unref( repmsg ); return p_entries; error: *pi_count = 0; vlc_keystore_release_entries( p_entries, i ); if ( msg ) dbus_message_unref( msg ); if ( repmsg ) dbus_message_unref( repmsg ); return NULL; }
static gboolean dconf_dbus_from_gv (DBusMessageIter *iter, GVariant *value, GError **error) { switch (g_variant_get_type_class (value)) { case G_VARIANT_CLASS_BOOLEAN: { dbus_bool_t v = g_variant_get_boolean (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_BOOLEAN, &v); break; } case G_VARIANT_CLASS_BYTE: { guint8 v = g_variant_get_byte (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_BYTE, &v); break; } case G_VARIANT_CLASS_INT16: { gint16 v = g_variant_get_int16 (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_INT16, &v); break; } case G_VARIANT_CLASS_UINT16: { guint16 v = g_variant_get_uint16 (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT16, &v); break; } case G_VARIANT_CLASS_INT32: { gint32 v = g_variant_get_int32 (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_INT32, &v); break; } case G_VARIANT_CLASS_UINT32: { guint32 v = g_variant_get_uint32 (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT32, &v); break; } case G_VARIANT_CLASS_INT64: { gint64 v = g_variant_get_int64 (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_INT64, &v); break; } case G_VARIANT_CLASS_UINT64: { guint64 v = g_variant_get_uint64 (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_UINT64, &v); break; } case G_VARIANT_CLASS_DOUBLE: { gdouble v = g_variant_get_double (value); dbus_message_iter_append_basic (iter, DBUS_TYPE_DOUBLE, &v); break; } case G_VARIANT_CLASS_STRING: { const gchar *v = g_variant_get_string (value, NULL); dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &v); break; } case G_VARIANT_CLASS_OBJECT_PATH: { const gchar *v = g_variant_get_string (value, NULL); dbus_message_iter_append_basic (iter, DBUS_TYPE_OBJECT_PATH, &v); break; } case G_VARIANT_CLASS_SIGNATURE: { const gchar *v = g_variant_get_string (value, NULL); dbus_message_iter_append_basic (iter, DBUS_TYPE_SIGNATURE, &v); break; } case G_VARIANT_CLASS_VARIANT: { DBusMessageIter sub; GVariant *child; child = g_variant_get_child_value (value, 0); dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, g_variant_get_type_string (child), &sub); if (!dconf_dbus_from_gv (&sub, child, error)) { g_variant_unref (child); goto fail; } dbus_message_iter_close_container (iter, &sub); g_variant_unref (child); break; } case G_VARIANT_CLASS_ARRAY: { DBusMessageIter dbus_iter; const gchar *type_string; GVariantIter gv_iter; GVariant *item; type_string = g_variant_get_type_string (value); type_string++; /* skip the 'a' */ dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY, type_string, &dbus_iter); g_variant_iter_init (&gv_iter, value); while ((item = g_variant_iter_next_value (&gv_iter))) { if (!dconf_dbus_from_gv (&dbus_iter, item, error)) { goto fail; } } dbus_message_iter_close_container (iter, &dbus_iter); break; } case G_VARIANT_CLASS_TUPLE: { DBusMessageIter dbus_iter; GVariantIter gv_iter; GVariant *item; dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL, &dbus_iter); g_variant_iter_init (&gv_iter, value); while ((item = g_variant_iter_next_value (&gv_iter))) { if (!dconf_dbus_from_gv (&dbus_iter, item, error)) goto fail; } dbus_message_iter_close_container (iter, &dbus_iter); break; } case G_VARIANT_CLASS_DICT_ENTRY: { DBusMessageIter dbus_iter; GVariant *key, *val; dbus_message_iter_open_container (iter, DBUS_TYPE_DICT_ENTRY, NULL, &dbus_iter); key = g_variant_get_child_value (value, 0); if (!dconf_dbus_from_gv (&dbus_iter, key, error)) { g_variant_unref (key); goto fail; } g_variant_unref (key); val = g_variant_get_child_value (value, 1); if (!dconf_dbus_from_gv (&dbus_iter, val, error)) { g_variant_unref (val); goto fail; } g_variant_unref (val); dbus_message_iter_close_container (iter, &dbus_iter); break; } default: g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_CONVERSION_FAILED, _("Error serializing GVariant with type-string `%s' to a D-Bus message"), g_variant_get_type_string (value)); goto fail; } return TRUE; fail: return FALSE; }