static void to_dbus_iter_from_dict(DBusMessageIter* parent_it, const EdbusData& data) { E_ASSERT(data.is_dict()); EdbusDict dict = data.to_dict(); /* TODO: allow empty containers ??? */ if(dict.size() < 1) return; /* * TODO: check signature size in DBus spec (or use edelib::String here) * * Also, this part needs a better code, especially in case when value signature * is needed. Value can be another dict, struct or array of dicts, struct, variants * and etc. so I need better singature builder. */ char sig[256]; const char* key_sig = from_edbusdata_type_to_dbus_type_string(dict.key_type()); //const char* value_sig = from_edbusdata_type_to_dbus_type_string(dict.value_type()); #if 0 const char* value_sig; if(dict.value_type() == EDBUS_TYPE_DICT) value_sig = "a{ss}"; else value_sig = from_edbusdata_type_to_dbus_type_string(dict.value_type()); #endif const char* value_sig; String ss; if(dict.value_type_is_container()) { /* * We already have correct header that represents dict array. Now * go and recurse into dict value container */ EdbusDict::const_iterator first = dict.begin(); build_signature((*first).value, ss); value_sig = ss.c_str(); } else value_sig = from_edbusdata_type_to_dbus_type_string(dict.value_type()); /* * Dicts are serialized as array of dict entries. We first build signature for array * elements, then iterate over EdbusDict entries and from key/value pairs construct a * DBus dict entry then append that entry to the array * * A signature for dictionary will be 'a{TYPE TYPE}'. dbus_message_iter_open_container() will * append 'a' to the signature. */ snprintf(sig, sizeof(sig), "%c%s%s%c", DBUS_DICT_ENTRY_BEGIN_CHAR, key_sig, value_sig, DBUS_DICT_ENTRY_END_CHAR); /* printf("Dict entry signature: %s\n", sig); */ DBusMessageIter sub; dbus_message_iter_open_container(parent_it, DBUS_TYPE_ARRAY, sig, &sub); EdbusDict::const_iterator it = dict.begin(), it_end = dict.end(); for(; it != it_end; ++it) { DBusMessageIter dict_entry_iter; dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, 0, &dict_entry_iter); /* * append key; it is always basic type * TODO: here should be assertion check */ to_dbus_iter_from_basic_type(&dict_entry_iter, (*it).key); /* append value, can be any type */ to_dbus_iter_from_edbusdata_type(&dict_entry_iter, (*it).value); dbus_message_iter_close_container(&sub, &dict_entry_iter); } dbus_message_iter_close_container(parent_it, &sub); }
/** * Closes an a{sv} after successfully appending all values. * * If this function fails, you must abandon iter and whatever * larger data structure (message, etc.) the a{sv} was embedded in. * * @param iter the iterator which is appending to the message or other data structure containing the a{sv} * @param arr_iter the iterator appending to the array, will be closed * @returns #TRUE on success, or #FALSE if not enough memory */ dbus_bool_t _dbus_asv_close (DBusMessageIter *iter, DBusMessageIter *arr_iter) { return dbus_message_iter_close_container (iter, arr_iter); }
bool CHALManager::Mount(CStorageDevice *volume, CStdString mountpath) { CLog::Log(LOGNOTICE, "HAL: Mounting %s (%s) at %s with umask=%u", volume->UDI.c_str(), volume->toString().c_str(), mountpath.c_str(), umask (0)); DBusMessage* msg; DBusMessageIter args; DBusError error; dbus_error_init (&error); DBusConnection *connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error); const char *s; if (connection) { msg = dbus_message_new_method_call("org.freedesktop.Hal", volume->UDI.c_str(), "org.freedesktop.Hal.Device.Volume", "Mount"); dbus_message_iter_init_append(msg, &args); s = mountpath.c_str(); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &s)) CLog::Log(LOGERROR, "DBus: Failed to append arguments"); s = ""; //FileSystem if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &s)) CLog::Log(LOGERROR, "DBus: Failed to append arguments"); DBusMessageIter sub; dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub); CStdString temporaryString; if (volume->FileSystem.Equals("vfat")) { int mask = umask (0); temporaryString.Format("umask=%#o", mask); s = temporaryString.c_str(); dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s); temporaryString.Format("uid=%u", getuid()); s = temporaryString.c_str(); dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s); s = "shortname=mixed"; dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s); s = "utf8"; dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s); // 'sync' option will slow down transfer speed significantly for FAT filesystems. We prefer 'flush' instead. s = "flush"; dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s); } else { s = "sync"; dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s); } dbus_message_iter_close_container(&args, &sub); if (msg == NULL) CLog::Log(LOGERROR, "DBus: Create Mount Message failed"); else { DBusMessage *reply; reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, &error); //The reply timout might be bad to have as -1 if (dbus_error_is_set(&error)) { CLog::Log(LOGERROR, "DBus: %s - %s", error.name, error.message); dbus_error_free(&error); return false; } // Need to create a reader for the Message dbus_message_unref (reply); dbus_message_unref(msg); msg = NULL; } volume->Mounted = true; volume->MountedByXBMC = true; volume->MountPoint = mountpath; dbus_connection_unref(connection); connection = NULL; return true; } else { CLog::Log(LOGERROR, "DBus: Failed to connect to Systembus"); dbus_error_free(&error); return false; } }
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; }
/** * PropertiesChangedSignal() synthetizes and sends the * org.freedesktop.DBus.Properties.PropertiesChanged signal */ static DBusHandlerResult PropertiesChangedSignal( intf_thread_t *p_intf, vlc_dictionary_t *p_changed_properties ) { DBusConnection *p_conn = p_intf->p_sys->p_conn; DBusMessageIter changed_properties, invalidated_properties, entry, variant; const char *psz_interface_name = DBUS_MPRIS_PLAYER_INTERFACE; char **ppsz_properties = NULL; int i_properties = 0; SIGNAL_INIT( DBUS_INTERFACE_PROPERTIES, DBUS_MPRIS_OBJECT_PATH, "PropertiesChanged" ); OUT_ARGUMENTS; ADD_STRING( &psz_interface_name ); dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "{sv}", &changed_properties ); i_properties = vlc_dictionary_keys_count( p_changed_properties ); ppsz_properties = vlc_dictionary_all_keys( p_changed_properties ); for( int i = 0; i < i_properties; i++ ) { dbus_message_iter_open_container( &changed_properties, DBUS_TYPE_DICT_ENTRY, NULL, &entry ); dbus_message_iter_append_basic( &entry, DBUS_TYPE_STRING, &ppsz_properties[i] ); if( !strcmp( ppsz_properties[i], "Metadata" ) ) { input_thread_t *p_input; p_input = playlist_CurrentInput( p_intf->p_sys->p_playlist ); dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "a{sv}", &variant ); if( p_input ) { input_item_t *p_item = input_GetItem( p_input ); GetInputMeta( p_item, &variant ); vlc_object_release( p_input ); } dbus_message_iter_close_container( &entry, &variant ); } else if( !strcmp( ppsz_properties[i], "PlaybackStatus" ) ) { dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "s", &variant ); MarshalPlaybackStatus( p_intf, &variant ); dbus_message_iter_close_container( &entry, &variant ); } else if( !strcmp( ppsz_properties[i], "LoopStatus" ) ) { dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "s", &variant ); MarshalLoopStatus( p_intf, &variant ); dbus_message_iter_close_container( &entry, &variant ); } else if( !strcmp( ppsz_properties[i], "Rate" ) ) { dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "d", &variant ); MarshalRate( p_intf, &variant ); dbus_message_iter_close_container( &entry, &variant ); } else if( !strcmp( ppsz_properties[i], "Shuffle" ) ) { dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "b", &variant ); MarshalShuffle( p_intf, &variant ); dbus_message_iter_close_container( &entry, &variant ); } else if( !strcmp( ppsz_properties[i], "Volume" ) ) { dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "d", &variant ); MarshalVolume( p_intf, &variant ); dbus_message_iter_close_container( &entry, &variant ); } else if( !strcmp( ppsz_properties[i], "CanSeek" ) ) { dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "b", &variant ); MarshalCanSeek( p_intf, &variant ); dbus_message_iter_close_container( &entry, &variant ); } else if( !strcmp( ppsz_properties[i], "CanPlay" ) ) { dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "b", &variant ); MarshalCanPlay( p_intf, &variant ); dbus_message_iter_close_container( &entry, &variant ); } else if( !strcmp( ppsz_properties[i], "CanPause" ) ) { dbus_message_iter_open_container( &entry, DBUS_TYPE_VARIANT, "b", &variant ); MarshalCanPause( p_intf, &variant ); dbus_message_iter_close_container( &entry, &variant ); } dbus_message_iter_close_container( &changed_properties, &entry ); free( ppsz_properties[i] ); } dbus_message_iter_close_container( &args, &changed_properties ); dbus_message_iter_open_container( &args, DBUS_TYPE_ARRAY, "s", &invalidated_properties ); dbus_message_iter_close_container( &args, &invalidated_properties ); free( ppsz_properties ); SIGNAL_SEND; }
virtual int showNotify(const char *pcHeader, const char *pcBody) { int rc; # ifdef VBOX_WITH_DBUS DBusConnection *conn; DBusMessage* msg = NULL; conn = dbus_bus_get (DBUS_BUS_SESSON, NULL); if (conn == NULL) { LogRelFlowFunc(("Could not retrieve D-BUS session bus!\n")); rc = VERR_INVALID_HANDLE; } else { msg = dbus_message_new_method_call("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications", "Notify"); if (msg == NULL) { LogRel(("Could not create D-BUS message!\n")); rc = VERR_INVALID_HANDLE; } else rc = VINF_SUCCESS; } if (RT_SUCCESS(rc)) { uint32_t msg_replace_id = 0; const char *msg_app = "VBoxClient"; const char *msg_icon = ""; const char *msg_summary = pcHeader; const char *msg_body = pcBody; int32_t msg_timeout = -1; /* Let the notification server decide */ DBusMessageIter iter; DBusMessageIter array; DBusMessageIter dict; DBusMessageIter value; DBusMessageIter variant; DBusMessageIter data; /* Format: UINT32 org.freedesktop.Notifications.Notify * (STRING app_name, UINT32 replaces_id, STRING app_icon, STRING summary, STRING body, * ARRAY actions, DICT hints, INT32 expire_timeout) */ dbus_message_iter_init_append(msg,&iter); dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&msg_app); dbus_message_iter_append_basic(&iter,DBUS_TYPE_UINT32,&msg_replace_id); dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&msg_icon); dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&msg_summary); dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&msg_body); dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,DBUS_TYPE_STRING_AS_STRING,&array); dbus_message_iter_close_container(&iter,&array); dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,"{sv}",&array); dbus_message_iter_close_container(&iter,&array); dbus_message_iter_append_basic(&iter,DBUS_TYPE_INT32,&msg_timeout); DBusError err; dbus_error_init(&err); DBusMessage *reply; reply = dbus_connection_send_with_reply_and_block(conn, msg, 30 * 1000 /* 30 seconds timeout */, &err); if (dbus_error_is_set(&err)) { LogRel(("D-BUS returned an error while sending the notification: %s", err.message)); } else if (reply) { dbus_connection_flush(conn); dbus_message_unref(reply); } if (dbus_error_is_set(&err)) dbus_error_free(&err); } if (msg != NULL) dbus_message_unref(msg); # else /* TODO: Implement me */ rc = VINF_SUCCESS; # endif /* VBOX_WITH_DBUS */ return rc; }
VIR_MOCK_WRAP_RET_ARGS(dbus_connection_send_with_reply_and_block, DBusMessage *, DBusConnection *, connection, DBusMessage *, message, int, timeout_milliseconds, DBusError *, error) { DBusMessage *reply = NULL; const char *service = dbus_message_get_destination(message); const char *member = dbus_message_get_member(message); size_t i; size_t nargs = 0; char **args = NULL; char *type = NULL; VIR_MOCK_REAL_INIT(dbus_connection_send_with_reply_and_block); if (STREQ(service, "org.freedesktop.DBus") && STREQ(member, "ListNames")) { const char *svc1 = "org.foo.bar.wizz"; const char *svc2 = VIR_FIREWALL_FIREWALLD_SERVICE; DBusMessageIter iter; DBusMessageIter sub; reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); dbus_message_iter_init_append(reply, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub); if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &svc1)) goto error; if (!fwDisabled && !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &svc2)) goto error; dbus_message_iter_close_container(&iter, &sub); } else if (STREQ(service, VIR_FIREWALL_FIREWALLD_SERVICE) && STREQ(member, "passthrough")) { bool isAdd = false; bool doError = false; if (virDBusMessageDecode(message, "sa&s", &type, &nargs, &args) < 0) goto error; for (i = 0; i < nargs; i++) { /* Fake failure on the command with this IP addr */ if (STREQ(args[i], "-A")) { isAdd = true; } else if (isAdd && STREQ(args[i], "192.168.122.255")) { doError = true; } } if (fwBuf) { if (STREQ(type, "ipv4")) virBufferAddLit(fwBuf, IPTABLES_PATH); else if (STREQ(type, "ipv4")) virBufferAddLit(fwBuf, IP6TABLES_PATH); else virBufferAddLit(fwBuf, EBTABLES_PATH); } for (i = 0; i < nargs; i++) { if (fwBuf) { virBufferAddLit(fwBuf, " "); virBufferEscapeShell(fwBuf, args[i]); } } if (fwBuf) virBufferAddLit(fwBuf, "\n"); if (doError) { dbus_set_error_const(error, "org.firewalld.error", "something bad happened"); } else { if (nargs == 1 && STREQ(type, "ipv4") && STREQ(args[0], "-L")) { if (virDBusCreateReply(&reply, "s", TEST_FILTER_TABLE_LIST) < 0) goto error; } else if (nargs == 3 && STREQ(type, "ipv4") && STREQ(args[0], "-t") && STREQ(args[1], "nat") && STREQ(args[2], "-L")) { if (virDBusCreateReply(&reply, "s", TEST_NAT_TABLE_LIST) < 0) goto error; } else { if (virDBusCreateReply(&reply, "s", "success") < 0) goto error; } } } else { reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); } cleanup: VIR_FREE(type); for (i = 0; i < nargs; i++) VIR_FREE(args[i]); VIR_FREE(args); return reply; error: virDBusMessageUnref(reply); reply = NULL; if (error && !dbus_error_is_set(error)) dbus_set_error_const(error, "org.firewalld.error", "something unexpected happened"); goto cleanup; }
static char * session_ck_open_session (DBusConnection *connection, const char *username, int display) { DBusError error; DBusMessage *message; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter iter_array; dbus_bool_t res; char *ret; char *cookie; dbus_bool_t is_local = FALSE; dbus_bool_t active = TRUE; int uid; char display_str[256]; const char *x11_display = display_str; const char *session_type = "rdp"; reply = NULL; message = NULL; ret = NULL; g_sprintf(display_str, ":%d", display); if (g_getuser_info(username, 0, &uid, 0, 0, 0)) goto out; message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "OpenSessionWithParameters"); if (message == NULL) { goto out; } dbus_message_iter_init_append (message, &iter); if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(sv)", &iter_array)) { goto out; } if (!add_param_basic (&iter_array, "unix-user", DBUS_TYPE_INT32, &uid) || !add_param_basic (&iter_array, "x11-display", DBUS_TYPE_STRING, &x11_display) || !add_param_basic (&iter_array, "is-local", DBUS_TYPE_BOOLEAN, &is_local) || !add_param_basic (&iter_array, "active", DBUS_TYPE_BOOLEAN, &active) || !add_param_basic (&iter_array, "session-type", DBUS_TYPE_STRING, &session_type)) { log_message(&(g_cfg->log), LOG_LEVEL_ALWAYS, "Error adding ck session parameter"); goto out; } if (! dbus_message_iter_close_container (&iter, &iter_array)) { goto out; } dbus_error_init (&error); reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error); if (reply == NULL) { if (dbus_error_is_set (&error)) { log_message(&(g_cfg->log), LOG_LEVEL_ALWAYS, "Unable to open session: %s", error.message); dbus_error_free (&error); goto out; } } dbus_error_init (&error); if (! dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, &cookie, DBUS_TYPE_INVALID)) { if (dbus_error_is_set (&error)) { log_message(&(g_cfg->log), LOG_LEVEL_ALWAYS, "Unable to open session: %s", error.message); dbus_error_free (&error); goto out; } } ret = g_strdup (cookie); out: if (reply != NULL) { dbus_message_unref (reply); } if (message != NULL) { dbus_message_unref (message); } return ret; }
static dbus_bool_t bus_driver_handle_list_services (DBusConnection *connection, BusTransaction *transaction, DBusMessage *message, DBusError *error) { DBusMessage *reply; int len; char **services; BusRegistry *registry; int i; DBusMessageIter iter; DBusMessageIter sub; _DBUS_ASSERT_ERROR_IS_CLEAR (error); registry = bus_connection_get_registry (connection); reply = dbus_message_new_method_return (message); if (reply == NULL) { BUS_SET_OOM (error); return FALSE; } if (!bus_registry_list_services (registry, &services, &len)) { dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } dbus_message_iter_init_append (reply, &iter); if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &sub)) { dbus_free_string_array (services); dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } { /* Include the bus driver in the list */ const char *v_STRING = DBUS_SERVICE_DBUS; if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING, &v_STRING)) { dbus_free_string_array (services); dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } } i = 0; while (i < len) { if (!dbus_message_iter_append_basic (&sub, DBUS_TYPE_STRING, &services[i])) { dbus_free_string_array (services); dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } ++i; } if (!dbus_message_iter_close_container (&iter, &sub)) { dbus_free_string_array (services); dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } dbus_free_string_array (services); if (!bus_transaction_send_from_driver (transaction, connection, reply)) { dbus_message_unref (reply); BUS_SET_OOM (error); return FALSE; } else { dbus_message_unref (reply); return TRUE; } }
int verify_polkit( DBusConnection *c, DBusMessage *request, const char *action, bool interactive, bool *_challenge, DBusError *error) { #ifdef ENABLE_POLKIT DBusMessage *m = NULL, *reply = NULL; const char *unix_process = "unix-process", *pid = "pid", *starttime = "start-time", *cancel_id = ""; uint32_t flags = interactive ? 1 : 0; pid_t pid_raw; uint32_t pid_u32; unsigned long long starttime_raw; uint64_t starttime_u64; DBusMessageIter iter_msg, iter_struct, iter_array, iter_dict, iter_variant; int r; dbus_bool_t authorized = FALSE, challenge = FALSE; #endif const char *sender; unsigned long ul; assert(c); assert(request); sender = dbus_message_get_sender(request); if (!sender) return -EINVAL; ul = dbus_bus_get_unix_user(c, sender, error); if (ul == (unsigned long) -1) return -EINVAL; /* Shortcut things for root, to avoid the PK roundtrip and dependency */ if (ul == 0) return 1; #ifdef ENABLE_POLKIT pid_raw = bus_get_unix_process_id(c, sender, error); if (pid_raw == 0) return -EINVAL; r = get_starttime_of_pid(pid_raw, &starttime_raw); if (r < 0) return r; m = dbus_message_new_method_call( "org.freedesktop.PolicyKit1", "/org/freedesktop/PolicyKit1/Authority", "org.freedesktop.PolicyKit1.Authority", "CheckAuthorization"); if (!m) return -ENOMEM; dbus_message_iter_init_append(m, &iter_msg); pid_u32 = (uint32_t) pid_raw; starttime_u64 = (uint64_t) starttime_raw; if (!dbus_message_iter_open_container(&iter_msg, DBUS_TYPE_STRUCT, NULL, &iter_struct) || !dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &unix_process) || !dbus_message_iter_open_container(&iter_struct, DBUS_TYPE_ARRAY, "{sv}", &iter_array) || !dbus_message_iter_open_container(&iter_array, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict) || !dbus_message_iter_append_basic(&iter_dict, DBUS_TYPE_STRING, &pid) || !dbus_message_iter_open_container(&iter_dict, DBUS_TYPE_VARIANT, "u", &iter_variant) || !dbus_message_iter_append_basic(&iter_variant, DBUS_TYPE_UINT32, &pid_u32) || !dbus_message_iter_close_container(&iter_dict, &iter_variant) || !dbus_message_iter_close_container(&iter_array, &iter_dict) || !dbus_message_iter_open_container(&iter_array, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict) || !dbus_message_iter_append_basic(&iter_dict, DBUS_TYPE_STRING, &starttime) || !dbus_message_iter_open_container(&iter_dict, DBUS_TYPE_VARIANT, "t", &iter_variant) || !dbus_message_iter_append_basic(&iter_variant, DBUS_TYPE_UINT64, &starttime_u64) || !dbus_message_iter_close_container(&iter_dict, &iter_variant) || !dbus_message_iter_close_container(&iter_array, &iter_dict) || !dbus_message_iter_close_container(&iter_struct, &iter_array) || !dbus_message_iter_close_container(&iter_msg, &iter_struct) || !dbus_message_iter_append_basic(&iter_msg, DBUS_TYPE_STRING, &action) || !dbus_message_iter_open_container(&iter_msg, DBUS_TYPE_ARRAY, "{ss}", &iter_array) || !dbus_message_iter_close_container(&iter_msg, &iter_array) || !dbus_message_iter_append_basic(&iter_msg, DBUS_TYPE_UINT32, &flags) || !dbus_message_iter_append_basic(&iter_msg, DBUS_TYPE_STRING, &cancel_id)) { r = -ENOMEM; goto finish; } reply = dbus_connection_send_with_reply_and_block(c, m, -1, error); if (!reply) { /* Treat no PK available as access denied */ if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN)) { r = -EACCES; dbus_error_free(error); goto finish; } r = -EIO; goto finish; } if (!dbus_message_iter_init(reply, &iter_msg) || dbus_message_iter_get_arg_type(&iter_msg) != DBUS_TYPE_STRUCT) { r = -EIO; goto finish; } dbus_message_iter_recurse(&iter_msg, &iter_struct); if (dbus_message_iter_get_arg_type(&iter_struct) != DBUS_TYPE_BOOLEAN) { r = -EIO; goto finish; } dbus_message_iter_get_basic(&iter_struct, &authorized); if (!dbus_message_iter_next(&iter_struct) || dbus_message_iter_get_arg_type(&iter_struct) != DBUS_TYPE_BOOLEAN) { r = -EIO; goto finish; } dbus_message_iter_get_basic(&iter_struct, &challenge); if (authorized) r = 1; else if (_challenge) { *_challenge = !!challenge; r = 0; } else r = -EPERM; finish: if (m) dbus_message_unref(m); if (reply) dbus_message_unref(reply); return r; #else return -EPERM; #endif }
gboolean ibus_message_iter_close_container (IBusMessageIter *iter, IBusMessageIter *sub) { return dbus_message_iter_close_container (iter, sub); }
static int set_network(struct supplicant_task *task, const unsigned char *network, int len, const char *address, const char *security, const char *passphrase) { DBusMessage *message, *reply; DBusMessageIter array, dict; DBusError error; dbus_uint32_t scan_ssid = 1; _DBG_SUPPLICANT("task %p", task); if (task->netpath == NULL) return -EINVAL; message = dbus_message_new_method_call(SUPPLICANT_NAME, task->netpath, SUPPLICANT_INTF ".Network", "set"); if (message == NULL) return -ENOMEM; dbus_message_set_auto_start(message, FALSE); dbus_message_iter_init_append(message, &array); dbus_message_iter_open_container(&array, 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); connman_dbus_dict_append_variant(&dict, "scan_ssid", DBUS_TYPE_UINT32, &scan_ssid); connman_dbus_dict_append_array(&dict, "ssid", DBUS_TYPE_BYTE, &network, len); /* NB: do not set the bssid; this allows wpa_supplicant to roam */ if (g_ascii_strcasecmp(security, "wpa") == 0 || g_ascii_strcasecmp(security, "rsn") == 0) { const char *key_mgmt = "WPA-PSK"; connman_dbus_dict_append_variant(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt); if (passphrase && strlen(passphrase) > 0) connman_dbus_dict_append_variant(&dict, "psk", DBUS_TYPE_STRING, &passphrase); } else if (g_ascii_strcasecmp(security, "wep") == 0) { const char *key_mgmt = "NONE"; const char *auth_alg = "OPEN"; const char *key_index = "0"; if (task->mac80211 == TRUE) auth_alg = "OPEN SHARED"; connman_dbus_dict_append_variant(&dict, "auth_alg", DBUS_TYPE_STRING, &auth_alg); connman_dbus_dict_append_variant(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt); if (passphrase) { int size = strlen(passphrase); if (size == 10 || size == 26) { unsigned char *key = malloc(13); char tmp[3]; int i; memset(tmp, 0, sizeof(tmp)); if (key == NULL) size = 0; for (i = 0; i < size / 2; i++) { memcpy(tmp, passphrase + (i * 2), 2); key[i] = (unsigned char) strtol(tmp, NULL, 16); } connman_dbus_dict_append_array(&dict, "wep_key0", DBUS_TYPE_BYTE, &key, size / 2); free(key); } else connman_dbus_dict_append_variant(&dict, "wep_key0", DBUS_TYPE_STRING, &passphrase); connman_dbus_dict_append_variant(&dict, "wep_tx_keyidx", DBUS_TYPE_STRING, &key_index); } } else { const char *key_mgmt = "NONE"; connman_dbus_dict_append_variant(&dict, "key_mgmt", DBUS_TYPE_STRING, &key_mgmt); } dbus_message_iter_close_container(&array, &dict); dbus_error_init(&error); reply = dbus_connection_send_with_reply_and_block(connection, message, -1, &error); if (reply == NULL) { if (dbus_error_is_set(&error) == TRUE) { connman_error("%s", error.message); dbus_error_free(&error); } else connman_error("Failed to set network options"); dbus_message_unref(message); return -EIO; } dbus_message_unref(message); dbus_message_unref(reply); return 0; }
static DBusHandlerResult message_handler_cb (DBusConnection *conn, DBusMessage *message, void *user_data) { /* * Here we handle the requests to our own gnome-keyring DBus interfaces */ DBusMessageIter args; DBusMessage *reply = NULL; /* GetEnvironment */ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL && dbus_message_is_method_call (message, GNOME_KEYRING_DAEMON_INTERFACE, "GetEnvironment") && g_str_equal (dbus_message_get_signature (message), "")) { const gchar **env; DBusMessageIter items, entry; env = gkd_util_get_environment (); g_return_val_if_fail (env, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); /* Setup the result */ reply = dbus_message_new_method_return (message); dbus_message_iter_init_append (reply, &args); if (!dbus_message_iter_open_container (&args, DBUS_TYPE_ARRAY, "{ss}", &items)) g_return_val_if_reached (DBUS_HANDLER_RESULT_NEED_MEMORY); while (*env) { gchar **parts; parts = g_strsplit (*env, "=", 2); g_return_val_if_fail (parts && parts[0] && parts[1], DBUS_HANDLER_RESULT_NOT_YET_HANDLED); if (!dbus_message_iter_open_container (&items, DBUS_TYPE_DICT_ENTRY, NULL, &entry) || !dbus_message_iter_append_basic (&entry, DBUS_TYPE_STRING, &parts[0]) || !dbus_message_iter_append_basic (&entry, DBUS_TYPE_STRING, &parts[1]) || !dbus_message_iter_close_container (&items, &entry)) { g_strfreev (parts); g_return_val_if_reached (DBUS_HANDLER_RESULT_NEED_MEMORY); } g_strfreev (parts); ++env; } if (!dbus_message_iter_close_container (&args, &items)) g_return_val_if_reached (DBUS_HANDLER_RESULT_NEED_MEMORY); /* GetControlDirectory */ } else if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL && dbus_message_is_method_call (message, GNOME_KEYRING_DAEMON_INTERFACE, "GetControlDirectory") && g_str_equal (dbus_message_get_signature (message), "")) { /* Setup the result */ const gchar *directory = gkd_util_get_master_directory (); reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_STRING, &directory, DBUS_TYPE_INVALID); /* Unknown call */ } else { return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } /* Send the reply */ if (!dbus_connection_send (conn, reply, NULL)) g_return_val_if_reached (DBUS_HANDLER_RESULT_NEED_MEMORY); dbus_connection_flush (conn); return DBUS_HANDLER_RESULT_HANDLED; }
static ssize_t synce_read(void *object, void *buf, size_t count, uint8_t *hi) { struct synce_context *context = object; DBusConnection *conn; char transport[36], transport_description[24]; const char *session; DBusMessage *msg; DBusMessageIter iter, dict; gboolean authenticate; DBusPendingCall *call; if (context->buffer) { *hi = OBEX_HDR_BODY; return string_read(context->buffer, buf, count); } conn = obex_dbus_get_connection(); if (conn == NULL) return -EPERM; msg = dbus_message_new_method_call(SYNCE_BUS_NAME, SYNCE_PATH, SYNCE_SERVER_INTERFACE, "Connect"); if (!msg) return -EPERM; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); append_dict_entry(&dict, "id", DBUS_TYPE_STRING, context->id); snprintf(transport, sizeof(transport), "%s.obexd", OPENOBEX_SERVICE); append_dict_entry(&dict, "transport", DBUS_TYPE_STRING, transport); snprintf(transport_description, sizeof(transport_description), "version %s", VERSION); append_dict_entry(&dict, "transport_description", DBUS_TYPE_STRING, transport_description); dbus_message_iter_close_container(&iter, &dict); authenticate = FALSE; session = ""; dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &authenticate, DBUS_TYPE_STRING, &session, DBUS_TYPE_INVALID); if (!dbus_connection_send_with_reply(conn, msg, &call, -1)) { error("D-Bus call to %s failed.", SYNCE_SERVER_INTERFACE); dbus_message_unref(msg); return -EPERM; } dbus_pending_call_set_notify(call, connect_cb, context, NULL); dbus_pending_call_unref(call); dbus_message_unref(msg); return -EAGAIN; }
END_TEST START_TEST(test_cancel_browse_invalid) { MafwProxySource *src; guint32 browse_id; DBusMessage *replmsg; DBusMessageIter iter_array, iter_msg; GError *error = NULL; /* II. call browse(), wait till it's finished, then try to * cancel it -> proxy should NOT send anything. */ mockbus_reset(); mock_empty_props(MAFW_DBUS_DESTINATION, MAFW_DBUS_PATH); mockbus_expect( mafw_dbus_method(MAFW_SOURCE_METHOD_BROWSE, MAFW_DBUS_STRING("bigcan"), MAFW_DBUS_BOOLEAN(FALSE), MAFW_DBUS_STRING(""), MAFW_DBUS_STRING(""), MAFW_DBUS_C_STRVZ("faszom"), MAFW_DBUS_UINT32(0), MAFW_DBUS_UINT32(0))); mockbus_reply(MAFW_DBUS_UINT32(4444)); replmsg = append_browse_res(NULL, &iter_msg, &iter_array, 4444, 0, 0, "testobject::item0", NULL, "", 0, ""); dbus_message_iter_close_container(&iter_msg, &iter_array); mockbus_incoming(replmsg); src = MAFW_PROXY_SOURCE(mafw_proxy_source_new(SOURCE_UUID, "fake", mafw_registry_get_instance())); fail_if(mafw_source_cancel_browse(MAFW_SOURCE(src), 10, &error)); fail_if(!error); g_error_free(error); browse_id = mafw_source_browse( MAFW_SOURCE(src), "bigcan", FALSE, NULL, NULL, MAFW_SOURCE_LIST("faszom"), 0, 0, browse_result2_invalid, NULL); g_main_loop_run(mainloop_test = g_main_loop_new(NULL, FALSE)); fail_if(mafw_source_cancel_browse(MAFW_SOURCE(src), browse_id, NULL)); mockbus_expect( mafw_dbus_method(MAFW_SOURCE_METHOD_BROWSE, MAFW_DBUS_STRING("abc"), MAFW_DBUS_BOOLEAN(FALSE), MAFW_DBUS_STRING(""), MAFW_DBUS_STRING(""), MAFW_DBUS_C_STRVZ("def"), MAFW_DBUS_UINT32(0), MAFW_DBUS_UINT32(0))); mockbus_reply(MAFW_DBUS_UINT32(4444)); browse_id = mafw_source_browse( MAFW_SOURCE(src), "abc", FALSE, NULL, NULL, MAFW_SOURCE_LIST("def"), 0, 0, browse_result2_invalid, NULL); error = NULL; mockbus_expect( mafw_dbus_method(MAFW_SOURCE_METHOD_CANCEL_BROWSE, MAFW_DBUS_UINT32(4444))); mockbus_error(MAFW_SOURCE_ERROR, 2, "testproblem"); fail_if(mafw_source_cancel_browse(MAFW_SOURCE(src), browse_id, &error)); fail_if(!error); g_error_free(error); mafw_registry_remove_extension(mafw_registry_get_instance(), (gpointer)src); mockbus_finish(); }
void method_AddService(char *path) { DBusMessage* msg; DBusMessageIter args; DBusConnection* conn; DBusError err; dbus_error_init(&err); DBusPendingCall* pending; dbus_int32_t interface = -1; dbus_int32_t protocol = -1; dbus_uint32_t flags = 0; char *name = "xifei"; char *type = "_http._tcp"; char *domain = "local"; char *host = "192.168.160.3"; dbus_uint16_t port = 500; char *txt1 = "xifei"; char *txt2 = "password of xifei"; /* <arg name="interface" type="i" direction="in"/> <arg name="protocol" type="i" direction="in"/> <arg name="flags" type="u" direction="in"/> <arg name="name" type="s" direction="in"/> <arg name="type" type="s" direction="in"/> <arg name="domain" type="s" direction="in"/> <arg name="host" type="s" direction="in"/> <arg name="port" type="q" direction="in"/> <arg name="txt" type="aay" direction="in"/> */ // initialiset the errors printf("Calling remote method: %s\n", "org.freedesktop.Avahi.EntryGroup"); // connect to the system bus and check for errors conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); if (dbus_error_is_set(&err)) { fprintf(stderr, "Connection Error (%s)\n", err.message); dbus_error_free(&err); } if (NULL == conn) { exit(1); } msg = dbus_message_new_method_call("org.freedesktop.Avahi",// target for the method call path, // object to call on "org.freedesktop.Avahi.EntryGroup", // interface to call on "AddService"); // method nameResolveHostName 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_INT32, &interface)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &protocol)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &flags)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &name)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &type)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &domain)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &host)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT16, &port)) { fprintf(stderr, "Out Of Memory!\n"); exit(1); } /* DBusMessageIter iter_ay, iter_y; // Open dict entry container if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "ay", &iter_ay)) { printf("Can't open container for iter_ay\n"); exit(1); } if (!dbus_message_iter_open_container(&iter_ay, DBUS_TYPE_ARRAY, "y", &iter_y)) { printf("Can't open container for iter_y\n"); exit(1); } dbus_uint16_t bb=98; dbus_uint16_t cc=97; dbus_message_iter_append_basic(&iter_y, DBUS_TYPE_BYTE, &bb); dbus_message_iter_append_basic(&iter_y, DBUS_TYPE_BYTE, &cc); dbus_message_iter_close_container(&iter_ay, &iter_y); dbus_message_iter_close_container(&args, &iter_ay); g_message("signature of iter_ay: %s", dbus_message_iter_get_signature(&iter_ay)); g_message("signature of args: %s", dbus_message_iter_get_signature(&args)); */ DBusMessageIter iter_ay, iter_y; if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "ay", &iter_ay)) { printf("Can't open container for iter_ay\n"); exit(1); } if (!dbus_message_iter_open_container(&iter_ay, DBUS_TYPE_ARRAY, "y", &iter_y)) { printf("Can't open container for iter_y\n"); exit(1); } if (!dbus_message_iter_append_fixed_array (&iter_y, DBUS_TYPE_BYTE, &txt1, sizeof(txt1))) { fprintf (stderr, "No memory!\n"); } dbus_message_iter_close_container(&iter_ay, &iter_y); dbus_message_iter_close_container(&args, &iter_ay); g_message("arrive here1."); g_message("signature of msg: %s", dbus_message_get_signature(msg)); // g_message("signature of iter_ay: %s", dbus_message_iter_get_signature(&iter_ay)); // g_message("signature of args: %s", dbus_message_iter_get_signature(&args)); // send message and get a handle for a reply if (!dbus_connection_send (conn, msg, NULL)) { // -1 is default timeout fprintf(stderr, "Out Of Memory!\n"); exit(1); } dbus_connection_flush(conn); printf("Request Sent\n"); // free message dbus_message_unref(msg); }
int supplicant_dbus_property_set(const char *path, const char *interface, const char *key, const char *signature, supplicant_dbus_setup_function setup, supplicant_dbus_result_function function, void *user_data) { struct property_set_data *data; DBusMessage *message; DBusMessageIter iter, value; DBusPendingCall *call; if (connection == NULL) return -EINVAL; if (path == NULL || interface == NULL) return -EINVAL; if (key == NULL || signature == NULL || setup == NULL) return -EINVAL; data = dbus_malloc0(sizeof(*data)); if (data == NULL) return -ENOMEM; message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path, DBUS_INTERFACE_PROPERTIES, "Set"); if (message == NULL) { dbus_free(data); return -ENOMEM; } dbus_message_set_auto_start(message, FALSE); dbus_message_iter_init_append(message, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &interface); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, signature, &value); setup(&value, user_data); dbus_message_iter_close_container(&iter, &value); if (dbus_connection_send_with_reply(connection, message, &call, TIMEOUT) == FALSE) { dbus_message_unref(message); dbus_free(data); return -EIO; } if (call == NULL) { dbus_message_unref(message); dbus_free(data); return -EIO; } data->function = function; data->user_data = user_data; dbus_pending_call_set_notify(call, property_set_reply, data, dbus_free); dbus_message_unref(message); return 0; }
static dbus_bool_t add_param_basic (DBusMessageIter *iter_array, const char *name, int type, const void *value) { DBusMessageIter iter_struct; DBusMessageIter iter_variant; const char *container_type; switch (type) { case DBUS_TYPE_STRING: container_type = DBUS_TYPE_STRING_AS_STRING; break; case DBUS_TYPE_BOOLEAN: container_type = DBUS_TYPE_BOOLEAN_AS_STRING; break; case DBUS_TYPE_INT32: container_type = DBUS_TYPE_INT32_AS_STRING; break; default: goto oom; break; } if (! dbus_message_iter_open_container (iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct)) { goto oom; } if (! dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &name)) { goto oom; } if (! dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_VARIANT, container_type, &iter_variant)) { goto oom; } if (! dbus_message_iter_append_basic (&iter_variant, type, value)) { goto oom; } if (! dbus_message_iter_close_container (&iter_struct, &iter_variant)) { goto oom; } if (! dbus_message_iter_close_container (iter_array, &iter_struct)) { goto oom; } return TRUE; oom: return FALSE; }
static DBusMessage * rdc_dbus_method_get_radius_conf( DBusConnection *conn, DBusMessage *msg, void *user_data ) { rdc_ins_t *rdcins = NULL; DBusMessage* reply = NULL; DBusMessageIter iter = {0}; DBusError err = {0}; struct radius_srv_coa * radius_srv = NULL; int num=0; char *domain=NULL; char *auth_secret=NULL; int ret = -1; reply = dbus_message_new_method_return(msg); if (NULL == reply) { eag_log_err("rdc_dbus_method_get_radius_conf "\ "DBUS new reply message error!\n"); return NULL; } rdcins = ( rdc_ins_t *)user_data; if( NULL == rdcins ){ eag_log_err("rdc_dbus_method_get_radius_conf user_data error!"); //return reply; ret = EAG_ERR_UNKNOWN; goto replyx; } dbus_error_init(&err); if (!(dbus_message_get_args(msg ,&err, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INVALID))){ eag_log_err("rdc_dbus_method_get_radius_conf "\ "unable to get input args\n"); if (dbus_error_is_set(&err)) { eag_log_err("rdc_dbus_method_get_radius_conf %s raised:%s\n", err.name, err.message); dbus_error_free(&err); } ret = EAG_ERR_DBUS_FAILED; goto replyx; } eag_log_info("rdc_dbus_method_get_radius_conf domain=%s,end", domain ); if( 0 == strlen(domain)){ /*get all radius configuration*/ num = rdcins->radius_conf.current_num; ret = EAG_RETURN_OK; radius_srv = &(rdcins->radius_conf.radius_srv[0]); } replyx: dbus_message_iter_init_append(reply, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret); if( EAG_RETURN_OK == ret ){ dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &num); } if( EAG_RETURN_OK == ret && num > 0 ){ int i; DBusMessageIter iter_array; dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, DBUS_STRUCT_BEGIN_CHAR_AS_STRING DBUS_TYPE_UINT32_AS_STRING DBUS_TYPE_UINT16_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_STRUCT_END_CHAR_AS_STRING, &iter_array); for( i=0; i<num; i++ ){ DBusMessageIter iter_struct; dbus_message_iter_open_container (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct); /*domain = radius_srv[i].domain; eag_log_info("eag_dbus_method_get_radius_conf add domain %s", domain ); dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &domain); */ /*auth*/ dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_UINT32, &radius_srv[i].auth_ip); dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_UINT16, &radius_srv[i].auth_port); auth_secret = radius_srv[i].auth_secret; dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &auth_secret); dbus_message_iter_close_container (&iter_array, &iter_struct); } dbus_message_iter_close_container (&iter, &iter_array); } return reply; }
static dbus_bool_t ck_connector_open_session_with_parameters_valist (CkConnector *connector, DBusError *error, const char *first_parameter_name, va_list var_args) { DBusError local_error; DBusMessage *message; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter iter_array; dbus_bool_t ret; char *cookie; const char *name; _ck_return_val_if_fail (connector != NULL, FALSE); reply = NULL; message = NULL; ret = FALSE; dbus_error_init (&local_error); connector->connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &local_error); if (connector->connection == NULL) { if (dbus_error_is_set (&local_error)) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Unable to open session: %s", local_error.message); dbus_error_free (&local_error); } goto out; } dbus_connection_set_exit_on_disconnect (connector->connection, FALSE); message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager", "OpenSessionWithParameters"); if (message == NULL) { goto out; } dbus_message_iter_init_append (message, &iter); if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(sv)", &iter_array)) { goto out; } name = first_parameter_name; while (name != NULL) { int type; const void *value; dbus_bool_t res; type = lookup_parameter_type (name); value = va_arg (var_args, const void *); if (type == DBUS_TYPE_INVALID) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Unknown parameter: %s", name); goto out; } res = add_param_basic (&iter_array, name, type, value); if (! res) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Error adding parameter: %s", name); goto out; } name = va_arg (var_args, char *); } if (! dbus_message_iter_close_container (&iter, &iter_array)) { goto out; } dbus_error_init (&local_error); reply = dbus_connection_send_with_reply_and_block (connector->connection, message, -1, &local_error); if (reply == NULL) { if (dbus_error_is_set (&local_error)) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Unable to open session: %s", local_error.message); dbus_error_free (&local_error); goto out; } } dbus_error_init (&local_error); if (! dbus_message_get_args (reply, &local_error, DBUS_TYPE_STRING, &cookie, DBUS_TYPE_INVALID)) { if (dbus_error_is_set (&local_error)) { dbus_set_error (error, CK_CONNECTOR_ERROR, "Unable to open session: %s", local_error.message); dbus_error_free (&local_error); goto out; } } connector->cookie = strdup (cookie); if (connector->cookie == NULL) { goto out; } connector->session_created = TRUE; ret = TRUE; out: if (reply != NULL) { dbus_message_unref (reply); } if (message != NULL) { dbus_message_unref (message); } return ret; }
errno_t ifp_add_ldb_el_to_dict(DBusMessageIter *iter_dict, struct ldb_message_element *el) { DBusMessageIter iter_dict_entry; DBusMessageIter iter_dict_val; DBusMessageIter iter_array; dbus_bool_t dbret; unsigned int i; if (el == NULL) { return EINVAL; } dbret = dbus_message_iter_open_container(iter_dict, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict_entry); if (!dbret) { return ENOMEM; } /* Start by appending the key */ dbret = dbus_message_iter_append_basic(&iter_dict_entry, DBUS_TYPE_STRING, &(el->name)); if (!dbret) { return ENOMEM; } dbret = dbus_message_iter_open_container(&iter_dict_entry, DBUS_TYPE_VARIANT, DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING, &iter_dict_val); if (!dbret) { return ENOMEM; } /* Open container for values */ dbret = dbus_message_iter_open_container(&iter_dict_val, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &iter_array); if (!dbret) { return ENOMEM; } /* Now add all the values */ for (i = 0; i < el->num_values; i++) { DEBUG(SSSDBG_TRACE_FUNC, "element [%s] has value [%s]\n", el->name, (const char *) el->values[i].data); dbret = dbus_message_iter_append_basic(&iter_array, DBUS_TYPE_STRING, &(el->values[i].data)); if (!dbret) { return ENOMEM; } } dbret = dbus_message_iter_close_container(&iter_dict_val, &iter_array); if (!dbret) { return ENOMEM; } dbret = dbus_message_iter_close_container(&iter_dict_entry, &iter_dict_val); if (!dbret) { return ENOMEM; } dbret = dbus_message_iter_close_container(iter_dict, &iter_dict_entry); if (!dbret) { return ENOMEM; } return EOK; }
TInt Cstif_3::stif_file_writecontact( CStifItemParser& aItem ) { TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles ); //_dbus_wsd_reset(); _LIT(KOOM, "Out Of Memory"); DBusConnection* connection; DBusError error; DBusMessage* msg; DBusMessage* msg1; DBusMessageIter append_iter; DBusMessageIter return_iter; DBusMessageIter sub_iter; DBusPendingCall* pending; char error_name[40]; char error_msg[40]; char* arg_str = "DBus Testing"; char* arg_obj_path = "\Test\Object\Path"; int size; struct data_contact { char *name; char *ph_no; dbus_int32_t cnt; }data; size = sizeof(struct data_contact); iLog->Log(_L8("size of struct is %d"),size); data.name = "DBus"; data.ph_no = "+91234455"; //cnt=0; dbus_int32_t return_value; char ret_msg[20]; dbus_error_init(&error); connection = dbus_bus_get_private(DBUS_BUS_SESSION, &error); if(!connection) { sprintf(error_name, "Error_name : %s", error.name); iLog->Log(_L8(error_name)); sprintf(error_msg, "Error_msg : %s", error.message); iLog->Log(_L8(error_msg)); return 1; } msg = dbus_message_new_method_call("Test.Method.Call1", "/Test/Method/Object", "test.Method.Call", "file_writecontact"); if(msg == NULL) { iLog->Log(_L8("message error")); return 1; } iLog->Log(_L8("message created successfully")); dbus_message_iter_init_append(msg, &append_iter); if(!dbus_message_iter_append_basic(&append_iter, DBUS_TYPE_STRING, &arg_str)) { iLog->Log(KOOM); return 1; } // structure for(int i=0; i<=50; i++) { if(!dbus_message_iter_open_container(&append_iter, DBUS_TYPE_STRUCT, NULL, &sub_iter)) { iLog->Log(KOOM); return 1; } data.cnt = i; if(!dbus_message_iter_append_basic(&sub_iter, DBUS_TYPE_INT32, &data.cnt)) { iLog->Log(KOOM); return 1; } if(!dbus_message_iter_append_basic(&sub_iter, DBUS_TYPE_STRING, &data.name)) { iLog->Log(KOOM); return 1; } if(!dbus_message_iter_append_basic(&sub_iter, DBUS_TYPE_STRING, &data.ph_no)) { iLog->Log(KOOM); return 1; } dbus_message_iter_close_container(&append_iter, &sub_iter); // for 80 structure } // send message and get a handle for a reply if (!dbus_connection_send_with_reply (connection, msg, &pending, -1)) { // -1 is default timeout iLog->Log(_L8("message send error")); exit(1); } if (NULL == pending) { iLog->Log(_L8("pending is null")); exit(1); } dbus_connection_flush(connection); // free message dbus_message_unref(msg); // block until we recieve a reply dbus_pending_call_block(pending); // get the reply message msg1 = dbus_pending_call_steal_reply(pending); if (NULL == msg1) { iLog->Log(_L8("Reply error")); exit(1); } // free the pending message handle dbus_pending_call_unref(pending); dbus_error_init (&error); dbus_message_iter_init(msg1, &return_iter); dbus_message_iter_get_basic(&return_iter, &return_value); sprintf(ret_msg,"Reply = %d", return_value); iLog->Log(_L8(ret_msg)); if(return_value != 50) { iLog->Log(_L8("Return value is not what is sent")); return 1; } dbus_message_unref(msg); dbus_connection_close(connection); dbus_connection_unref(connection); dbus_shutdown(); iLog->Log( KSuccess ); return KErrNone; }
gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy, const char *name, int type, const void *value, size_t size, GDBusResultFunction function, void *user_data, GDBusDestroyFunction destroy) { struct set_property_data *data; GDBusClient *client; DBusMessage *msg; DBusMessageIter iter, variant, array; DBusPendingCall *call; char array_sig[3]; char type_sig[2]; if (!proxy || !name || !value) return FALSE; if (!dbus_type_is_basic(type)) return FALSE; client = proxy->client; if (!client) return FALSE; data = g_try_new0(struct set_property_data, 1); if (!data) 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) { g_free(data); return FALSE; } array_sig[0] = DBUS_TYPE_ARRAY; array_sig[1] = (char) type; array_sig[2] = '\0'; type_sig[0] = (char) type; type_sig[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, array_sig, &variant); dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, type_sig, &array); if (dbus_type_is_fixed(type)) dbus_message_iter_append_fixed_array(&array, type, &value, size); else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) { const char **str = (const char **) value; size_t i; for (i = 0; i < size; i++) dbus_message_iter_append_basic(&array, type, &str[i]); } dbus_message_iter_close_container(&variant, &array); 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; }
/** Helper for appending GConfValue to dbus message * * @param reply DBusMessage under construction * @param conf GConfValue to be added to the reply * * @return TRUE if the value was succesfully appended, or FALSE on failure */ static gboolean append_gconf_value_to_dbus_message(DBusMessage *reply, GConfValue *conf) { const char *sig = 0; DBusMessageIter body, variant, array; if( !(sig = value_signature(conf)) ) { goto bailout_message; } dbus_message_iter_init_append(reply, &body); if( !dbus_message_iter_open_container(&body, DBUS_TYPE_VARIANT, sig, &variant) ) { goto bailout_message; } switch( conf->type ) { case GCONF_VALUE_STRING: { const char *arg = gconf_value_get_string(conf) ?: ""; dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &arg); } break; case GCONF_VALUE_INT: { dbus_int32_t arg = gconf_value_get_int(conf); dbus_message_iter_append_basic(&variant, DBUS_TYPE_INT32, &arg); } break; case GCONF_VALUE_FLOAT: { double arg = gconf_value_get_float(conf); dbus_message_iter_append_basic(&variant, DBUS_TYPE_DOUBLE, &arg); } break; case GCONF_VALUE_BOOL: { dbus_bool_t arg = gconf_value_get_bool(conf); dbus_message_iter_append_basic(&variant, DBUS_TYPE_BOOLEAN, &arg); } break; case GCONF_VALUE_LIST: if( !(sig = type_signature(gconf_value_get_list_type(conf))) ) { goto bailout_variant; } if( !dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, sig, &array) ) { goto bailout_variant; } switch( gconf_value_get_list_type(conf) ) { case GCONF_VALUE_STRING: { int cnt = 0; const char **arg = string_array_from_gconf_value(conf, &cnt); for( int i = 0; i < cnt; ++i ) { const char *str = arg[i]; dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &str); } g_free(arg); } break; case GCONF_VALUE_INT: { int cnt = 0; dbus_int32_t *arg = int_array_from_gconf_value(conf, &cnt); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_INT32, &arg, cnt); g_free(arg); } break; case GCONF_VALUE_FLOAT: { int cnt = 0; double *arg = float_array_from_gconf_value(conf, &cnt); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_DOUBLE, &arg, cnt); g_free(arg); } break; case GCONF_VALUE_BOOL: { int cnt = 0; dbus_bool_t *arg = bool_array_from_gconf_value(conf, &cnt); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BOOLEAN, &arg, cnt); g_free(arg); } break; default: goto bailout_array; } if( !dbus_message_iter_close_container(&variant, &array) ) { goto bailout_variant; } break; default: goto bailout_variant; } if( !dbus_message_iter_close_container(&body, &variant) ) { goto bailout_message; } return TRUE; bailout_array: dbus_message_iter_abandon_container(&variant, &array); bailout_variant: dbus_message_iter_abandon_container(&body, &variant); bailout_message: return FALSE; }
static int tapi_transceive(uint8_t ctrl_idx, uint32_t se_idx, uint8_t *apdu, size_t apdu_length, transceive_cb_t cb, void *context) { DBusMessage *message; DBusMessageIter iter; DBusMessageIter value, array; DBusPendingCall *call; struct tapi_transceive_context *ctx; int err; DBG("%zd APDU %p", apdu_length, apdu); if (default_modem == NULL) { err = -EIO; goto fail; } ctx = g_try_malloc0(sizeof(struct tapi_transceive_context)); if (ctx == NULL) { err = -ENOMEM; goto fail; } ctx->context = context; ctx->cb = cb; message = dbus_message_new_method_call(TELEPHONY_SERVICE, default_modem->path, SIM_INTERFACE, TRANSFER_APDU); if (message == NULL) { err = -ENOMEM; goto fail; } dbus_message_iter_init_append(message, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING, &value); dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &array); dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE, &apdu, apdu_length); dbus_message_iter_close_container(&value, &array); dbus_message_iter_close_container(&iter, &value); if (dbus_connection_send_with_reply(connection, message, &call, -1) == FALSE) { DBG("Failed to Transfer APDU through UICC"); dbus_message_unref(message); err = -EINVAL; goto fail; } if (call == NULL) { DBG("D-Bus connection not available"); dbus_message_unref(message); err = -EINVAL; goto fail; } dbus_pending_call_set_notify(call, tapi_transfer_apdu_reply, ctx, NULL); dbus_message_unref(message); return 0; fail: cb(context, NULL, 0, err); if (ctx != NULL) g_free(ctx); return err; }
END_TEST START_TEST(test_browse) { MafwProxySource *sp = NULL; guint browse_id = 0; const gchar *const *metadata_keys = NULL; GHashTable *metadata; DBusMessage *replmsg; DBusMessageIter iter_array, iter_msg; metadata_keys = MAFW_SOURCE_LIST("title"); metadata = mockbus_mkmeta("title", "More than words", NULL); mockbus_reset(); mock_empty_props(MAFW_DBUS_DESTINATION, MAFW_DBUS_PATH); mockbus_expect( mafw_dbus_method(MAFW_SOURCE_METHOD_BROWSE, MAFW_DBUS_STRING("testobject"), MAFW_DBUS_BOOLEAN(FALSE), MAFW_DBUS_STRING(""), MAFW_DBUS_STRING(""), MAFW_DBUS_C_STRVZ("title"), MAFW_DBUS_UINT32(0), MAFW_DBUS_UINT32(10))); mockbus_reply(MAFW_DBUS_UINT32(4444)); replmsg = append_browse_res(NULL, &iter_msg, &iter_array, 4444, -1, 0, "testobject", metadata, "", 0, ""); dbus_message_iter_close_container(&iter_msg, &iter_array); mockbus_incoming(replmsg); mafw_metadata_release(metadata); sp = MAFW_PROXY_SOURCE(mafw_proxy_source_new(SOURCE_UUID, "fake", mafw_registry_get_instance())); fail_unless(sp != NULL, "Object construction failed"); browse_id = mafw_source_browse(MAFW_SOURCE(sp), "testobject", FALSE, NULL, NULL, metadata_keys, 0, 10, browse_result, NULL); info("Browse ID: %d", browse_id); mainloop_test = g_main_loop_new(NULL, FALSE); g_main_loop_run(mainloop_test); fail_unless(browse_result_ok == TRUE, "Browse result signal missing."); mockbus_expect( mafw_dbus_method(MAFW_SOURCE_METHOD_BROWSE, MAFW_DBUS_STRING("testobject"), MAFW_DBUS_BOOLEAN(FALSE), MAFW_DBUS_STRING(""), MAFW_DBUS_STRING(""), MAFW_DBUS_C_STRVZ(NULL), MAFW_DBUS_UINT32(0), MAFW_DBUS_UINT32(10))); mockbus_error(MAFW_SOURCE_ERROR, 2, "testproblem"); browse_id = mafw_source_browse(MAFW_SOURCE(sp), "testobject", FALSE, NULL, NULL, NULL, 0, 10, browse_error_result, NULL); info("Browse ID: %d", browse_id); fail_unless(browse_result_ok == TRUE, "Browse result signal missing."); fail_if(browse_id != MAFW_SOURCE_INVALID_BROWSE_ID); mafw_registry_remove_extension(mafw_registry_get_instance(), (gpointer)sp); g_main_loop_unref(mainloop_test); mockbus_finish(); }
/** * Creates the HealthApplication's by calling BlueZ * * @param is_sink TRUE if data type is Sink role * @param data_type Specialization or data type */ gboolean create_health_application(gboolean is_sink, guint16 data_type) { /* Create HealthApplication */ // Need to use non-GLib code here because GLib still does not have // the G_TYPE_UINT16 type. DBusMessage *msg, *reply; DBusError err; DBusMessageIter iter, array, entry, variant; guint16 value; const char *svalue; const char *key; char *app_path; app_object *app; msg = dbus_message_new_method_call("org.bluez", "/org/bluez", "org.bluez.HealthManager", "CreateApplication"); if (!msg) { DEBUG(" network:dbus Can't allocate new method call"); return FALSE; } dbus_message_iter_init_append(msg, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &array); key = "DataType"; value = data_type; dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "q", &variant); dbus_message_iter_append_basic(&variant, DBUS_TYPE_UINT16, &value); dbus_message_iter_close_container(&entry, &variant); dbus_message_iter_close_container(&array, &entry); key = "Role"; svalue = (is_sink ? "Sink" : "Source"); dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &variant); dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &svalue); dbus_message_iter_close_container(&entry, &variant); dbus_message_iter_close_container(&array, &entry); key = "Description"; svalue = "healthd"; dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &variant); dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING, &svalue); dbus_message_iter_close_container(&entry, &variant); dbus_message_iter_close_container(&array, &entry); dbus_message_iter_close_container(&iter, &array); dbus_error_init(&err); reply = dbus_connection_send_with_reply_and_block( dbus_g_connection_get_connection(conn), msg, -1, &err); dbus_message_unref(msg); if (!reply) { DEBUG(" network:dbus Can't create application"); if (dbus_error_is_set(&err)) { ERROR("%s", err.message); dbus_error_free(&err); } return FALSE; } if (!dbus_message_get_args(reply, &err, DBUS_TYPE_OBJECT_PATH, &app_path, DBUS_TYPE_INVALID)) { DEBUG(" network:dbus Can't get reply arguments"); if (dbus_error_is_set(&err)) { ERROR("%s", err.message); dbus_error_free(&err); } return FALSE; } app = g_new0(app_object, 1); app->path = g_strdup(app_path); app->data_type = data_type; app->is_sink = is_sink; llist_add(apps(), app); dbus_message_unref(reply); DEBUG("Created health application: %s", (char *) app->path); return TRUE; }
END_TEST START_TEST(test_cancel_browse) { GPtrArray *results; MafwProxySource *src; DBusMessage *replmsg; DBusMessageIter iter_array, iter_msg; /* I. call browse(), wait for 2 results, then cancel it -> * proxy should sent the cancel message */ mockbus_reset(); mock_empty_props(MAFW_DBUS_DESTINATION, MAFW_DBUS_PATH); mockbus_expect( mafw_dbus_method(MAFW_SOURCE_METHOD_BROWSE, MAFW_DBUS_STRING("bigcan"), MAFW_DBUS_BOOLEAN(FALSE), MAFW_DBUS_STRING(""), MAFW_DBUS_STRING(""), MAFW_DBUS_C_STRVZ("faszom"), MAFW_DBUS_UINT32(0), MAFW_DBUS_UINT32(0))); mockbus_reply(MAFW_DBUS_UINT32(4444)); replmsg = append_browse_res(NULL, &iter_msg, &iter_array, 4444, 5, 0, "testobject::item0", NULL, "", 0, ""); replmsg = append_browse_res(replmsg, &iter_msg, &iter_array, 4444, 4, 0, "testobject::item1", NULL, "", 0, ""); replmsg = append_browse_res(replmsg, &iter_msg, &iter_array, 4444, 3, 0, "testobject::item2", NULL, "", 0, ""); replmsg = append_browse_res(replmsg, &iter_msg, &iter_array, 4444, 3, 0, "testobject::item3", NULL, "", 0, ""); dbus_message_iter_close_container(&iter_msg, &iter_array); mockbus_incoming(replmsg); mockbus_expect( mafw_dbus_method(MAFW_SOURCE_METHOD_CANCEL_BROWSE, MAFW_DBUS_UINT32(4444))); mockbus_reply(); src = MAFW_PROXY_SOURCE(mafw_proxy_source_new(SOURCE_UUID, "fake", mafw_registry_get_instance())); results = g_ptr_array_new(); mafw_source_browse(MAFW_SOURCE(src), "bigcan", FALSE, NULL, NULL, MAFW_SOURCE_LIST("faszom"), 0, 0, browse_result2, results); g_main_loop_run(mainloop_test = g_main_loop_new(NULL, FALSE)); fail_if(results->len != 3); fail_if(strcmp(results->pdata[0], "testobject::item0")); fail_if(strcmp(results->pdata[1], "testobject::item1")); fail_if(strcmp(results->pdata[2], "testobject::item2")); g_free(results->pdata[0]); g_free(results->pdata[1]); g_free(results->pdata[2]); g_ptr_array_free(results, TRUE); mafw_registry_remove_extension(mafw_registry_get_instance(), (gpointer)src); mockbus_finish(); }
gboolean upstart_job_exec(svc_action_t * op, gboolean synchronous) { char *job = NULL; int arg_wait = TRUE; const char *arg_env = "pacemaker=1"; const char *action = op->action; DBusError error; DBusMessage *msg = NULL; DBusMessage *reply = NULL; DBusMessageIter iter, array_iter; op->rc = PCMK_OCF_UNKNOWN_ERROR; CRM_ASSERT(upstart_init()); if (safe_str_eq(op->action, "meta-data")) { op->stdout_data = upstart_job_metadata(op->agent); op->rc = PCMK_OCF_OK; goto cleanup; } if(!upstart_job_by_name(op->agent, &job, op->timeout)) { crm_debug("Could not obtain job named '%s' to %s", op->agent, action); if (!g_strcmp0(action, "stop")) { op->rc = PCMK_OCF_OK; } else { op->rc = PCMK_OCF_NOT_INSTALLED; op->status = PCMK_LRM_OP_NOT_INSTALLED; } goto cleanup; } if (safe_str_eq(op->action, "monitor") || safe_str_eq(action, "status")) { char *path = get_first_instance(job, op->timeout); op->rc = PCMK_OCF_NOT_RUNNING; if(path) { DBusPendingCall *pending = NULL; char *state = pcmk_dbus_get_property( upstart_proxy, BUS_NAME, path, UPSTART_06_API ".Instance", "state", op->synchronous?NULL:upstart_job_check, op, op->synchronous?NULL:&pending, op->timeout); free(job); free(path); if(op->synchronous) { upstart_job_check("state", state, op); free(state); return op->rc == PCMK_OCF_OK; } else if (pending) { services_set_op_pending(op, pending); return TRUE; } return FALSE; } goto cleanup; } else if (!g_strcmp0(action, "start")) { action = "Start"; } else if (!g_strcmp0(action, "stop")) { action = "Stop"; } else if (!g_strcmp0(action, "restart")) { action = "Restart"; } else { op->rc = PCMK_OCF_UNIMPLEMENT_FEATURE; goto cleanup; } crm_debug("Calling %s for %s on %s", action, op->rsc, job); msg = dbus_message_new_method_call(BUS_NAME, // target for the method call job, // object to call on UPSTART_JOB_IFACE, // interface to call on action); // method name CRM_ASSERT(msg != NULL); dbus_message_iter_init_append (msg, &iter); CRM_LOG_ASSERT(dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &array_iter)); CRM_LOG_ASSERT(dbus_message_iter_append_basic (&array_iter, DBUS_TYPE_STRING, &arg_env)); CRM_LOG_ASSERT(dbus_message_iter_close_container (&iter, &array_iter)); CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &arg_wait, DBUS_TYPE_INVALID)); if (op->synchronous == FALSE) { DBusPendingCall* pending = pcmk_dbus_send(msg, upstart_proxy, upstart_async_dispatch, op, op->timeout); free(job); if(pending) { services_set_op_pending(op, pending); return TRUE; } return FALSE; } dbus_error_init(&error); reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, op->timeout); if(error.name) { if(!upstart_mask_error(op, error.name)) { crm_err("Could not issue %s for %s: %s (%s)", action, op->rsc, error.name, job); } } else if (!g_strcmp0(op->action, "stop")) { /* No return vaue */ op->rc = PCMK_OCF_OK; } else if(!pcmk_dbus_type_check(reply, NULL, DBUS_TYPE_OBJECT_PATH, __FUNCTION__, __LINE__)) { crm_warn("Call to %s passed but return type was unexpected", op->action); op->rc = PCMK_OCF_OK; } else { const char *path = NULL; dbus_message_get_args (reply, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); crm_info("Call to %s passed: %s", op->action, path); op->rc = PCMK_OCF_OK; } cleanup: free(job); if(msg) { dbus_message_unref(msg); } if(reply) { dbus_message_unref(reply); } if (op->synchronous == FALSE) { operation_finalize(op); return TRUE; } return op->rc == PCMK_OCF_OK; }
DBusHandlerResult my_com_netsplit_Nih_Test_Method_method (NihDBusObject * object, NihDBusMessage *message) { DBusMessageIter iter; DBusMessage * reply; MyMethodStructure *structure; DBusMessageIter structure_iter; const char * structure_item0; uint32_t structure_item1; nih_assert (object != NULL); nih_assert (message != NULL); /* Iterate the arguments to the message and demarshal into arguments * for our own function call. */ dbus_message_iter_init (message->message, &iter); if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) { reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS, "Invalid arguments to Method method"); if (! reply) return DBUS_HANDLER_RESULT_NEED_MEMORY; if (! dbus_connection_send (message->connection, reply, NULL)) { dbus_message_unref (reply); return DBUS_HANDLER_RESULT_NEED_MEMORY; } dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; } /* Call the handler function */ nih_error_push_context (); if (my_method (object->data, message, &structure) < 0) { NihError *err; err = nih_error_get (); if (err->number == ENOMEM) { nih_free (err); nih_error_pop_context (); return DBUS_HANDLER_RESULT_NEED_MEMORY; } else if (err->number == NIH_DBUS_ERROR) { NihDBusError *dbus_err = (NihDBusError *)err; reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message)); nih_free (err); nih_error_pop_context (); NIH_MUST (dbus_connection_send (message->connection, reply, NULL)); dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; } else { reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message)); nih_free (err); nih_error_pop_context (); NIH_MUST (dbus_connection_send (message->connection, reply, NULL)); dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; } } nih_error_pop_context (); /* If the sender doesn't care about a reply, don't bother wasting * effort constructing and sending one. */ if (dbus_message_get_no_reply (message->message)) return DBUS_HANDLER_RESULT_HANDLED; do { __label__ enomem; /* Construct the reply message. */ reply = dbus_message_new_method_return (message->message); if (! reply) goto enomem; dbus_message_iter_init_append (reply, &iter); /* Marshal a structure onto the message */ if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL, &structure_iter)) { dbus_message_unref (reply); reply = NULL; goto enomem; } structure_item0 = structure->item0; /* Marshal a char * onto the message */ if (! dbus_message_iter_append_basic (&structure_iter, DBUS_TYPE_STRING, &structure_item0)) { dbus_message_iter_abandon_container (&iter, &structure_iter); dbus_message_unref (reply); reply = NULL; goto enomem; } structure_item1 = structure->item1; /* Marshal a uint32_t onto the message */ if (! dbus_message_iter_append_basic (&structure_iter, DBUS_TYPE_UINT32, &structure_item1)) { dbus_message_iter_abandon_container (&iter, &structure_iter); dbus_message_unref (reply); reply = NULL; goto enomem; } if (! dbus_message_iter_close_container (&iter, &structure_iter)) { dbus_message_unref (reply); reply = NULL; goto enomem; } enomem: __attribute__ ((unused)); } while (! reply); /* Send the reply, appending it to the outgoing queue. */ NIH_MUST (dbus_connection_send (message->connection, reply, NULL)); dbus_message_unref (reply); return DBUS_HANDLER_RESULT_HANDLED; }