static long long rtkit_get_int_property(DBusConnection *connection, const char* propname, long long* propval) {
DBusMessage *m = NULL, *r = NULL;
DBusMessageIter iter, subiter;
dbus_int64_t i64;
dbus_int32_t i32;
DBusError error;
int current_type;
long long ret;
const char * interfacestr = "org.freedesktop.RealtimeKit1";
dbus_error_init(&error);
if (!(m = dbus_message_new_method_call(
RTKIT_SERVICE_NAME,
RTKIT_OBJECT_PATH,
"org.freedesktop.DBus.Properties",
"Get"))) {
ret = -ENOMEM;
goto finish;
}
if (!dbus_message_append_args(
m,
DBUS_TYPE_STRING, &interfacestr,
DBUS_TYPE_STRING, &propname,
DBUS_TYPE_INVALID)) {
ret = -ENOMEM;
goto finish;
}
if (!(r = dbus_connection_send_with_reply_and_block(connection, m, -1, &error))) {
ret = translate_error(error.name);
goto finish;
}
if (dbus_set_error_from_message(&error, r)) {
ret = translate_error(error.name);
goto finish;
}
ret = -EBADMSG;
dbus_message_iter_init(r, &iter);
while ((current_type = dbus_message_iter_get_arg_type (&iter)) != DBUS_TYPE_INVALID) {
if (current_type == DBUS_TYPE_VARIANT) {
dbus_message_iter_recurse(&iter, &subiter);
while ((current_type = dbus_message_iter_get_arg_type (&subiter)) != DBUS_TYPE_INVALID) {
if (current_type == DBUS_TYPE_INT32) {
dbus_message_iter_get_basic(&subiter, &i32);
*propval = i32;
ret = 0;
}
if (current_type == DBUS_TYPE_INT64) {
dbus_message_iter_get_basic(&subiter, &i64);
*propval = i64;
ret = 0;
}
dbus_message_iter_next (&subiter);
}
}
dbus_message_iter_next (&iter);
}
finish:
if (m)
dbus_message_unref(m);
if (r)
dbus_message_unref(r);
dbus_error_free(&error);
return ret;
}
static gboolean parse_player_metadata(struct media_player *mp,
DBusMessageIter *iter)
{
DBusMessageIter dict;
DBusMessageIter var;
int ctype;
gboolean title = FALSE;
uint64_t uid;
ctype = dbus_message_iter_get_arg_type(iter);
if (ctype != DBUS_TYPE_ARRAY)
return FALSE;
dbus_message_iter_recurse(iter, &dict);
if (mp->track != NULL)
g_hash_table_unref(mp->track);
mp->track = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
g_free);
while ((ctype = dbus_message_iter_get_arg_type(&dict)) !=
DBUS_TYPE_INVALID) {
DBusMessageIter entry;
const char *key;
if (ctype != DBUS_TYPE_DICT_ENTRY)
return FALSE;
dbus_message_iter_recurse(&dict, &entry);
if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&entry, &key);
dbus_message_iter_next(&entry);
if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
return FALSE;
dbus_message_iter_recurse(&entry, &var);
if (strcasecmp(key, "xesam:title") == 0) {
if (!parse_string_metadata(mp, "Title", &var))
return FALSE;
title = TRUE;
} else if (strcasecmp(key, "xesam:artist") == 0) {
if (!parse_array_metadata(mp, "Artist", &var))
return FALSE;
} else if (strcasecmp(key, "xesam:album") == 0) {
if (!parse_string_metadata(mp, "Album", &var))
return FALSE;
} else if (strcasecmp(key, "xesam:genre") == 0) {
if (!parse_array_metadata(mp, "Genre", &var))
return FALSE;
} else if (strcasecmp(key, "mpris:length") == 0) {
if (!parse_int64_metadata(mp, "Duration", &var))
return FALSE;
} else if (strcasecmp(key, "xesam:trackNumber") == 0) {
if (!parse_int32_metadata(mp, "TrackNumber", &var))
return FALSE;
} else
DBG("%s not supported, ignoring", key);
dbus_message_iter_next(&dict);
}
if (title == FALSE)
g_hash_table_insert(mp->track, g_strdup("Title"),
g_strdup(""));
mp->position = 0;
g_timer_start(mp->timer);
uid = get_uid(mp);
avrcp_player_event(mp->player, AVRCP_EVENT_TRACK_CHANGED, &uid);
avrcp_player_event(mp->player, AVRCP_EVENT_TRACK_REACHED_START, NULL);
return TRUE;
}
/* Helper for utils_get_value, reads a list. The "list" is a struct with the
* list type and an array with the values directly in it.
*/
static GConfValue *
utils_get_value_helper_list (DBusMessageIter *iter)
{
DBusMessageIter struct_iter;
DBusMessageIter array_iter;
GConfValue *value;
gint32 list_type;
GSList *list;
GConfValue *child_value;
d(g_print ("Get value (list)\n"));
value = gconf_value_new (GCONF_VALUE_LIST);
dbus_message_iter_recurse (iter, &struct_iter);
/* Get the list type. */
dbus_message_iter_get_basic (&struct_iter, &list_type);
gconf_value_set_list_type (value, list_type);
/* Get the array. */
dbus_message_iter_next (&struct_iter);
dbus_message_iter_recurse (&struct_iter, &array_iter);
/* And the values from the array. */
list = NULL;
switch (list_type)
{
case GCONF_VALUE_STRING:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRING)
{
const gchar *str;
dbus_message_iter_get_basic (&array_iter, &str);
child_value = gconf_value_new (GCONF_VALUE_STRING);
gconf_value_set_string (child_value, str);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
case GCONF_VALUE_INT:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_INT32)
{
gint32 i;
dbus_message_iter_get_basic (&array_iter, &i);
child_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (child_value, i);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
case GCONF_VALUE_FLOAT:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_DOUBLE)
{
gdouble d;
dbus_message_iter_get_basic (&array_iter, &d);
child_value = gconf_value_new (GCONF_VALUE_FLOAT);
gconf_value_set_float (child_value, d);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
case GCONF_VALUE_BOOL:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_BOOLEAN)
{
gboolean b;
dbus_message_iter_get_basic (&array_iter, &b);
child_value = gconf_value_new (GCONF_VALUE_BOOL);
gconf_value_set_bool (child_value, b);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
case GCONF_VALUE_SCHEMA:
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRUCT)
{
child_value = utils_get_schema_value (&array_iter);
list = g_slist_prepend (list, child_value);
dbus_message_iter_next (&array_iter);
}
break;
default:
g_assert_not_reached ();
}
list = g_slist_reverse (list);
gconf_value_set_list_nocopy (value, list);
return value;
}
int tool_cmd_scan(int argc, char *argv[])
{
int ret = 0;
int c;
int timeout = DEFAULT_TIMEOUT_IN_SECONDS * 1000;
const char *method_name;
DBusConnection* connection = NULL;
DBusMessage *message = NULL;
DBusMessage *reply = NULL;
DBusPendingCall *pending = NULL;
DBusError error;
int32_t scan_period = 0;
uint32_t channel_mask = 0;
dbus_bool_t joiner_flag = FALSE;
dbus_bool_t enable_filtering = FALSE;
uint16_t pan_id_filter = 0xffff;
dbus_error_init(&error);
sEnergyScan = false;
sMleDiscoverScan = false;
while (1) {
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"timeout", required_argument, 0, 't'},
{"channel", required_argument, 0, 'c'},
{"energy", no_argument, 0, 'e'},
{"discover", no_argument, 0, 'd'},
{"joiner-only", no_argument, 0, 'j'},
{"enable-filtering", no_argument, 0, 'f'},
{"panid-filtering", required_argument, 0, 'p'},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long(argc, argv, "hc:t:edjfp:", long_options,
&option_index);
if (c == -1)
break;
switch (c) {
case 'h':
print_arg_list_help(scan_option_list, argv[0],
scan_cmd_syntax);
ret = ERRORCODE_HELP;
goto bail;
case 't':
timeout = strtol(optarg, NULL, 0);
break;
case 'c':
channel_mask = strtomask_uint32(optarg);
break;
case 'e':
sEnergyScan = true;
break;
case 'd':
sMleDiscoverScan = true;
break;
case 'j':
joiner_flag = TRUE;
break;
case 'f':
enable_filtering = TRUE;
break;
case 'p':
pan_id_filter = strtol(optarg, NULL, 0);
break;
}
}
if (optind < argc) {
if (scan_period == 0) {
scan_period = strtol(argv[optind], NULL, 0);
optind++;
}
}
if (optind < argc) {
fprintf(stderr,
"%s: error: Unexpected extra argument: \"%s\"\n",
argv[0], argv[optind]);
ret = ERRORCODE_BADARG;
goto bail;
}
if (gInterfaceName[0] == 0) {
fprintf(stderr,
"%s: error: No WPAN interface set (use the `cd` command, or the `-I` argument for `wpanctl`).\n",
argv[0]);
ret = ERRORCODE_BADARG;
goto bail;
}
connection = dbus_bus_get(DBUS_BUS_STARTER, &error);
if (!connection) {
dbus_error_free(&error);
dbus_error_init(&error);
connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
}
require_string(connection != NULL, bail, error.message);
dbus_bus_add_match(connection, gDBusObjectManagerMatchString, &error);
require_string(error.name == NULL, bail, error.message);
dbus_connection_add_filter(connection, &dbus_signal_handler, NULL, NULL);
{
char path[DBUS_MAXIMUM_NAME_LENGTH+1];
char interface_dbus_name[DBUS_MAXIMUM_NAME_LENGTH+1];
DBusMessageIter iter;
ret = lookup_dbus_name_from_interface(interface_dbus_name, gInterfaceName);
if (ret != 0) {
print_error_diagnosis(ret);
goto bail;
}
snprintf(
path,
sizeof(path),
"%s/%s",
WPANTUND_DBUS_PATH,
gInterfaceName
);
if (sEnergyScan) {
method_name = WPANTUND_IF_CMD_ENERGY_SCAN_START;
} else {
if (sMleDiscoverScan) {
method_name = WPANTUND_IF_CMD_DISCOVER_SCAN_START;
} else {
method_name = WPANTUND_IF_CMD_NET_SCAN_START;
}
}
message = dbus_message_new_method_call(
interface_dbus_name,
path,
WPANTUND_DBUS_APIv1_INTERFACE,
method_name
);
dbus_message_append_args(
message,
DBUS_TYPE_UINT32, &channel_mask,
DBUS_TYPE_INVALID
);
if (sMleDiscoverScan) {
dbus_message_append_args(
message,
DBUS_TYPE_BOOLEAN, &joiner_flag,
DBUS_TYPE_BOOLEAN, &enable_filtering,
DBUS_TYPE_UINT16, &pan_id_filter,
DBUS_TYPE_INVALID
);
}
print_scan_header();
if (!sEnergyScan) {
gScannedNetworkCount = 0;
}
if(!dbus_connection_send_with_reply(
connection,
message,
&pending,
timeout
)) {
fprintf(stderr, "%s: error: IPC failure\n", argv[0]);
ret = ERRORCODE_UNKNOWN;
goto bail;
}
while ((dbus_connection_get_dispatch_status(connection) == DBUS_DISPATCH_DATA_REMAINS)
|| dbus_connection_has_messages_to_send(connection)
|| !dbus_pending_call_get_completed(pending)
) {
dbus_connection_read_write_dispatch(connection, 5000 /*ms*/);
}
reply = dbus_pending_call_steal_reply(pending);
require(reply != NULL, bail);
dbus_message_iter_init(reply, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32) {
fprintf(stderr, "%s: error: Server returned a bad response ('%c')\n",
argv[0], dbus_message_iter_get_arg_type(&iter));
ret = ERRORCODE_UNKNOWN;
goto bail;
}
// Get return code
dbus_message_iter_get_basic(&iter, &ret);
if (ret) {
fprintf(stderr, "%s failed with error %d. %s\n", argv[0], ret, wpantund_status_to_cstr(ret));
print_error_diagnosis(ret);
goto bail;
}
}
bail:
if (reply) {
dbus_message_unref(reply);
}
if (pending != NULL) {
dbus_pending_call_unref(pending);
}
if (message) {
dbus_message_unref(message);
}
if (connection) {
dbus_bus_remove_match(connection, gDBusObjectManagerMatchString, NULL);
dbus_connection_remove_filter(connection,&dbus_signal_handler,NULL);
dbus_connection_unref(connection);
}
dbus_error_free(&error);
return ret;
}
/**
* Call a method on a remote object
*/
void query(char* param)
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
DBusPendingCall* pending;
int ret;
bool stat;
dbus_uint32_t level;
printf("Calling remote method with %s\n", param);
// initialiset the errors
dbus_error_init(&err);
// connect to the system bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
exit(1);
}
// request our name on the bus
ret = dbus_bus_request_name(conn, "test.method.caller", DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Name Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
exit(1);
}
// create a new method call and check for errors
msg = dbus_message_new_method_call("test.method.server",// target for the method call
"/test/method/Object", // object to call on
"test.method.Type", // interface to call on
"Method"); // method name
if (NULL == msg) {
fprintf(stderr, "Message Null\n");
exit(1);
}
// append arguments
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, ¶m)) {
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
}
dbus_connection_flush(conn);
printf("Request Sent\n");
// free message
dbus_message_unref(msg);
// block until we recieve a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
exit(1);
}
// free the pending message handle
dbus_pending_call_unref(pending);
// read the parameters
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not boolean!\n");
else
dbus_message_iter_get_basic(&args, &stat);
if (!dbus_message_iter_next(&args))
fprintf(stderr, "Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not int!\n");
else
dbus_message_iter_get_basic(&args, &level);
printf("Got Reply: %d, %d\n", stat, level);
// free reply
dbus_message_unref(msg);
}
static void mediaplayer_register(const char *id) {
DBusMessage* msg;
DBusMessageIter args, element;
DBusPendingCall* pending;
char *name=NULL;
static const char *prop="Identity";
struct MEDIAPLAYER **mp;
char player[256];
for(mp=&mediaplayer; *mp; mp=&((*mp)->next)) {
if(!strcmp(id, (*mp)->id))
return;
}
sprintf(player, "%s.%s", mpris.interface, id);
if(!(msg=dbus_message_new_method_call(player, mpris.object, dbus.interface_prop, "Get")))
goto do_register;
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mpris.interface)) {
dbus_message_unref(msg);
goto do_register;
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &prop)) {
dbus_message_unref(msg);
goto do_register;
}
if(!dbus_connection_send_with_reply(dbus.session.connection, msg, &pending, -1)) {
dbus_message_unref(msg);
goto do_register;
}
if(!pending) {
dbus_message_unref(msg);
goto do_register;
}
dbus_connection_flush(dbus.session.connection);
dbus_message_unref(msg);
dbus_pending_call_block(pending);
if (!(msg=dbus_pending_call_steal_reply(pending))) {
dbus_pending_call_unref(pending);
goto do_register;
}
dbus_pending_call_unref(pending);
if(!dbus_message_iter_init(msg, &args)) {
dbus_message_unref(msg);
goto do_register;
} else if(dbus_message_iter_get_arg_type(&args)!=DBUS_TYPE_VARIANT) {
dbus_message_unref(msg);
goto do_register;
}
dbus_message_iter_recurse(&args, &element);
dbus_message_iter_get_basic(&element, &name);
dbus_message_unref(msg);
do_register:
*mp=malloc(sizeof(struct MEDIAPLAYER));
(*mp)->id=malloc(strlen(id)+1);
if(name) {
(*mp)->name=malloc(strlen(name)+1);
strcpy((void *) (*mp)->name, name);
} else
(*mp)->name=NULL;
(*mp)->next=NULL;
strcpy((void *) (*mp)->id, id);
}
int
pdc_intf_show_ipv6_maps(DBusConnection *connection,
int hansitype, int insid,
struct pdc_ipv6_map_conf *map_conf)
{
DBusMessage *query = NULL;
DBusMessage *reply = NULL;
DBusError err = {0};
DBusMessageIter iter;
DBusMessageIter iter_array;
DBusMessageIter iter_struct;
int iRet = 0;
uint32_t num = 0;
int i = 0;
int eag_slotid = 0;
int eag_hansitype = 0;
int eag_hansiid = 0;
if (NULL == map_conf){
return EAG_ERR_INPUT_PARAM_ERR;
}
memset(map_conf, 0, sizeof(struct pdc_ipv6_map_conf));
pdc_dbus_path_reinit(hansitype,insid);
query = dbus_message_new_method_call(
PDC_DBUS_NAME,
PDC_DBUS_OBJPATH,
PDC_DBUS_INTERFACE,
PDC_DBUS_METHOD_SHOW_IPV6_MAPS);
dbus_error_init(&err);
reply = dbus_connection_send_with_reply_and_block (
connection, query, -1, &err );
dbus_message_unref(query);
if (NULL == reply) {
if (dbus_error_is_set(&err)) {
dbus_error_free(&err);
}
return EAG_ERR_DBUS_FAILED;
}else{
dbus_message_iter_init(reply,&iter);
dbus_message_iter_get_basic(&iter, &iRet);
if( EAG_RETURN_OK == iRet ){
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter, &num);
if( num > MAX_PDC_IPV6_MAP_NUM ){
num = MAX_PDC_IPV6_MAP_NUM;
}
map_conf->num = num;
if( num > 0 ){
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter,&iter_array);
for( i=0; i<num; i++ ){
dbus_message_iter_recurse(&iter_array,&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&(map_conf->map[i].userip[0]));
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&(map_conf->map[i].userip[1]));
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&(map_conf->map[i].userip[2]));
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&(map_conf->map[i].userip[3]));
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&(map_conf->map[i].prefix_length));
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&eag_slotid);
map_conf->map[i].eag_slotid = eag_slotid;
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&eag_hansitype);
map_conf->map[i].eag_hansitype = eag_hansitype;
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&eag_hansiid);
map_conf->map[i].eag_hansiid = eag_hansiid;
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&(map_conf->map[i].eag_ip));
dbus_message_iter_next(&iter_struct);
dbus_message_iter_get_basic(&iter_struct,
&(map_conf->map[i].eag_port));
dbus_message_iter_next(&iter_array);
}
}
}
}
dbus_message_unref(reply);
return iRet;
}
static DBusHandlerResult
my_com_netsplit_Nih_Test_Peek_method (NihDBusObject * object,
NihDBusMessage *message)
{
DBusMessageIter iter;
DBusMessage * reply;
uint32_t address;
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);
/* Demarshal a uint32_t from the message */
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_UINT32) {
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
"Invalid arguments to Peek 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;
}
dbus_message_iter_get_basic (&iter, &address);
dbus_message_iter_next (&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 Peek 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_test_peek (object->data, message, address) < 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 ();
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
my_com_netsplit_Nih_Test_IsValidAddress_method (NihDBusObject * object,
NihDBusMessage *message)
{
DBusMessageIter iter;
DBusMessage * reply;
uint32_t address;
int is_valid;
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);
/* Demarshal a uint32_t from the message */
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_UINT32) {
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
"Invalid arguments to IsValidAddress 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;
}
dbus_message_iter_get_basic (&iter, &address);
dbus_message_iter_next (&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 IsValidAddress 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_test_is_valid_address (object->data, message, address, &is_valid) < 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 int onto the message */
if (! dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &is_valid)) {
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;
}
static void request_input_reply(DBusMessage *reply, void *user_data)
{
struct request_input_reply *pptp_reply = user_data;
const char *error = NULL;
char *username = NULL, *password = NULL;
char *key;
DBusMessageIter iter, dict;
DBG("provider %p", pptp_reply->provider);
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
error = dbus_message_get_error_name(reply);
goto done;
}
if (!vpn_agent_check_reply_has_dict(reply))
goto done;
dbus_message_iter_init(reply, &iter);
dbus_message_iter_recurse(&iter, &dict);
while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry, value;
const char *str;
dbus_message_iter_recurse(&dict, &entry);
if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
break;
dbus_message_iter_get_basic(&entry, &key);
if (g_str_equal(key, "Username")) {
dbus_message_iter_next(&entry);
if (dbus_message_iter_get_arg_type(&entry)
!= DBUS_TYPE_VARIANT)
break;
dbus_message_iter_recurse(&entry, &value);
if (dbus_message_iter_get_arg_type(&value)
!= DBUS_TYPE_STRING)
break;
dbus_message_iter_get_basic(&value, &str);
username = g_strdup(str);
}
if (g_str_equal(key, "Password")) {
dbus_message_iter_next(&entry);
if (dbus_message_iter_get_arg_type(&entry)
!= DBUS_TYPE_VARIANT)
break;
dbus_message_iter_recurse(&entry, &value);
if (dbus_message_iter_get_arg_type(&value)
!= DBUS_TYPE_STRING)
break;
dbus_message_iter_get_basic(&value, &str);
password = g_strdup(str);
}
dbus_message_iter_next(&dict);
}
done:
pptp_reply->callback(pptp_reply->provider, username, password, error,
pptp_reply->user_data);
g_free(username);
g_free(password);
g_free(pptp_reply);
}
CVariant CDBusUtil::ParseType(DBusMessageIter *itr)
{
CVariant value;
const char * string = NULL;
dbus_int32_t int32 = 0;
dbus_uint32_t uint32 = 0;
dbus_int64_t int64 = 0;
dbus_uint64_t uint64 = 0;
dbus_bool_t boolean = false;
double doublev = 0;
int type = dbus_message_iter_get_arg_type(itr);
switch (type)
{
case DBUS_TYPE_OBJECT_PATH:
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic(itr, &string);
value = string;
break;
case DBUS_TYPE_UINT32:
dbus_message_iter_get_basic(itr, &uint32);
value = (uint64_t)uint32;
break;
case DBUS_TYPE_BYTE:
case DBUS_TYPE_INT32:
dbus_message_iter_get_basic(itr, &int32);
value = (int64_t)int32;
break;
case DBUS_TYPE_UINT64:
dbus_message_iter_get_basic(itr, &uint64);
value = (uint64_t)uint64;
break;
case DBUS_TYPE_INT64:
dbus_message_iter_get_basic(itr, &int64);
value = (int64_t)int64;
break;
case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic(itr, &boolean);
value = (bool)boolean;
break;
case DBUS_TYPE_DOUBLE:
dbus_message_iter_get_basic(itr, &doublev);
value = (double)doublev;
break;
case DBUS_TYPE_ARRAY:
DBusMessageIter array;
dbus_message_iter_recurse(itr, &array);
value = CVariant::VariantTypeArray;
do
{
CVariant item = ParseType(&array);
if (!item.isNull())
value.push_back(item);
} while (dbus_message_iter_next(&array));
break;
}
return value;
}
static int pptp_notify(DBusMessage *msg, struct vpn_provider *provider)
{
DBusMessageIter iter, dict;
const char *reason, *key, *value;
char *addressv4 = NULL, *netmask = NULL, *gateway = NULL;
char *ifname = NULL, *nameservers = NULL;
struct connman_ipaddress *ipaddress = NULL;
dbus_message_iter_init(msg, &iter);
dbus_message_iter_get_basic(&iter, &reason);
dbus_message_iter_next(&iter);
if (!provider) {
connman_error("No provider found");
return VPN_STATE_FAILURE;
}
if (strcmp(reason, "auth failed") == 0) {
DBG("authentication failure");
vpn_provider_set_string(provider, "PPTP.User", NULL);
vpn_provider_set_string(provider, "PPTP.Password", NULL);
return VPN_STATE_AUTH_FAILURE;
}
if (strcmp(reason, "connect"))
return VPN_STATE_DISCONNECT;
dbus_message_iter_recurse(&iter, &dict);
while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry;
dbus_message_iter_recurse(&dict, &entry);
dbus_message_iter_get_basic(&entry, &key);
dbus_message_iter_next(&entry);
dbus_message_iter_get_basic(&entry, &value);
DBG("%s = %s", key, value);
if (!strcmp(key, "INTERNAL_IP4_ADDRESS"))
addressv4 = g_strdup(value);
if (!strcmp(key, "INTERNAL_IP4_NETMASK"))
netmask = g_strdup(value);
if (!strcmp(key, "INTERNAL_IP4_DNS"))
nameservers = g_strdup(value);
if (!strcmp(key, "INTERNAL_IFNAME"))
ifname = g_strdup(value);
dbus_message_iter_next(&dict);
}
if (vpn_set_ifname(provider, ifname) < 0) {
g_free(ifname);
g_free(addressv4);
g_free(netmask);
g_free(nameservers);
return VPN_STATE_FAILURE;
}
if (addressv4)
ipaddress = connman_ipaddress_alloc(AF_INET);
g_free(ifname);
if (!ipaddress) {
connman_error("No IP address for provider");
g_free(addressv4);
g_free(netmask);
g_free(nameservers);
return VPN_STATE_FAILURE;
}
value = vpn_provider_get_string(provider, "HostIP");
if (value) {
vpn_provider_set_string(provider, "Gateway", value);
gateway = g_strdup(value);
}
if (addressv4)
connman_ipaddress_set_ipv4(ipaddress, addressv4, netmask,
gateway);
vpn_provider_set_ipaddress(provider, ipaddress);
vpn_provider_set_nameservers(provider, nameservers);
g_free(addressv4);
g_free(netmask);
g_free(gateway);
g_free(nameservers);
connman_ipaddress_free(ipaddress);
return VPN_STATE_CONNECT;
}
static DBusMessage* dbus_read_servers_ex(DBusMessage *message)
{
DBusMessageIter iter, array_iter, string_iter;
DBusMessage *error = NULL;
const char *addr_err;
if (!dbus_message_iter_init(message, &iter))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
}
/* check that the message contains an array of arrays */
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected array of string arrays");
}
mark_dbus();
/* array_iter points to each "as" element in the outer array */
dbus_message_iter_recurse(&iter, &array_iter);
while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
{
const char *str = NULL;
union mysockaddr addr, source_addr;
char interface[IF_NAMESIZE];
char *str_addr;
/* check the types of the struct and its elements */
if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected inner array of strings");
break;
}
/* string_iter points to each "s" element in the inner array */
dbus_message_iter_recurse(&array_iter, &string_iter);
if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
{
/* no IP address given */
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected IP address");
break;
}
dbus_message_iter_get_basic(&string_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty IP address");
break;
}
memset(&addr, 0, sizeof(addr));
memset(&source_addr, 0, sizeof(source_addr));
memset(&interface, 0, sizeof(interface));
/* dup the string because it gets modified during parsing */
str_addr = strdup(str);
if (!str_addr)
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Out of memory parsing IP address");
break;
}
/* parse the IP address */
addr_err = parse_server(str_addr, &addr, &source_addr, &interface, NULL);
free(str_addr);
if (addr_err)
{
error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s': %s",
str, addr_err);
break;
}
/* jump past the address to the domain list (if any) */
dbus_message_iter_next (&string_iter);
/* parse domains and add each server/domain pair to the list */
do {
str = NULL;
if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
dbus_message_iter_get_basic(&string_iter, &str);
dbus_message_iter_next (&string_iter);
add_update_server(&addr, &source_addr, interface, str);
} while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
/* jump to next element in outer array */
dbus_message_iter_next(&array_iter);
}
cleanup_dbus();
return error;
}
static void dbus_read_servers(DBusMessage *message)
{
DBusMessageIter iter;
union mysockaddr addr, source_addr;
char *domain;
dbus_message_iter_init(message, &iter);
mark_dbus();
while (1)
{
int skip = 0;
if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_UINT32)
{
u32 a;
dbus_message_iter_get_basic(&iter, &a);
dbus_message_iter_next (&iter);
#ifdef HAVE_SOCKADDR_SA_LEN
source_addr.in.sin_len = addr.in.sin_len = sizeof(struct sockaddr_in);
#endif
addr.in.sin_addr.s_addr = ntohl(a);
source_addr.in.sin_family = addr.in.sin_family = AF_INET;
addr.in.sin_port = htons(NAMESERVER_PORT);
source_addr.in.sin_addr.s_addr = INADDR_ANY;
source_addr.in.sin_port = htons(daemon->query_port);
}
else if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_BYTE)
{
unsigned char p[sizeof(struct in6_addr)];
unsigned int i;
skip = 1;
for(i = 0; i < sizeof(struct in6_addr); i++)
{
dbus_message_iter_get_basic(&iter, &p[i]);
dbus_message_iter_next (&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE)
break;
}
#ifndef HAVE_IPV6
my_syslog(LOG_WARNING, _("attempt to set an IPv6 server address via DBus - no IPv6 support"));
#else
if (i == sizeof(struct in6_addr)-1)
{
memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr));
#ifdef HAVE_SOCKADDR_SA_LEN
source_addr.in6.sin6_len = addr.in6.sin6_len = sizeof(struct sockaddr_in6);
#endif
source_addr.in6.sin6_family = addr.in6.sin6_family = AF_INET6;
addr.in6.sin6_port = htons(NAMESERVER_PORT);
source_addr.in6.sin6_flowinfo = addr.in6.sin6_flowinfo = 0;
source_addr.in6.sin6_scope_id = addr.in6.sin6_scope_id = 0;
source_addr.in6.sin6_addr = in6addr_any;
source_addr.in6.sin6_port = htons(daemon->query_port);
skip = 0;
}
#endif
}
else
/* At the end */
break;
/* process each domain */
do {
if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
{
dbus_message_iter_get_basic(&iter, &domain);
dbus_message_iter_next (&iter);
}
else
domain = NULL;
if (!skip)
add_update_server(&addr, &source_addr, NULL, domain);
} while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING);
}
/* unlink and free anything still marked. */
cleanup_dbus();
}
static struct TRACK mediaplayer_get_track(const char *id) {
int current_type;
DBusMessage* msg;
DBusMessageIter args, array, dict, element, var, artist;
DBusPendingCall* pending;
static const char *prop="Metadata";
char player[256];
struct TRACK track={
"Unknown",
"Unknown",
"Unknown",
};
sprintf(player, "%s%s", mpris.base, id);
if(!(msg=dbus_message_new_method_call(player, mpris.object, dbus.interface_prop, "Get")))
return track;
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &mpris.interface_player)) {
dbus_message_unref(msg);
return track;
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &prop)) {
dbus_message_unref(msg);
return track;
}
if(!dbus_connection_send_with_reply(dbus.session.connection, msg, &pending, -1)) {
dbus_message_unref(msg);
return track;
}
if(!pending) {
dbus_message_unref(msg);
return track;
}
dbus_connection_flush(dbus.session.connection);
dbus_message_unref(msg);
dbus_pending_call_block(pending);
if(!(msg=dbus_pending_call_steal_reply(pending))) {
dbus_pending_call_unref(pending);
return track;
}
dbus_pending_call_unref(pending);
if(!dbus_message_iter_init(msg, &args)) {
dbus_message_unref(msg);
return track;
}
if(dbus_message_iter_get_arg_type(&args)!=DBUS_TYPE_VARIANT) {
dbus_message_unref(msg);
return track;
}
dbus_message_iter_recurse(&args, &array);
if(dbus_message_iter_get_arg_type(&array)!=DBUS_TYPE_ARRAY) {
dbus_message_unref(msg);
return track;
}
for(dbus_message_iter_recurse(&array, &dict); (current_type=dbus_message_iter_get_arg_type(&dict))!=DBUS_TYPE_INVALID; dbus_message_iter_next(&dict)) {
char *element_key, *element_value;
int element_type;
dbus_message_iter_recurse(&dict, &element);
if(dbus_message_iter_get_arg_type(&element)!=DBUS_TYPE_STRING)
continue;
dbus_message_iter_get_basic(&element, &element_key);
dbus_message_iter_next(&element);
if(dbus_message_iter_get_arg_type(&element)!=DBUS_TYPE_VARIANT)
continue;
dbus_message_iter_recurse(&element, &var);
element_type=dbus_message_iter_get_arg_type(&var);
if(element_type==DBUS_TYPE_STRING) {
dbus_message_iter_get_basic(&var, &element_value);
if(!strcmp(element_key, "xesam:album"))
snprintf(track.album, TRACK_ELEMENT_LENGTH, "%s", element_value);
else if(!strcmp(element_key, "xesam:title"))
snprintf(track.title, TRACK_ELEMENT_LENGTH, "%s", element_value);
} else if(element_type==DBUS_TYPE_ARRAY) {
/*just handle one artist for now*/
dbus_message_iter_recurse(&var, &artist);
if(dbus_message_iter_get_arg_type(&artist)!=DBUS_TYPE_STRING)
continue;
dbus_message_iter_get_basic(&artist, &element_value);
if(!strcmp(element_key, "xesam:artist"))
snprintf(track.artist, TRACK_ELEMENT_LENGTH, "%s", element_value);
}
}
dbus_message_unref(msg);
return track;
}
static void
do_iter (DBusMessageIter *iter)
{
static struct timeval album_time={0,0}, artist_time={0,0}, title_time={0,0}, now_time={0,0};
char *decoded;
int pos, len, i;
do
{
int type = dbus_message_iter_get_arg_type (iter);
const char *str;
if (type == DBUS_TYPE_INVALID)
break;
switch (type)
{
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic (iter, &str);
if(varian_now){
gettimeofday(&now_time,NULL);
mylog("DBUS>> %s : '%s'\n",last_string,str);
if((strcmp(ALBUM_STRING,last_string)==0) || (strcmp(ALBUM_STRING2,last_string)==0)){
strncpy(album,str,MAX_STR_LEN);
now_playing_changed=1;
if(now_time.tv_sec-artist_time.tv_sec>DBUS_INTERVAL) artist[0]='\0';
if(now_time.tv_sec-title_time.tv_sec >DBUS_INTERVAL) title[0]='\0';
album_time.tv_sec=now_time.tv_sec;
mylog("DBUS>> ALBUM='%s'\n",str);
}
else if((strcmp(TITLE_STRING,last_string)==0) || (strcmp(TITLE_STRING2,last_string)==0)){
strncpy(title,str,MAX_STR_LEN);
now_playing_changed=1;
if(now_time.tv_sec-artist_time.tv_sec>DBUS_INTERVAL) artist[0]='\0';
if(now_time.tv_sec-album_time.tv_sec >DBUS_INTERVAL) album[0]='\0';
title_time.tv_sec=now_time.tv_sec;
mylog("DBUS>> TITLE='%s'\n",str);
}
else if((strcmp(ARTIST_STRING,last_string)==0) || (strcmp(ARTIST_STRING2,last_string)==0)){
strncpy(artist,str,MAX_STR_LEN);
now_playing_changed=1;
if(now_time.tv_sec-album_time.tv_sec>DBUS_INTERVAL) album[0]='\0';
if(now_time.tv_sec-title_time.tv_sec>DBUS_INTERVAL) title[0]='\0';
artist_time.tv_sec=now_time.tv_sec;
mylog("DBUS>> ARTIST='%s'\n",str);
}
else if((now_playing_changed==0) &&
(strcmp(LOC_STRING,last_string)==0)){
decoded=url_decode(str);
len=strlen(decoded);
pos=0;
for(i=0;i<len;++i){
if(decoded[i]=='/')
pos=i+1;
}
strncpy(title,decoded+pos,MAX_STR_LEN);
free(decoded);
now_playing_changed=1;
}
}
strncpy(last_string,str,MAX_STR_LEN);
break;
case DBUS_TYPE_VARIANT:
{
DBusMessageIter subiter;
dbus_message_iter_recurse (iter, &subiter);
// printf ("variant:");
varian_now=1;
do_iter (&subiter);
varian_now=0;
break;
}
case DBUS_TYPE_ARRAY:
{
int current_type;
DBusMessageIter subiter;
dbus_message_iter_recurse (iter, &subiter);
// printf("[");
while ((current_type = dbus_message_iter_get_arg_type (&subiter))
!= DBUS_TYPE_INVALID)
{
do_iter (&subiter);
dbus_message_iter_next (&subiter);
// if (dbus_message_iter_get_arg_type (&subiter) != DBUS_TYPE_INVALID)
// printf (",");
}
// printf("]");
break;
}
case DBUS_TYPE_DICT_ENTRY:
{
DBusMessageIter subiter;
dbus_message_iter_recurse (iter, &subiter);
// printf("{");
do_iter (&subiter);
dbus_message_iter_next (&subiter);
do_iter (&subiter);
// printf("}");
break;
}
default:
break;
}
} while (dbus_message_iter_next (iter));
}
int indicator_music_init(Indicator *indicator) {
DBusMessage* msg;
DBusMessageIter args, element;
DBusPendingCall* pending;
char *player;
int current_type;
if(!dbus.session.connection)
return -1;
if(!(msg=dbus_message_new_method_call(dbus.interface, dbus.object, dbus.interface, "ListNames")))
return -1;
if(!dbus_connection_send_with_reply(dbus.session.connection, msg, &pending, -1)) {
dbus_connection_unref(dbus.session.connection);
return -1;
}
if(!pending) {
dbus_message_unref(msg);
dbus_connection_unref(dbus.session.connection);
return -1;
}
dbus_connection_flush(dbus.session.connection);
dbus_message_unref(msg);
dbus_pending_call_block(pending);
if(!(msg=dbus_pending_call_steal_reply(pending))) {
dbus_connection_unref(dbus.session.connection);
return -1;
}
dbus_pending_call_unref(pending);
if(!(dbus_message_iter_init(msg, &args)&&dbus_message_iter_get_arg_type(&args)==DBUS_TYPE_ARRAY)) {
dbus_message_unref(msg);
dbus_connection_unref(dbus.session.connection);
return -1;
}
for(dbus_message_iter_recurse(&args, &element); (current_type=dbus_message_iter_get_arg_type(&element))!=DBUS_TYPE_INVALID; dbus_message_iter_next(&element)) {
if(current_type!=DBUS_TYPE_STRING)
continue;
dbus_message_iter_get_basic(&element, &player);
if(!strncmp(player, mpris.base, strlen(mpris.base))) {
mediaplayer_register(player+strlen(mpris.base));
}
}
dbus_message_unref(msg);
dbus_bus_add_match(dbus.session.connection, "type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged'", &dbus.session.error);
dbus_connection_flush(dbus.session.connection);
if(dbus_error_is_set(&dbus.session.error)) {
dbus_connection_unref(dbus.session.connection);
mediaplayer_deregister_all();
return -1;
}
/*init alsa*/
snd_mixer_selem_id_alloca(&alsa.sid);
snd_mixer_selem_id_set_index(alsa.sid, alsa.mix_index);
snd_mixer_selem_id_set_name(alsa.sid, alsa.mix_name);
if((snd_mixer_open(&alsa.handle, 0))<0)
return -1;
if((snd_mixer_attach(alsa.handle, alsa.card))<0) {
snd_mixer_close(alsa.handle);
return -1;
}
if((snd_mixer_selem_register(alsa.handle, NULL, NULL))<0) {
snd_mixer_close(alsa.handle);
return -1;
}
if(snd_mixer_load(alsa.handle)<0) {
snd_mixer_close(alsa.handle);
return -1;
}
if(!(alsa.elem=snd_mixer_find_selem(alsa.handle, alsa.sid))) {
snd_mixer_close(alsa.handle);
return -1;
}
snd_mixer_selem_get_playback_volume_range (alsa.elem, &alsa.minv, &alsa.maxv);
return 0;
}
static GVariant *
dconf_dbus_to_gv (DBusMessageIter *iter,
GError **error)
{
gint arg_type;
arg_type = dbus_message_iter_get_arg_type (iter);
switch (dbus_message_iter_get_arg_type (iter))
{
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_boolean (value);
}
case DBUS_TYPE_BYTE:
{
guchar value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_byte (value);
}
case DBUS_TYPE_INT16:
{
gint16 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_int16 (value);
}
case DBUS_TYPE_UINT16:
{
guint16 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_uint16 (value);
}
case DBUS_TYPE_INT32:
{
gint32 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_int32 (value);
}
case DBUS_TYPE_UINT32:
{
guint32 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_uint32 (value);
}
case DBUS_TYPE_INT64:
{
gint64 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_int64 (value);
}
case DBUS_TYPE_UINT64:
{
guint64 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_uint64 (value);
}
case DBUS_TYPE_DOUBLE:
{
gdouble value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_double (value);
}
case DBUS_TYPE_STRING:
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_string (value);
}
case DBUS_TYPE_OBJECT_PATH:
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_object_path (value);
}
case DBUS_TYPE_SIGNATURE:
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_signature (value);
}
case DBUS_TYPE_VARIANT:
{
GVariantBuilder *builder;
GVariantClass class;
DBusMessageIter sub;
char *type;
GVariant *val;
dbus_message_iter_recurse (iter, &sub);
class = dbus_message_iter_get_arg_type (iter);
type = dbus_message_iter_get_signature (&sub);
builder = g_variant_builder_new (G_VARIANT_TYPE_VARIANT);
dbus_free (type);
while (dbus_message_iter_get_arg_type (&sub))
{
val = dconf_dbus_to_gv (&sub, error);
if (val == NULL)
{
g_variant_builder_cancel (builder);
goto fail;
}
g_variant_builder_add_value (builder, val);
dbus_message_iter_next (&sub);
}
return g_variant_builder_end (builder);
}
case DBUS_TYPE_ARRAY:
case DBUS_TYPE_STRUCT:
case DBUS_TYPE_DICT_ENTRY:
{
GVariantBuilder *builder;
GVariantClass class;
DBusMessageIter sub;
char *type;
GVariant *val;
dbus_message_iter_recurse (iter, &sub);
class = dbus_message_iter_get_arg_type (iter);
type = dbus_message_iter_get_signature (iter);
builder = g_variant_builder_new (G_VARIANT_TYPE (type));
dbus_free (type);
while (dbus_message_iter_get_arg_type (&sub))
{
val = dconf_dbus_to_gv (&sub, error);
if (val == NULL)
{
g_variant_builder_cancel (builder);
goto fail;
}
g_variant_builder_add_value (builder, val);
dbus_message_iter_next (&sub);
}
return g_variant_builder_end (builder);
}
default:
g_set_error (error,
G_DBUS_ERROR,
G_DBUS_ERROR_CONVERSION_FAILED,
_("Error serializing D-Bus message to GVariant. Unsupported arg type `%c' (%d)"),
arg_type,
arg_type);
goto fail;
}
g_assert_not_reached ();
fail:
return NULL;
}
static DBusMessage*
service_method_create_collection (GkdSecretService *self, DBusMessage *message)
{
GckBuilder builder = GCK_BUILDER_INIT;
DBusMessageIter iter, array;
GckAttributes *attrs;
GkdSecretCreate *create;
DBusMessage *reply;
const gchar *path;
const gchar *alias;
const char *caller;
const gchar *coll;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}s"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, &builder)) {
gck_builder_clear (&builder);
return dbus_message_new_error_printf (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties");
}
if (!dbus_message_iter_next (&iter))
g_return_val_if_reached (NULL);
dbus_message_iter_get_basic (&iter, &alias);
/* Empty alias is no alias */
if (alias) {
if (!alias[0]) {
alias = NULL;
} else if (!g_str_equal (alias, "default")) {
gck_builder_clear (&builder);
return dbus_message_new_error (message, DBUS_ERROR_NOT_SUPPORTED,
"Only the 'default' alias is supported");
}
}
gck_builder_add_boolean (&builder, CKA_TOKEN, TRUE);
attrs = gck_attributes_ref_sink (gck_builder_end (&builder));
/* Create the prompt object, for the password */
caller = dbus_message_get_sender (message);
create = gkd_secret_create_new (self, caller, attrs, alias);
gck_attributes_unref (attrs);
path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (create));
gkd_secret_service_publish_dispatch (self, caller,
GKD_SECRET_DISPATCH (create));
coll = "/";
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply,
DBUS_TYPE_OBJECT_PATH, &coll,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
g_object_unref (create);
return reply;
}
static int get_all_properties_by_unit_path(DBusConnection *conn, const char *unit_path, int(*callback)(const char *name, const char *value, void *arg), void *cbarg)
{
int ret = 1;
DBusMessage *msg = NULL;
DBusPendingCall *pending = NULL;
msg = dbus_message_new_method_call(
"org.freedesktop.systemd1",
unit_path,
"org.freedesktop.DBus.Properties",
"GetAll"
);
if (msg == NULL) {
dI("Failed to create dbus_message via dbus_message_new_method_call!\n");
goto cleanup;
}
DBusMessageIter args, property_iter;
const char *interface = "org.freedesktop.systemd1.Unit";
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &interface)) {
dI("Failed to append interface '%s' string parameter to dbus message!\n", interface);
goto cleanup;
}
if (!dbus_connection_send_with_reply(conn, msg, &pending, -1)) {
dI("Failed to send message via dbus!\n");
goto cleanup;
}
if (pending == NULL) {
dI("Invalid dbus pending call!\n");
goto cleanup;
}
dbus_connection_flush(conn);
dbus_message_unref(msg); msg = NULL;
dbus_pending_call_block(pending);
msg = dbus_pending_call_steal_reply(pending);
if (msg == NULL) {
dI("Failed to steal dbus pending call reply.\n");
goto cleanup;
}
dbus_pending_call_unref(pending); pending = NULL;
if (!dbus_message_iter_init(msg, &args)) {
dI("Failed to initialize iterator over received dbus message.\n");
goto cleanup;
}
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY && dbus_message_iter_get_element_type(&args) != DBUS_TYPE_DICT_ENTRY) {
dI("Expected array of dict_entry argument in reply. Instead received: %s.\n", dbus_message_type_to_string(dbus_message_iter_get_arg_type(&args)));
goto cleanup;
}
dbus_message_iter_recurse(&args, &property_iter);
do {
DBusMessageIter dict_entry, value_variant;
dbus_message_iter_recurse(&property_iter, &dict_entry);
if (dbus_message_iter_get_arg_type(&dict_entry) != DBUS_TYPE_STRING) {
dI("Expected string as key in dict_entry. Instead received: %s.\n", dbus_message_type_to_string(dbus_message_iter_get_arg_type(&dict_entry)));
goto cleanup;
}
_DBusBasicValue value;
dbus_message_iter_get_basic(&dict_entry, &value);
char *property_name = oscap_strdup(value.str);
if (dbus_message_iter_next(&dict_entry) == false) {
dW("Expected another field in dict_entry.");
oscap_free(property_name);
goto cleanup;
}
if (dbus_message_iter_get_arg_type(&dict_entry) != DBUS_TYPE_VARIANT) {
dI("Expected variant as value in dict_entry. Instead received: %s.\n", dbus_message_type_to_string(dbus_message_iter_get_arg_type(&dict_entry)));
oscap_free(property_name);
goto cleanup;
}
dbus_message_iter_recurse(&dict_entry, &value_variant);
int cbret = 0;
const int arg_type = dbus_message_iter_get_arg_type(&value_variant);
// DBUS_TYPE_ARRAY is a special case, we report each element as one value entry
if (arg_type == DBUS_TYPE_ARRAY) {
DBusMessageIter array;
dbus_message_iter_recurse(&value_variant, &array);
do {
char *element = dbus_value_to_string(&array);
if (element == NULL)
continue;
const int elementcbret = callback(property_name, element, cbarg);
if (elementcbret > cbret)
cbret = elementcbret;
oscap_free(element);
}
while (dbus_message_iter_next(&array));
}
else {
char *property_value = dbus_value_to_string(&value_variant);
cbret = callback(property_name, property_value, cbarg);
oscap_free(property_value);
}
oscap_free(property_name);
if (cbret != 0) {
goto cleanup;
}
}
while (dbus_message_iter_next(&property_iter));
dbus_message_unref(msg); msg = NULL;
ret = 0;
cleanup:
if (pending != NULL)
dbus_pending_call_unref(pending);
if (msg != NULL)
dbus_message_unref(msg);
return ret;
}
/**
* wpas_dbus_global_add_interface - Request registration of a network interface
* @message: Pointer to incoming dbus message
* @global: %wpa_supplicant global data structure
* Returns: The object path of the new interface object,
* or a dbus error message with more information
*
* Handler function for "addInterface" method call. Handles requests
* by dbus clients to register a network interface that wpa_supplicant
* will manage.
*/
DBusMessage * wpas_dbus_global_add_interface(DBusMessage *message,
struct wpa_global *global)
{
char *ifname = NULL;
char *driver = NULL;
char *driver_param = NULL;
char *confname = NULL;
char *bridge_ifname = NULL;
DBusMessage *reply = NULL;
DBusMessageIter iter;
dbus_message_iter_init(message, &iter);
/* First argument: interface name (DBUS_TYPE_STRING)
* Required; must be non-zero length
*/
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
goto error;
dbus_message_iter_get_basic(&iter, &ifname);
if (!os_strlen(ifname))
goto error;
/* Second argument: dict of options */
if (dbus_message_iter_next(&iter)) {
DBusMessageIter iter_dict;
struct wpa_dbus_dict_entry entry;
if (!wpa_dbus_dict_open_read(&iter, &iter_dict, NULL))
goto error;
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!strcmp(entry.key, "driver") &&
(entry.type == DBUS_TYPE_STRING)) {
driver = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (driver == NULL)
goto error;
} else if (!strcmp(entry.key, "driver-params") &&
(entry.type == DBUS_TYPE_STRING)) {
driver_param = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (driver_param == NULL)
goto error;
} else if (!strcmp(entry.key, "config-file") &&
(entry.type == DBUS_TYPE_STRING)) {
confname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (confname == NULL)
goto error;
} else if (!strcmp(entry.key, "bridge-ifname") &&
(entry.type == DBUS_TYPE_STRING)) {
bridge_ifname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (bridge_ifname == NULL)
goto error;
} else {
wpa_dbus_dict_entry_clear(&entry);
goto error;
}
}
}
/*
* Try to get the wpa_supplicant record for this iface, return
* an error if we already control it.
*/
if (wpa_supplicant_get_iface(global, ifname) != NULL) {
reply = dbus_message_new_error(message,
WPAS_ERROR_EXISTS_ERROR,
"wpa_supplicant already "
"controls this interface.");
} else {
struct wpa_supplicant *wpa_s;
struct wpa_interface iface;
os_memset(&iface, 0, sizeof(iface));
iface.ifname = ifname;
iface.driver = driver;
iface.driver_param = driver_param;
iface.confname = confname;
iface.bridge_ifname = bridge_ifname;
/* Otherwise, have wpa_supplicant attach to it. */
if ((wpa_s = wpa_supplicant_add_iface(global, &iface))) {
const char *path = wpa_s->dbus_path;
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
&path, DBUS_TYPE_INVALID);
} else {
reply = dbus_message_new_error(message,
WPAS_ERROR_ADD_ERROR,
"wpa_supplicant "
"couldn't grab this "
"interface.");
}
}
out:
os_free(driver);
os_free(driver_param);
os_free(confname);
os_free(bridge_ifname);
return reply;
error:
reply = wpas_dbus_new_invalid_opts_error(message, NULL);
goto out;
}
/**
* Listens for signals on the bus
*/
int sedbus_send_avc(DBusConnection* conn, char *avc) {
DBusMessage* msg;
DBusMessageIter args;
DBusPendingCall* pending;
char* reply = NULL;
msg = dbus_message_new_method_call(BUSNAME,
PATH,
INTERFACE,
"avc"); // method name
if (NULL == msg) {
fprintf(stderr, "Can't communicate with setroubleshootd\n");
return -1;
}
// append arguments
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &avc)) {
fprintf(stderr, "Out Of Memory!\n");
return -1;
}
// send message and get a handle for a reply
if ( ! dbus_connection_send_with_reply (conn, msg, &pending, -1)) {
// -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
return -1;
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
return -1;
}
dbus_connection_flush(conn);
// free message
dbus_message_unref(msg);
// block until we receive a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
exit(1);
}
// free the pending message handle
dbus_pending_call_unref(pending);
// read the parameters
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not boolean!\n");
else
dbus_message_iter_get_basic(&args, &reply);
printf("Send: %s\n", avc);
printf("Got Reply: %s\n", reply);
// free reply and close connection
dbus_message_unref(msg);
return 0;
}
/**
* Listens for signals on the bus
*/
void receive()
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
int ret;
char* sigvalue;
printf("Listening for signals\n");
// initialise the errors
dbus_error_init(&err);
// connect to the bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
exit(1);
}
// request our name on the bus and check for errors
ret = dbus_bus_request_name(conn, "test.signal.sink", DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Name Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
exit(1);
}
// add a rule for which messages we want to see
dbus_bus_add_match(conn, "type='signal',interface='test.signal.Type'", &err); // see signals from the given interface
dbus_connection_flush(conn);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Match Error (%s)\n", err.message);
exit(1);
}
printf("Match rule sent\n");
// loop listening for signals being emmitted
while (true) {
// non blocking read of the next available message
dbus_connection_read_write(conn, 0);
msg = dbus_connection_pop_message(conn);
// loop again if we haven't read a message
if (NULL == msg) {
sleep(1);
continue;
}
// check if the message is a signal from the correct interface and with the correct name
if (dbus_message_is_signal(msg, "test.signal.Type", "Test")) {
// read the parameters
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message Has No Parameters\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not string!\n");
else
dbus_message_iter_get_basic(&args, &sigvalue);
printf("Got Signal with value %s\n", sigvalue);
}
// free the message
dbus_message_unref(msg);
}
}
static DBusHandlerResult
mafw_proxy_source_dispatch_message(DBusConnection *conn,
DBusMessage *msg,
MafwProxySource *self)
{
MafwProxySourcePrivate *priv;
gchar *domain_str;
gint code;
gchar *message;
GError *error = NULL;
g_assert(conn != NULL);
g_assert(msg != NULL);
priv = MAFW_PROXY_SOURCE_GET_PRIVATE(self);
if (dbus_message_has_interface(msg, MAFW_EXTENSION_INTERFACE))
return proxy_extension_dispatch(conn, msg, self);
if (dbus_message_has_member(msg,
MAFW_PROXY_SOURCE_METHOD_BROWSE_RESULT)) {
MafwProxySourceBrowseReq *new_req = NULL;
guint browse_id;
gint remaining_count;
guint index;
gchar *object_id;
GHashTable *metadata;
DBusMessageIter imsg, iary, istr;
g_return_val_if_fail(
priv->browse_requests != NULL,
DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
dbus_message_iter_init(msg, &imsg);
dbus_message_iter_get_basic(&imsg, &browse_id);
dbus_message_iter_next(&imsg);
g_assert(dbus_message_iter_get_arg_type(&imsg) ==
DBUS_TYPE_ARRAY);
dbus_message_iter_recurse(&imsg, &iary);
while (dbus_message_iter_get_arg_type(&iary) !=
DBUS_TYPE_INVALID)
{
dbus_message_iter_recurse(&iary, &istr);
g_assert(dbus_message_iter_get_arg_type(&istr)
== DBUS_TYPE_INT32);
dbus_message_iter_get_basic(&istr,
&remaining_count);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &index);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &object_id);
dbus_message_iter_next(&istr);
mafw_dbus_message_parse_metadata(&istr,
&metadata);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &domain_str);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &code);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &message);
if (domain_str && domain_str[0])
g_set_error(&error,
g_quark_from_string(domain_str),
code, "%s", message);
dbus_message_iter_next(&iary);
if (!new_req)
{
new_req = g_hash_table_lookup(
priv->browse_requests,
GUINT_TO_POINTER(browse_id));
if (new_req)
new_req->emitting = TRUE;
}
if (new_req) {
new_req->browse_cb(MAFW_SOURCE(self),
browse_id,
remaining_count,
index,
object_id[0] ?
object_id :
NULL,
metadata,
new_req->user_data,
error);
if (remaining_count == 0 || new_req->stop_emitting)
{
g_hash_table_remove(
priv->browse_requests,
GUINT_TO_POINTER(browse_id));
new_req = NULL;
g_clear_error(&error);
mafw_metadata_release(metadata);
break;
}
}
else
{
g_clear_error(&error);
mafw_metadata_release(metadata);
break;
}
g_clear_error(&error);
mafw_metadata_release(metadata);
}
if (new_req) {
new_req->emitting = FALSE;
}
return DBUS_HANDLER_RESULT_HANDLED;
} else if (!dbus_message_has_path(msg,
proxy_extension_return_path(self))) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_METADATA_CHANGED)) {
return handle_metadata_changed_signal(self, msg);
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_CONTAINER_CHANGED)) {
return handle_container_changed_signal(self, msg);
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_UPDATING)) {
return handle_updating_signal(self, msg);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
GList *
systemd_unit_listall(void)
{
int lpc = 0;
GList *units = NULL;
DBusMessageIter args;
DBusMessageIter unit;
DBusMessageIter elem;
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
const char *method = "ListUnits";
DBusError error;
if (systemd_init() == FALSE) {
return NULL;
}
/*
" <method name=\"ListUnits\">\n" \
" <arg name=\"units\" type=\"a(ssssssouso)\" direction=\"out\"/>\n" \
" </method>\n" \
*/
dbus_error_init(&error);
msg = systemd_new_method(BUS_NAME".Manager", method);
CRM_ASSERT(msg != NULL);
reply = pcmk_dbus_send_recv(msg, systemd_proxy, &error);
dbus_message_unref(msg);
if(error.name) {
crm_err("Call to %s failed: %s", method, error.name);
return NULL;
} else if (reply == NULL) {
crm_err("Call to %s failed: Message has no reply", method);
return NULL;
} else if (!dbus_message_iter_init(reply, &args)) {
crm_err("Call to %s failed: Message has no arguments", method);
dbus_message_unref(reply);
return NULL;
}
if(!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY, __FUNCTION__, __LINE__)) {
crm_err("Call to %s failed: Message has invalid arguments", method);
dbus_message_unref(reply);
return NULL;
}
dbus_message_iter_recurse(&args, &unit);
while (dbus_message_iter_get_arg_type (&unit) != DBUS_TYPE_INVALID) {
DBusBasicValue value;
if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_STRUCT, __FUNCTION__, __LINE__)) {
continue;
}
dbus_message_iter_recurse(&unit, &elem);
if(!pcmk_dbus_type_check(reply, &elem, DBUS_TYPE_STRING, __FUNCTION__, __LINE__)) {
continue;
}
dbus_message_iter_get_basic(&elem, &value);
crm_trace("Got: %s", value.str);
if(value.str) {
char *match = strstr(value.str, ".service");
if (match) {
lpc++;
match[0] = 0;
units = g_list_append(units, strdup(value.str));
}
}
dbus_message_iter_next (&unit);
}
dbus_message_unref(reply);
crm_trace("Found %d systemd services", lpc);
return units;
}
/* MafwSource::get_metadatas */
static void got_metadatas(DBusPendingCall *pendelum, RequestReplyInfo *info)
{
GError *error;
DBusMessage *msg;
msg = dbus_pending_call_steal_reply(pendelum);
if (!(error = mafw_dbus_is_error(msg, MAFW_SOURCE_ERROR))) {
gchar *object_id;
GHashTable *cur_metadata, *metadatas = NULL;
DBusMessageIter imsg, iary, istr;
GError *error = NULL;
gchar *domain_str;
gint code;
gchar *message;
dbus_message_iter_init(msg, &imsg);
if (dbus_message_iter_get_arg_type(&imsg) == DBUS_TYPE_ARRAY)
{
dbus_message_iter_recurse(&imsg, &iary);
metadatas =
g_hash_table_new_full(
g_str_hash,
g_str_equal,
(GDestroyNotify)g_free,
(GDestroyNotify)mafw_metadata_release);
while (dbus_message_iter_get_arg_type(&iary) !=
DBUS_TYPE_INVALID)
{
dbus_message_iter_recurse(&iary, &istr);
dbus_message_iter_get_basic(&istr, &object_id);
dbus_message_iter_next(&istr);
mafw_dbus_message_parse_metadata(&istr,
&cur_metadata);
g_hash_table_insert(metadatas,
g_strdup(object_id),
cur_metadata);
dbus_message_iter_next(&iary);
}
dbus_message_iter_next(&imsg);
}
dbus_message_iter_get_basic(&imsg, &domain_str);
dbus_message_iter_next(&imsg);
dbus_message_iter_get_basic(&imsg, &code);
dbus_message_iter_next(&imsg);
dbus_message_iter_get_basic(&imsg, &message);
if (domain_str && domain_str[0])
g_set_error(&error,
g_quark_from_string(domain_str),
code, "%s", message);
info->got_metadatas_cb(info->src,
metadatas,
info->cbdata, error);
if (metadatas)
g_hash_table_unref(metadatas);
} else {
info->got_metadatas_cb(info->src,
NULL,
info->cbdata, error);
g_error_free(error);
}
dbus_message_unref(msg);
dbus_pending_call_unref(pendelum);
}
void PulseAudioControl::update()
{
openConnection();
if (dbusConnection == NULL) {
return;
}
DBusError error;
dbus_error_init(&error);
DBusMessage *reply = NULL;
DBusMessage *msg = dbus_message_new_method_call(VOLUME_SERVICE, VOLUME_PATH, "org.freedesktop.DBus.Properties", "GetAll");
if (msg != NULL) {
dbus_message_append_args(msg, DBUS_TYPE_STRING, &VOLUME_INTERFACE, DBUS_TYPE_INVALID);
reply = dbus_connection_send_with_reply_and_block(dbusConnection, msg, -1, &error);
DBUS_ERR_CHECK (error);
dbus_message_unref(msg);
}
int currentStep = -1, stepCount = -1;
if (reply != NULL) {
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN) {
DBusMessageIter iter;
dbus_message_iter_init(reply, &iter);
// Recurse into the array [array of dicts]
while (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INVALID) {
DBusMessageIter dict_entry;
dbus_message_iter_recurse(&iter, &dict_entry);
// Recurse into the dict [ dict_entry (string, variant(int)) ]
while (dbus_message_iter_get_arg_type(&dict_entry) != DBUS_TYPE_INVALID) {
DBusMessageIter in_dict;
// Recurse into the dict_entry [ string, variant(int) ]
dbus_message_iter_recurse(&dict_entry, &in_dict);
{
char *prop_name = NULL;
// Get the string value, "property name"
dbus_message_iter_get_basic(&in_dict, &prop_name);
dbus_message_iter_next(&in_dict);
DBusMessageIter variant;
// Recurse into the variant [ variant(int) ]
dbus_message_iter_recurse(&in_dict, &variant);
quint32 value;
// Get the variant value which is uint32
dbus_message_iter_get_basic(&variant, &value);
if (prop_name && strcmp(prop_name, "StepCount") == 0) {
stepCount = value;
} else if (prop_name && strcmp(prop_name, "CurrentStep") == 0) {
currentStep = value;
}
}
dbus_message_iter_next(&dict_entry);
}
dbus_message_iter_next(&iter);
}
}
dbus_message_unref(reply);
}
if (currentStep != -1 && stepCount != -1) {
setSteps(currentStep, stepCount);
}
}
static DBusHandlerResult locale_message_handler(
DBusConnection *connection,
DBusMessage *message,
void *userdata) {
DBusMessage *reply = NULL, *changed = NULL;
DBusError error;
int r;
assert(connection);
assert(message);
dbus_error_init(&error);
if (dbus_message_is_method_call(message, "org.freedesktop.locale1", "SetLocale")) {
char **l = NULL, **i;
dbus_bool_t interactive;
DBusMessageIter iter;
bool modified = false;
bool passed[_PROP_MAX];
int p;
if (!dbus_message_iter_init(message, &iter))
return bus_send_error_reply(connection, message, NULL, -EINVAL);
r = bus_parse_strv_iter(&iter, &l);
if (r < 0) {
if (r == -ENOMEM)
goto oom;
return bus_send_error_reply(connection, message, NULL, r);
}
if (!dbus_message_iter_next(&iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN) {
strv_free(l);
return bus_send_error_reply(connection, message, NULL, -EINVAL);
}
dbus_message_iter_get_basic(&iter, &interactive);
zero(passed);
/* Check whether a variable changed and if so valid */
STRV_FOREACH(i, l) {
bool valid = false;
for (p = 0; p < _PROP_MAX; p++) {
size_t k;
k = strlen(names[p]);
if (startswith(*i, names[p]) &&
(*i)[k] == '=' &&
string_is_safe((*i) + k + 1)) {
valid = true;
passed[p] = true;
if (!streq_ptr(*i + k + 1, data[p]))
modified = true;
break;
}
}
if (!valid) {
strv_free(l);
return bus_send_error_reply(connection, message, NULL, -EINVAL);
}
}
static GConfSchema *
utils_get_schema (DBusMessageIter *main_iter)
{
DBusMessageIter struct_iter;
gint32 type, list_type, car_type, cdr_type;
const gchar *locale, *short_desc, *long_desc, *owner;
const gchar *encoded;
GConfSchema *schema;
GConfValue *default_value;
g_assert (dbus_message_iter_get_arg_type (main_iter) == DBUS_TYPE_STRUCT);
dbus_message_iter_recurse (main_iter, &struct_iter);
dbus_message_iter_get_basic (&struct_iter, &type);
dbus_message_iter_next (&struct_iter);
dbus_message_iter_get_basic (&struct_iter, &list_type);
dbus_message_iter_next (&struct_iter);
dbus_message_iter_get_basic (&struct_iter, &car_type);
dbus_message_iter_next (&struct_iter);
dbus_message_iter_get_basic (&struct_iter, &cdr_type);
dbus_message_iter_next (&struct_iter);
locale = utils_get_optional_string (&struct_iter);
dbus_message_iter_next (&struct_iter);
short_desc = utils_get_optional_string (&struct_iter);
dbus_message_iter_next (&struct_iter);
long_desc = utils_get_optional_string (&struct_iter);
dbus_message_iter_next (&struct_iter);
owner = utils_get_optional_string (&struct_iter);
dbus_message_iter_next (&struct_iter);
dbus_message_iter_get_basic (&struct_iter, &encoded);
schema = gconf_schema_new ();
gconf_schema_set_type (schema, type);
gconf_schema_set_list_type (schema, list_type);
gconf_schema_set_car_type (schema, car_type);
gconf_schema_set_cdr_type (schema, cdr_type);
if (locale)
gconf_schema_set_locale (schema, locale);
if (short_desc)
gconf_schema_set_short_desc (schema, short_desc);
if (long_desc)
gconf_schema_set_long_desc (schema, long_desc);
if (owner)
gconf_schema_set_owner (schema, owner);
if (*encoded != '\0')
{
default_value = gconf_value_decode (encoded);
if (default_value)
gconf_schema_set_default_value_nocopy (schema, default_value);
}
return schema;
}
int __connman_session_create(DBusMessage *msg)
{
const char *owner, *notify_path;
char *session_path = NULL;
DBusMessageIter iter, array;
struct connman_session *session = NULL;
struct creation_data *creation_data = NULL;
bool user_allowed_bearers = false;
bool user_connection_type = false;
int err, i;
char *str;
owner = dbus_message_get_sender(msg);
DBG("owner %s", owner);
if (ecall_session && ecall_session->ecall) {
/*
* If there is an emergency call already going on,
* ignore session creation attempt
*/
err = -EBUSY;
goto err;
}
creation_data = g_try_new0(struct creation_data, 1);
if (!creation_data) {
err = -ENOMEM;
goto err;
}
creation_data->pending = dbus_message_ref(msg);
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &array);
while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry, value;
const char *key, *val;
dbus_message_iter_recurse(&array, &entry);
dbus_message_iter_get_basic(&entry, &key);
dbus_message_iter_next(&entry);
dbus_message_iter_recurse(&entry, &value);
switch (dbus_message_iter_get_arg_type(&value)) {
case DBUS_TYPE_ARRAY:
if (g_str_equal(key, "AllowedBearers")) {
err = parse_bearers(&value,
&creation_data->allowed_bearers);
if (err < 0)
goto err;
user_allowed_bearers = true;
} else {
err = -EINVAL;
goto err;
}
break;
case DBUS_TYPE_STRING:
if (g_str_equal(key, "ConnectionType")) {
dbus_message_iter_get_basic(&value, &val);
creation_data->type =
connman_session_parse_connection_type(val);
user_connection_type = true;
} else if (g_str_equal(key, "ContextIdentifier")) {
dbus_message_iter_get_basic(&value, &val);
creation_data->context_identifier = g_strdup(val);
} else if (g_str_equal(key, "AllowedInterface")) {
dbus_message_iter_get_basic(&value, &val);
creation_data->allowed_interface = g_strdup(val);
} else {
err = -EINVAL;
goto err;
}
break;
case DBUS_TYPE_BOOLEAN:
if (g_str_equal(key, "SourceIPRule")) {
dbus_bool_t source_ip_rule;
dbus_message_iter_get_basic(&value, &source_ip_rule);
creation_data->source_ip_rule = source_ip_rule;
} else {
err = -EINVAL;
goto err;
}
break;
default:
err = -EINVAL;
goto err;
}
dbus_message_iter_next(&array);
}
/*
* If the user hasn't provided a configuration, we set
* the default configuration.
*
* For AllowedBearers this is '*', ...
*/
if (!user_allowed_bearers) {
add_default_bearer_types(&creation_data->allowed_bearers);
if (!creation_data->allowed_bearers) {
err = -ENOMEM;
goto err;
}
}
/* ... and for ConnectionType it is 'any'. */
if (!user_connection_type)
creation_data->type = CONNMAN_SESSION_TYPE_ANY;
dbus_message_iter_next(&iter);
dbus_message_iter_get_basic(&iter, ¬ify_path);
if (!notify_path) {
err = -EINVAL;
goto err;
}
str = g_strdup(owner);
for (i = 0; str[i] != '\0'; i++)
if (str[i] == ':' || str[i] == '.')
str[i] = '_';
session_path = g_strdup_printf("/sessions/%s%s", str, notify_path);
g_free(str);
if (!session_path) {
err = -ENOMEM;
goto err;
}
session = g_hash_table_lookup(session_hash, session_path);
if (session) {
g_free(session_path);
session = NULL;
err = -EEXIST;
goto err;
}
session = g_try_new0(struct connman_session, 1);
if (!session) {
g_free(session_path);
err = -ENOMEM;
goto err;
}
creation_data->session = session;
session->session_path = session_path;
session->info = g_try_new0(struct session_info, 1);
if (!session->info) {
err = -ENOMEM;
goto err;
}
session->info_last = g_try_new0(struct session_info, 1);
if (!session->info_last) {
err = -ENOMEM;
goto err;
}
session->owner = g_strdup(owner);
session->notify_path = g_strdup(notify_path);
session->notify_watch =
g_dbus_add_disconnect_watch(connection, session->owner,
owner_disconnect, session, NULL);
err = create_policy_config(session, session_policy_config_cb,
creation_data);
if (err < 0 && err != -EINPROGRESS)
return err;
return -EINPROGRESS;
err:
connman_error("Failed to create session");
free_session(session);
cleanup_creation_data(creation_data);
return err;
}
