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