EXPORT_C
dbus_bool_t
_dbus_server_test (void)
{
const char *valid_addresses[] = {
"tcp:port=1234",
// #ifndef __SYMBIAN32__
"unix:path=./boogie",
// #endif
"tcp:host=localhost,port=1234",
"tcp:host=localhost,port=1234;tcp:port=5678",
"tcp:port=1234;unix:path=./boogie",
};
DBusServer *server;
int i;
for (i = 0; i < _DBUS_N_ELEMENTS (valid_addresses); i++)
{
DBusError error;
/* FIXME um, how are the two tests here different? */
dbus_error_init (&error);
server = dbus_server_listen (valid_addresses[i], &error);
if (server == NULL)
{
_dbus_warn ("server listen error: %s: %s\n", error.name, error.message);
dbus_error_free (&error);
_dbus_assert_not_reached ("Failed to listen for valid address.");
}
#ifdef __SYMBIAN32__
if(server!=NULL)
{
dbus_server_disconnect (server);
dbus_server_unref (server);
}
#else
dbus_server_disconnect (server);
dbus_server_unref (server);
#endif
/* Try disconnecting before unreffing */
server = dbus_server_listen (valid_addresses[i], &error);
if (server == NULL)
{
_dbus_warn ("server listen error: %s: %s\n", error.name, error.message);
dbus_error_free (&error);
_dbus_assert_not_reached ("Failed to listen for valid address.");
}
#ifdef __SYMBIAN32__
if(server!=NULL)
{
dbus_server_disconnect (server);
dbus_server_unref (server);
}
#else
dbus_server_disconnect (server);
dbus_server_unref (server);
#endif
}
return TRUE;
}
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);
}
/**
* Connects to the D-Bus system bus daemon and issues the method call
* OpenSession on the ConsoleKit manager interface. The
* connection to the bus is private.
*
* Returns FALSE on OOM, if the system bus daemon is not running, if
* the ConsoleKit daemon is not running or if the caller doesn't have
* sufficient privileges.
*
* @returns #TRUE if the operation succeeds
*/
dbus_bool_t
ck_connector_open_session (CkConnector *connector,
DBusError *error)
{
DBusError local_error;
DBusMessage *message;
DBusMessage *reply;
dbus_bool_t ret;
char *cookie;
_ck_return_val_if_fail (connector != NULL, FALSE);
_ck_return_val_if_fail ((error) == NULL || !dbus_error_is_set ((error)), 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",
"OpenSession");
if (message == NULL) {
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;
}
char* get_service_browser_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;
char *type = "_http._tcp";
char *domain = "local";
dbus_uint32_t flags = 0;
char *service_browser_path;
// initialiset the errors
printf("Calling remote method: %s\n", "org.freedesktop.Avahi");
// 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
"/", // object to call on
"org.freedesktop.Avahi.Server", // interface to call on
"ServiceBrowserNew"); // 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_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_UINT32, &flags))
{
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_OBJECT_PATH != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not boolean!\n");
else
dbus_message_iter_get_basic(&args, &service_browser_path);
printf("Got Reply: %s\n", service_browser_path);
dbus_message_unref(msg);
return service_browser_path;
}
void signal_ServiceBrowser_item(char *path){
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
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);
}
gchar* filter_itemnew = g_new(gchar, strlen("type='signal',interface='org.freedesktop.Avahi.ServiceBrowser',member='ItemNew', path=''") + strlen(path) + 2);
sprintf(filter_itemnew, "type='signal',interface='org.freedesktop.Avahi.ServiceBrowser',member='ItemNew', path='%s'", path);
gchar* filter_itemremove = g_new(gchar, strlen("type='signal',interface='org.freedesktop.Avahi.ServiceBrowser',member='ItemRemove', path=''") + strlen(path) + 2);
sprintf(filter_itemremove, "type='signal',interface='org.freedesktop.Avahi.ServiceBrowser',member='ItemRemove', path='%s'", path);
//printf("signal_filter:%s", signal_filter);
// add a rule for which messages we want to see
dbus_bus_add_match(conn, filter_itemnew, &err);
dbus_bus_add_match(conn, filter_itemremove, &err);
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");
int interface;
int protocol;
char *name;
char *stype;
char *domain;
unsigned int flags;
//int cnt = 0;
// 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) {
//g_message("cnt: %d", cnt++);
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, "org.freedesktop.Avahi.ServiceBrowser", "ItemNew")) {
// read the parameters
//g_message("is the message we need.%d", cnt++);
//g_message("Message Has No Parameters\n");
if (!dbus_message_iter_init(msg, &args))
g_message("dbus_message_iter_init fail\n");
else
{
if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message( "Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &interface);
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &protocol);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &name);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &stype);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &domain);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &flags);
printf("\n");
printf("discovered:%d, %d, %s, %s, %s, %d.\n", interface, protocol, name, stype, domain, flags);
resolve_service(interface, protocol, name, stype, domain);
//printf("Got Signal with value %s\n", sigvalue);
}
}else if(dbus_message_is_signal(msg, "org.freedesktop.Avahi.ServiceBrowser", "ItemRemove")){
if (!dbus_message_iter_init(msg, &args))
g_message("dbus_message_iter_init fail\n");
else
{
if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message( "Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &interface);
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &protocol);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &name);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &stype);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &domain);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &flags);
printf("\n");
printf("removed:%d, %d, %s, %s, %s, %d.\n", interface, protocol, name, stype, domain, flags);
//resolve_service(interface, protocol, name, stype, domain);
//printf("Got Signal with value %s\n", sigvalue);
}
}
// free the message
dbus_message_unref(msg);
}
}
static ReadStatus
read_data (DBusBabysitter *sitter,
int fd)
{
int what;
int got;
DBusError error = DBUS_ERROR_INIT;
ReadStatus r;
r = read_ints (fd, &what, 1, &got, &error);
switch (r)
{
case READ_STATUS_ERROR:
_dbus_warn ("Failed to read data from fd %d: %s\n", fd, error.message);
dbus_error_free (&error);
return r;
case READ_STATUS_EOF:
return r;
case READ_STATUS_OK:
break;
}
if (got == 1)
{
switch (what)
{
case CHILD_EXITED:
case CHILD_FORK_FAILED:
case CHILD_EXEC_FAILED:
{
int arg;
r = read_ints (fd, &arg, 1, &got, &error);
switch (r)
{
case READ_STATUS_ERROR:
_dbus_warn ("Failed to read arg from fd %d: %s\n", fd, error.message);
dbus_error_free (&error);
return r;
case READ_STATUS_EOF:
return r;
case READ_STATUS_OK:
break;
}
if (got == 1)
{
if (what == CHILD_EXITED)
{
sitter->have_child_status = TRUE;
sitter->status = arg;
sitter->errnum = 0;
_dbus_verbose ("recorded child status exited = %d signaled = %d exitstatus = %d termsig = %d\n",
WIFEXITED (sitter->status), WIFSIGNALED (sitter->status),
WEXITSTATUS (sitter->status), WTERMSIG (sitter->status));
}
else if (what == CHILD_FORK_FAILED)
{
sitter->have_fork_errnum = TRUE;
sitter->errnum = arg;
_dbus_verbose ("recorded fork errnum %d\n", sitter->errnum);
}
else if (what == CHILD_EXEC_FAILED)
{
sitter->have_exec_errnum = TRUE;
sitter->errnum = arg;
_dbus_verbose ("recorded exec errnum %d\n", sitter->errnum);
}
}
}
break;
case CHILD_PID:
{
pid_t pid = -1;
r = read_pid (fd, &pid, &error);
switch (r)
{
case READ_STATUS_ERROR:
_dbus_warn ("Failed to read PID from fd %d: %s\n", fd, error.message);
dbus_error_free (&error);
return r;
case READ_STATUS_EOF:
return r;
case READ_STATUS_OK:
break;
}
sitter->grandchild_pid = pid;
_dbus_verbose ("recorded grandchild pid %d\n", sitter->grandchild_pid);
}
break;
default:
_dbus_warn ("Unknown message received from babysitter process\n");
break;
}
}
return r;
}
static void
force_unmount (LibHalContext *ctx, const char *udi)
{
DBusError error;
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
char **options = NULL;
unsigned int num_options = 0;
DBusConnection *dbus_connection;
char *device_file;
dbus_connection = libhal_ctx_get_dbus_connection (ctx);
msg = dbus_message_new_method_call ("org.freedesktop.Hal", udi,
"org.freedesktop.Hal.Device.Volume",
"Unmount");
if (msg == NULL) {
HAL_ERROR (("Could not create dbus message for %s", udi));
goto out;
}
options = calloc (1, sizeof (char *));
if (options == NULL) {
HAL_ERROR (("Could not allocate options array"));
goto out;
}
options[0] = "lazy";
num_options = 1;
device_file = libhal_device_get_property_string (ctx, udi, "block.device", NULL);
if (device_file != NULL) {
HAL_INFO(("forcibly attempting to lazy unmount %s as media was removed", device_file));
libhal_free_string (device_file);
}
if (!dbus_message_append_args (msg,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &options, num_options,
DBUS_TYPE_INVALID)) {
HAL_ERROR (("Could not append args to dbus message for %s", udi));
goto out;
}
dbus_error_init (&error);
if (!(reply = dbus_connection_send_with_reply_and_block (dbus_connection, msg, -1, &error))) {
HAL_ERROR (("Unmount failed for %s: %s : %s\n", udi, error.name, error.message));
dbus_error_free (&error);
goto out;
}
if (dbus_error_is_set (&error)) {
HAL_ERROR (("Unmount failed for %s\n%s : %s\n", udi, error.name, error.message));
dbus_error_free (&error);
goto out;
}
HAL_DEBUG (("Succesfully unmounted udi '%s'", udi));
out:
if (options != NULL)
free (options);
if (msg != NULL)
dbus_message_unref (msg);
if (reply != NULL)
dbus_message_unref (reply);
}
/**
* main:
* @argc: Number of arguments given to program
* @argv: Arguments given to program
*
* Returns: Return code
*
* Main entry point
*/
int
main (int argc, char *argv[])
{
dbus_bool_t rc = 0;
char *udi = NULL;
char *key = NULL;
char *str_value = NULL;
dbus_int32_t int_value = 0;
dbus_uint64_t uint64_value = 0;
double double_value = 0.0f;
dbus_bool_t bool_value = TRUE;
dbus_bool_t remove = FALSE;
dbus_bool_t is_version = FALSE;
int type = PROP_INVALID;
DBusError error;
dbus_bool_t direct = FALSE;
if (argc <= 1) {
usage (argc, argv);
return 1;
}
while (1) {
int c;
int option_index = 0;
const char *opt;
static struct option long_options[] = {
{"udi", 1, NULL, 0},
{"key", 1, NULL, 0},
{"int", 1, NULL, 0},
{"uint64", 1, NULL, 0},
{"string", 1, NULL, 0},
{"double", 1, NULL, 0},
{"bool", 1, NULL, 0},
{"strlist-pre", 1, NULL, 0},
{"strlist-post", 1, NULL, 0},
{"strlist-rem", 1, NULL, 0},
{"direct", 0, NULL, 0},
{"remove", 0, NULL, 0},
{"version", 0, NULL, 0},
{"help", 0, NULL, 0},
{NULL, 0, NULL, 0}
};
c = getopt_long (argc, argv, "",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0:
opt = long_options[option_index].name;
if (strcmp (opt, "help") == 0) {
usage (argc, argv);
return 0;
} else if (strcmp (opt, "key") == 0) {
key = strdup (optarg);
} else if (strcmp (opt, "string") == 0) {
str_value = strdup (optarg);
type = PROP_STRING;
} else if (strcmp (opt, "int") == 0) {
int_value = strtol (optarg, NULL, 0);
type = PROP_INT;
} else if (strcmp (opt, "uint64") == 0) {
uint64_value = strtoull (optarg, NULL, 0);
type = PROP_UINT64;
} else if (strcmp (opt, "double") == 0) {
double_value = (double) atof (optarg);
type = PROP_DOUBLE;
} else if (strcmp (opt, "bool") == 0) {
if (strcmp (optarg, "true") == 0)
bool_value = TRUE;
else if (strcmp (optarg, "false") == 0)
bool_value = FALSE;
else {
usage (argc, argv);
return 1;
}
type = PROP_BOOL;
} else if (strcmp (opt, "strlist-pre") == 0) {
str_value = strdup (optarg);
type = PROP_STRLIST_PRE;
} else if (strcmp (opt, "strlist-post") == 0) {
str_value = strdup (optarg);
type = PROP_STRLIST_POST;
} else if (strcmp (opt, "strlist-rem") == 0) {
str_value = strdup (optarg);
type = PROP_STRLIST_REM;
} else if (strcmp (opt, "remove") == 0) {
remove = TRUE;
} else if (strcmp (opt, "direct") == 0) {
direct = TRUE;
} else if (strcmp (opt, "udi") == 0) {
udi = strdup (optarg);
} else if (strcmp (opt, "version") == 0) {
is_version = TRUE;
}
break;
default:
usage (argc, argv);
return 1;
break;
}
}
if (is_version) {
printf ("hal-set-property " PACKAGE_VERSION "\n");
return 0;
}
/* must have at least one, but not neither or both */
if ((remove && type != PROP_INVALID) || ((!remove) && type == PROP_INVALID)) {
usage (argc, argv);
return 1;
}
fprintf (stderr, "\n");
dbus_error_init (&error);
if (direct) {
if ((hal_ctx = libhal_ctx_init_direct (&error)) == NULL) {
fprintf (stderr, "error: libhal_ctx_init_direct\n");
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
} else {
if ((hal_ctx = libhal_ctx_new ()) == NULL) {
fprintf (stderr, "error: libhal_ctx_new\n");
return 1;
}
if (!libhal_ctx_set_dbus_connection (hal_ctx, dbus_bus_get (DBUS_BUS_SYSTEM, &error))) {
fprintf (stderr, "error: libhal_ctx_set_dbus_connection: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
if (!libhal_ctx_init (hal_ctx, &error)) {
if (dbus_error_is_set(&error)) {
fprintf (stderr, "error: libhal_ctx_init: %s: %s\n", error.name, error.message);
dbus_error_free (&error);
}
fprintf (stderr, "Could not initialise connection to hald.\n"
"Normally this means the HAL daemon (hald) is not running or not ready.\n");
return 1;
}
}
if (remove) {
rc = libhal_device_remove_property (hal_ctx, udi, key, &error);
if (!rc) {
fprintf (stderr, "error: libhal_device_remove_property: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
} else {
switch (type) {
case PROP_STRING:
rc = libhal_device_set_property_string (hal_ctx, udi, key, str_value, &error);
break;
case PROP_INT:
rc = libhal_device_set_property_int (hal_ctx, udi, key, int_value, &error);
break;
case PROP_UINT64:
rc = libhal_device_set_property_uint64 (hal_ctx, udi, key, uint64_value, &error);
break;
case PROP_DOUBLE:
rc = libhal_device_set_property_double (hal_ctx, udi, key, double_value, &error);
break;
case PROP_BOOL:
rc = libhal_device_set_property_bool (hal_ctx, udi, key, bool_value, &error);
break;
case PROP_STRLIST_PRE:
rc = libhal_device_property_strlist_prepend (hal_ctx, udi, key, str_value, &error);
break;
case PROP_STRLIST_POST:
rc = libhal_device_property_strlist_append (hal_ctx, udi, key, str_value, &error);
break;
case PROP_STRLIST_REM:
rc = libhal_device_property_strlist_remove (hal_ctx, udi, key, str_value, &error);
break;
}
if (!rc) {
fprintf (stderr, "error: libhal_device_set_property: %s: %s\n", error.name, error.message);
dbus_error_free (&error);
return 1;
}
}
return rc ? 0 : 1;
}
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;
}
/**
* wpa_supplicant_dbus_ctrl_iface_init - Initialize dbus control interface
* @global: Pointer to global data from wpa_supplicant_init()
* Returns: Pointer to dbus_ctrl_iface date or %NULL on failure
*
* Initialize the dbus control interface and start receiving commands from
* external programs over the bus.
*/
struct ctrl_iface_dbus_priv *
wpa_supplicant_dbus_ctrl_iface_init(struct wpa_global *global)
{
struct ctrl_iface_dbus_priv *iface;
DBusError error;
int ret = -1;
DBusObjectPathVTable wpas_vtable = {
NULL, &wpas_message_handler, NULL, NULL, NULL, NULL
};
iface = wpa_zalloc(sizeof(struct ctrl_iface_dbus_priv));
if (iface == NULL)
return NULL;
iface->global = global;
/* Get a reference to the system bus */
dbus_error_init(&error);
iface->con = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
dbus_error_free(&error);
if (!iface->con) {
perror("dbus_bus_get[ctrl_iface_dbus]");
wpa_printf(MSG_ERROR, "Could not acquire the system bus.");
goto fail;
}
/* Tell dbus about our mainloop integration functions */
if (integrate_with_eloop(iface->con, iface))
goto fail;
/* Register the message handler for the global dbus interface */
if (!dbus_connection_register_object_path(iface->con,
WPAS_DBUS_PATH, &wpas_vtable,
iface)) {
perror("dbus_connection_register_object_path[dbus]");
wpa_printf(MSG_ERROR, "Could not set up DBus message "
"handler.");
goto fail;
}
/* Register our service with the message bus */
dbus_error_init(&error);
switch (dbus_bus_request_name(iface->con, WPAS_DBUS_SERVICE,
0, &error)) {
case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
ret = 0;
break;
case DBUS_REQUEST_NAME_REPLY_EXISTS:
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
perror("dbus_bus_request_name[dbus]");
wpa_printf(MSG_ERROR, "Could not request DBus service name: "
"already registered.");
break;
default:
perror("dbus_bus_request_name[dbus]");
wpa_printf(MSG_ERROR, "Could not request DBus service name: "
"%s %s.", error.name, error.message);
break;
}
dbus_error_free(&error);
if (ret != 0)
goto fail;
wpa_printf(MSG_DEBUG, "Providing DBus service '" WPAS_DBUS_SERVICE
"'.");
/*
* Dispatch initial DBus messages that may have come in since the bus
* name was claimed above. Happens when clients are quick to notice the
* wpa_supplicant service.
*
* FIXME: is there a better solution to this problem?
*/
eloop_register_timeout(0, 50, dispatch_initial_dbus_messages,
iface->con, NULL);
return iface;
fail:
wpa_supplicant_dbus_ctrl_iface_deinit(iface);
return NULL;
}
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
}
int list_controllers_main (void *parent, char ***output)
{
DBusMessage *message = NULL, *reply = NULL;
char ** output_local = NULL;
DBusError error;
DBusMessageIter iter;
int ret = -1;
DBusMessageIter output_local_iter;
size_t output_local_size;
*output = NULL;
message = dbus_message_new_method_call(dbus_bus_get_unique_name(server_conn),
"/org/linuxcontainers/cgmanager",
"org.linuxcontainers.cgmanager0_0", "ListControllers");
dbus_error_init (&error);
reply = dbus_connection_send_with_reply_and_block (server_conn, message, -1, &error);
if (! reply) {
dbus_message_unref (message);
nih_error("%s: error completing dbus request: %s %s", __func__,
error.name, error.message);
dbus_error_free (&error);
return -1;
}
dbus_message_unref (message);
dbus_message_iter_init (reply, &iter);
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
goto out;
dbus_message_iter_recurse (&iter, &output_local_iter);
output_local_size = 0;
output_local = NULL;
output_local = NIH_MUST( nih_alloc (parent, sizeof (char *)) );
output_local[output_local_size] = NULL;
while (dbus_message_iter_get_arg_type (&output_local_iter) != DBUS_TYPE_INVALID) {
const char *output_local_element_dbus;
char ** output_local_tmp;
char * output_local_element;
if (dbus_message_iter_get_arg_type (&output_local_iter) != DBUS_TYPE_STRING)
goto out;
dbus_message_iter_get_basic (&output_local_iter, &output_local_element_dbus);
output_local_element = NIH_MUST( nih_strdup (output_local, output_local_element_dbus) );
dbus_message_iter_next (&output_local_iter);
output_local_tmp = NIH_MUST( nih_realloc (output_local, parent, sizeof (char *) * (output_local_size + 2)) );
output_local = output_local_tmp;
output_local[output_local_size] = output_local_element;
output_local[output_local_size + 1] = NULL;
output_local_size++;
}
dbus_message_iter_next (&iter);
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID)
goto out;
*output = output_local;
ret = 0;
out:
if (reply)
dbus_message_unref (reply);
if (ret)
nih_free (output_local);
return ret;
}
static void get_properties(DBusConnection *conn)
{
DBusError err;
DBusMessage *msg;
DBusMessageIter iter, dict, dict_key, dict_value;
dbus_bool_t bValue;
dbus_uint32_t iValue;
char key[255];
char value[255];
char *ckey;
char *cValue;
// int i = 0;
dbus_error_init(&err);
msg = dbus_message_new_method_call(DBUS_NAME,DBUS_PATH, DBUS_INTERFACE_APAPTER,
"GetProperties");
if (msg == NULL)
{
printf("%s %d msg is null\n", __func__, __LINE__);
exit(1);
}
msg = excute_method_a(conn, msg);
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &dict);
do
{
memset(key, 0, 255);
memset(value, 0, 255);
dbus_message_iter_recurse(&dict, &dict_key);
dbus_message_iter_get_basic(&dict_key, &ckey);
strcpy(key, ckey);
// printf("%s %d key:%s\n", __func__, __LINE__, key);
if (!strcmp(key, "Name"))
{
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_get_basic(&dict_value, &cValue);
strcpy(value, cValue);
printf("%s: %s\n", key, value);
}
else if(!strcmp(key, "Address"))
{
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_get_basic(&dict_value, &cValue);
strcpy(value, cValue);
printf("%s: %s\n", key, value);
}
//Discoverable
else if(!strcmp(key, "Discoverable"))
{
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_get_basic(&dict_value, &bValue);
printf("%s: %d\n", key, bValue);
}
//DiscoverableTimeout
else if(!strcmp(key, "DiscoverableTimeout"))
{
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_get_basic(&dict_value, &iValue);
printf("%s: %d\n", key, iValue);
}
//Discovering
else if(!strcmp(key, "Discovering"))
{
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_get_basic(&dict_value, &bValue);
printf("%s: %d\n", key, bValue);
}
//Pairable
else if(!strcmp(key, "Pairable"))
{
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_get_basic(&dict_value, &bValue);
printf("%s: %d\n", key, bValue);
}
//PairableTimeout
else if(!strcmp(key, "PairableTimeout"))
{
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_get_basic(&dict_value, &iValue);
printf("%s: %d\n", key, iValue);
}
//Powerd
else if(!strcmp(key, "Powered"))
{
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_get_basic(&dict_value, &bValue);
printf("%s: %d\n", key, bValue);
}
//Devices
else if(!strcmp(key, "Devices"))
{
DBusMessageIter device_array;
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_recurse(&dict_value, &device_array);
if (dbus_message_iter_get_arg_type(&device_array) != DBUS_TYPE_OBJECT_PATH)
{
printf("%s: 0\n", key);
continue;
}
// i = 0;
do
{
dbus_message_iter_get_basic(&device_array, &cValue);
strcpy(value, cValue);
// printf("%s %d %s %d: %s\n", __func__, __LINE__, key, ++i, value);
} while (dbus_message_iter_next(&device_array));
}
//UUIDs
else if(!strcmp(key, "UUIDs"))
{
DBusMessageIter device_array;
dbus_message_iter_next(&dict_key);
dbus_message_iter_recurse(&dict_key, &dict_value);
dbus_message_iter_recurse(&dict_value, &device_array);
do
{
dbus_message_iter_get_basic(&device_array, &cValue);
} while(dbus_message_iter_next(&device_array));
}
else
{
printf("%s: Not to supported \n",key);
}
} while (dbus_message_iter_next(&dict));
dbus_error_free(&err);
}
static void set_property(DBusConnection *conn, const char *name, struct ADAPTER_PROPERTIES *p)
{
DBusError err;
DBusMessage *msg;
DBusMessageIter iter;
char s[255];
memset(&s, 0, 255);
dbus_error_init(&err);
msg = dbus_message_new_method_call(DBUS_NAME,DBUS_PATH, DBUS_INTERFACE_APAPTER,
"SetProperty");
if (msg == NULL)
{
printf("%s %d msg is null\n", __func__, __LINE__);
exit(1);
}
/* append data */
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
// printf("%s %d\n", __func__, __LINE__);
if (!strcmp(name, "Name"))
{
// printf("SynergyDBusAdapter::SetProperty('%s', %s)\n", name, p->Name);
strcpy(s, p->Name);
append_variant(&iter, DBUS_TYPE_STRING, &s);
}
else if (!strcmp(name, "Powered"))
{
// printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->Powered);
append_variant(&iter, DBUS_TYPE_BOOLEAN, &p->Powered);
}
else if (!strcmp(name, "DiscoverableTimeout"))
{
// printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->DiscoverableTimeout);
append_variant(&iter, DBUS_TYPE_UINT32, &p->DiscoverableTimeout);
}
else if (!strcmp(name, "Discoverable"))
{
// printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->Discoverable);
append_variant(&iter, DBUS_TYPE_BOOLEAN, &p->Discoverable);
}
else if (!strcmp(name, "PairableTimeout"))
{
// printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->PairableTimeout);
append_variant(&iter, DBUS_TYPE_UINT32, &p->PairableTimeout);
}
else if (!strcmp(name, "Pairable"))
{
// printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->Pairable);
append_variant(&iter, DBUS_TYPE_BOOLEAN, &p->Pairable);
}
else
{
printf("SynergyDBusAdapter::SetProperty('%s') is not supported)\n", name);
dbus_connection_flush(conn);
dbus_message_unref(msg);
exit(1);
}
msg = excute_method_a(conn, msg);
dbus_message_unref(msg);
dbus_error_free(&err);
}
pa_reserve_wrapper* pa_reserve_wrapper_get(pa_core *c, const char *device_name) {
pa_reserve_wrapper *r;
int k;
char *t;
#ifdef HAVE_DBUS
DBusError error;
dbus_error_init(&error);
#endif
pa_assert(c);
pa_assert(device_name);
t = pa_sprintf_malloc("reserve-wrapper@%s", device_name);
if ((r = pa_shared_get(c, t))) {
pa_xfree(t);
pa_assert(PA_REFCNT_VALUE(r) >= 1);
PA_REFCNT_INC(r);
return r;
}
r = pa_xnew0(pa_reserve_wrapper, 1);
PA_REFCNT_INIT(r);
r->core = c;
pa_hook_init(&r->hook, r);
r->shared_name = t;
pa_assert_se(pa_shared_set(c, r->shared_name, r) >= 0);
#ifdef HAVE_DBUS
if (!(r->connection = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_debug("Unable to contact D-Bus session bus: %s: %s", error.name, error.message);
/* We don't treat this as error here because we want allow PA
* to run even when no session bus is available. */
return r;
}
if ((k = rd_acquire(
&r->device,
pa_dbus_connection_get(r->connection),
device_name,
_("PulseAudio Sound Server"),
0,
request_cb,
NULL)) < 0) {
if (k == -EBUSY) {
pa_log_debug("Device '%s' already locked.", device_name);
goto fail;
} else {
pa_log_debug("Failed to acquire reservation lock on device '%s': %s", device_name, pa_cstrerror(-k));
return r;
}
}
pa_log_debug("Successfully acquired reservation lock on device '%s'", device_name);
rd_set_userdata(r->device, r);
return r;
fail:
dbus_error_free(&error);
reserve_wrapper_free(r);
return NULL;
#else
return r;
#endif
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
ipp_t *msg; /* Event message from scheduler */
ipp_state_t state; /* IPP event state */
struct sigaction action; /* POSIX sigaction data */
DBusConnection *con = NULL; /* Connection to DBUS server */
DBusError error; /* Error, if any */
DBusMessage *message; /* Message to send */
DBusMessageIter iter; /* Iterator for message data */
int lock_fd = -1; /* Lock file descriptor */
/*
* Don't buffer stderr...
*/
setbuf(stderr, NULL);
/*
* Ignore SIGPIPE signals...
*/
memset(&action, 0, sizeof(action));
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
/*
* Validate command-line options...
*/
if (argc != 3)
{
fputs("Usage: dbus dbus:/// notify-user-data\n", stderr);
return (1);
}
if (strncmp(argv[1], "dbus:", 5))
{
fprintf(stderr, "ERROR: Bad URI \"%s\"!\n", argv[1]);
return (1);
}
/*
* Loop forever until we run out of events...
*/
for (;;)
{
ipp_attribute_t *attr; /* Current attribute */
const char *event; /* Event name */
const char *signame = NULL;/* DBUS signal name */
char *printer_reasons = NULL;
/* Printer reasons string */
char *job_reasons = NULL;
/* Job reasons string */
const char *nul = ""; /* Empty string value */
int no = 0; /* Boolean "no" value */
int params = PARAMS_NONE;
/* What parameters to include? */
/*
* Get the next event...
*/
msg = ippNew();
while ((state = ippReadFile(0, msg)) != IPP_DATA)
{
if (state <= IPP_IDLE)
break;
}
fprintf(stderr, "DEBUG: state=%d\n", state);
if (state == IPP_ERROR)
fputs("DEBUG: ippReadFile() returned IPP_ERROR!\n", stderr);
if (state <= IPP_IDLE)
{
/*
* Out of messages, free memory and then exit...
*/
ippDelete(msg);
break;
}
/*
* Verify connection to DBUS server...
*/
if (con && !dbus_connection_get_is_connected(con))
{
dbus_connection_unref(con);
con = NULL;
}
if (!con)
{
dbus_error_init(&error);
con = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (!con)
dbus_error_free(&error);
else
fputs("DEBUG: Connected to D-BUS\n", stderr);
}
if (!con)
continue;
if (lock_fd == -1 &&
acquire_lock(&lock_fd, lock_filename, sizeof(lock_filename)))
continue;
attr = ippFindAttribute(msg, "notify-subscribed-event",
IPP_TAG_KEYWORD);
if (!attr)
continue;
event = ippGetString(attr, 0, NULL);
if (!strncmp(event, "server-", 7))
{
const char *word2 = event + 7; /* Second word */
if (!strcmp(word2, "restarted"))
signame = "ServerRestarted";
else if (!strcmp(word2, "started"))
signame = "ServerStarted";
else if (!strcmp(word2, "stopped"))
signame = "ServerStopped";
else if (!strcmp(word2, "audit"))
signame = "ServerAudit";
else
continue;
}
else if (!strncmp(event, "printer-", 8))
{
const char *word2 = event + 8; /* Second word */
params = PARAMS_PRINTER;
if (!strcmp(word2, "restarted"))
signame = "PrinterRestarted";
else if (!strcmp(word2, "shutdown"))
signame = "PrinterShutdown";
else if (!strcmp(word2, "stopped"))
signame = "PrinterStopped";
else if (!strcmp(word2, "state-changed"))
signame = "PrinterStateChanged";
else if (!strcmp(word2, "finishings-changed"))
signame = "PrinterFinishingsChanged";
else if (!strcmp(word2, "media-changed"))
signame = "PrinterMediaChanged";
else if (!strcmp(word2, "added"))
signame = "PrinterAdded";
else if (!strcmp(word2, "deleted"))
signame = "PrinterDeleted";
else if (!strcmp(word2, "modified"))
signame = "PrinterModified";
else
continue;
}
else if (!strncmp(event, "job-", 4))
{
const char *word2 = event + 4; /* Second word */
params = PARAMS_JOB;
if (!strcmp(word2, "state-changed"))
signame = "JobState";
else if (!strcmp(word2, "created"))
signame = "JobCreated";
else if (!strcmp(word2, "completed"))
signame = "JobCompleted";
else if (!strcmp(word2, "stopped"))
signame = "JobStopped";
else if (!strcmp(word2, "config-changed"))
signame = "JobConfigChanged";
else if (!strcmp(word2, "progress"))
signame = "JobProgress";
else
continue;
}
else
continue;
/*
* Create and send the new message...
*/
fprintf(stderr, "DEBUG: %s\n", signame);
message = dbus_message_new_signal("/org/cups/cupsd/Notifier",
"org.cups.cupsd.Notifier",
signame);
dbus_message_append_iter_init(message, &iter);
attr = ippFindAttribute(msg, "notify-text", IPP_TAG_TEXT);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
goto bail;
if (params >= PARAMS_PRINTER)
{
char *p; /* Pointer into printer_reasons */
size_t reasons_length; /* Required size of printer_reasons */
int i; /* Looping var */
int have_printer_params = 1;/* Do we have printer URI? */
/* STRING printer-uri or "" */
attr = ippFindAttribute(msg, "notify-printer-uri", IPP_TAG_URI);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
{
have_printer_params = 0;
dbus_message_iter_append_string(&iter, &nul);
}
/* STRING printer-name */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-name", IPP_TAG_NAME);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* UINT32 printer-state */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-state", IPP_TAG_ENUM);
if (attr)
{
dbus_uint32_t val = (dbus_uint32_t)ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
}
else
dbus_message_iter_append_uint32(&iter, &no);
/* STRING printer-state-reasons */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-state-reasons",
IPP_TAG_KEYWORD);
if (attr)
{
int num_values = ippGetCount(attr);
for (reasons_length = 0, i = 0; i < num_values; i++)
/* All need commas except the last, which needs a nul byte. */
reasons_length += 1 + strlen(ippGetString(attr, i, NULL));
printer_reasons = malloc(reasons_length);
if (!printer_reasons)
goto bail;
p = printer_reasons;
for (i = 0; i < num_values; i++)
{
if (i)
*p++ = ',';
strlcpy(p, ippGetString(attr, i, NULL), reasons_length - (size_t)(p - printer_reasons));
p += strlen(p);
}
if (!dbus_message_iter_append_string(&iter, &printer_reasons))
goto bail;
}
else
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* BOOL printer-is-accepting-jobs */
if (have_printer_params)
{
attr = ippFindAttribute(msg, "printer-is-accepting-jobs",
IPP_TAG_BOOLEAN);
if (attr)
{
dbus_bool_t val = (dbus_bool_t)ippGetBoolean(attr, 0);
dbus_message_iter_append_boolean(&iter, &val);
}
else
goto bail;
}
else
dbus_message_iter_append_boolean(&iter, &no);
}
if (params >= PARAMS_JOB)
{
char *p; /* Pointer into job_reasons */
size_t reasons_length; /* Required size of job_reasons */
int i; /* Looping var */
/* UINT32 job-id */
attr = ippFindAttribute(msg, "notify-job-id", IPP_TAG_INTEGER);
if (attr)
{
dbus_uint32_t val = (dbus_uint32_t)ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
/* UINT32 job-state */
attr = ippFindAttribute(msg, "job-state", IPP_TAG_ENUM);
if (attr)
{
dbus_uint32_t val = (dbus_uint32_t)ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
/* STRING job-state-reasons */
attr = ippFindAttribute(msg, "job-state-reasons", IPP_TAG_KEYWORD);
if (attr)
{
int num_values = ippGetCount(attr);
for (reasons_length = 0, i = 0; i < num_values; i++)
/* All need commas except the last, which needs a nul byte. */
reasons_length += 1 + strlen(ippGetString(attr, i, NULL));
job_reasons = malloc(reasons_length);
if (!job_reasons)
goto bail;
p = job_reasons;
for (i = 0; i < num_values; i++)
{
if (i)
*p++ = ',';
strlcpy(p, ippGetString(attr, i, NULL), reasons_length - (size_t)(p - job_reasons));
p += strlen(p);
}
if (!dbus_message_iter_append_string(&iter, &job_reasons))
goto bail;
}
else
goto bail;
/* STRING job-name or "" */
attr = ippFindAttribute(msg, "job-name", IPP_TAG_NAME);
if (attr)
{
const char *val = ippGetString(attr, 0, NULL);
if (!dbus_message_iter_append_string(&iter, &val))
goto bail;
}
else
dbus_message_iter_append_string(&iter, &nul);
/* UINT32 job-impressions-completed */
attr = ippFindAttribute(msg, "job-impressions-completed",
IPP_TAG_INTEGER);
if (attr)
{
dbus_uint32_t val = (dbus_uint32_t)ippGetInteger(attr, 0);
dbus_message_iter_append_uint32(&iter, &val);
}
else
goto bail;
}
dbus_connection_send(con, message, NULL);
dbus_connection_flush(con);
/*
* Cleanup...
*/
bail:
dbus_message_unref(message);
if (printer_reasons)
free(printer_reasons);
if (job_reasons)
free(job_reasons);
ippDelete(msg);
}
/*
* Remove lock file...
*/
if (lock_fd >= 0)
{
close(lock_fd);
release_lock();
}
return (0);
}
pa_reserve_monitor_wrapper* pa_reserve_monitor_wrapper_get(pa_core *c, const char *device_name) {
pa_reserve_monitor_wrapper *w;
int k;
char *t;
#ifdef HAVE_DBUS
DBusError error;
dbus_error_init(&error);
#endif
pa_assert(c);
pa_assert(device_name);
t = pa_sprintf_malloc("reserve-monitor-wrapper@%s", device_name);
if ((w = pa_shared_get(c, t))) {
pa_xfree(t);
pa_assert(PA_REFCNT_VALUE(w) >= 1);
PA_REFCNT_INC(w);
return w;
}
w = pa_xnew0(pa_reserve_monitor_wrapper, 1);
PA_REFCNT_INIT(w);
w->core = c;
pa_hook_init(&w->hook, w);
w->shared_name = t;
pa_assert_se(pa_shared_set(c, w->shared_name, w) >= 0);
#ifdef HAVE_DBUS
if (!(w->connection = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_debug("Unable to contact D-Bus session bus: %s: %s", error.name, error.message);
/* We don't treat this as error here because we want allow PA
* to run even when no session bus is available. */
return w;
}
if ((k = rm_watch(
&w->monitor,
pa_dbus_connection_get(w->connection),
device_name,
change_cb,
NULL)) < 0) {
pa_log_debug("Failed to create watch on device '%s': %s", device_name, pa_cstrerror(-k));
goto fail;
}
pa_log_debug("Successfully create reservation lock monitor for device '%s'", device_name);
rm_set_userdata(w->monitor, w);
return w;
fail:
dbus_error_free(&error);
reserve_monitor_wrapper_free(w);
return NULL;
#else
return w;
#endif
}
static DBusHandlerResult
_libnm_glib_dbus_filter (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
libnm_glib_ctx *ctx = (libnm_glib_ctx *)user_data;
gboolean handled = TRUE;
DBusError error;
g_return_val_if_fail (ctx != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
dbus_error_init (&error);
if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected"))
{
/* Try to reactivate our connection to dbus on the next pass through the event loop */
ctx->nm_state = LIBNM_NO_DBUS;
dbus_connection_close (ctx->dbus_con);
dbus_connection_unref (ctx->dbus_con);
ctx->dbus_con = NULL;
_libnm_glib_schedule_dbus_watcher (ctx);
}
else if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS, "NameOwnerChanged"))
{
/* New signal for dbus 0.23... */
char *service;
char *old_owner;
char *new_owner;
if ( dbus_message_get_args (message, &error,
DBUS_TYPE_STRING, &service,
DBUS_TYPE_STRING, &old_owner,
DBUS_TYPE_STRING, &new_owner,
DBUS_TYPE_INVALID))
{
if (strcmp (service, NM_DBUS_SERVICE) == 0)
{
gboolean old_owner_good = (old_owner && (strlen (old_owner) > 0));
gboolean new_owner_good = (new_owner && (strlen (new_owner) > 0));
if (!old_owner_good && new_owner_good) /* Equivalent to old ServiceCreated signal */
_libnm_glib_get_nm_state (ctx);
else if (old_owner_good && !new_owner_good) /* Equivalent to old ServiceDeleted signal */
ctx->nm_state = LIBNM_NO_NETWORKMANAGER;
}
}
}
else if ( dbus_message_is_signal (message, NM_DBUS_INTERFACE, "DeviceNowActive")
|| dbus_message_is_signal (message, NM_DBUS_INTERFACE, "DeviceNoLongerActive")
|| dbus_message_is_signal (message, NM_DBUS_INTERFACE, "DeviceActivating")
|| dbus_message_is_signal (message, NM_DBUS_INTERFACE, "DevicesChanged"))
{
_libnm_glib_get_nm_state (ctx);
}
else if (dbus_message_is_signal (message, NM_DBUS_INTERFACE, "StateChanged"))
{
NMState state = NM_STATE_UNKNOWN;
dbus_message_get_args (message, &error, DBUS_TYPE_UINT32, &state, DBUS_TYPE_INVALID);
_libnm_glib_update_state (ctx, state);
}
else
handled = FALSE;
if (dbus_error_is_set (&error))
dbus_error_free (&error);
return (handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
}
static void
unmount_childs (LibHalContext *ctx, const char *udi)
{
int num_volumes;
char **volumes;
DBusError error;
/* need to force unmount all partitions */
dbus_error_init (&error);
if ((volumes = libhal_manager_find_device_string_match (ctx, "block.storage_device", udi, &num_volumes, &error)) != NULL) {
int i;
for (i = 0; i < num_volumes; i++) {
char *vol_udi;
vol_udi = volumes[i];
LIBHAL_FREE_DBUS_ERROR (&error);
if (libhal_device_get_property_bool (ctx, vol_udi, "block.is_volume", &error)) {
dbus_bool_t is_crypto;
/* unmount all cleartext devices associated with us */
is_crypto = unmount_cleartext_devices (ctx, vol_udi);
LIBHAL_FREE_DBUS_ERROR (&error);
if (libhal_device_get_property_bool (ctx, vol_udi, "volume.is_mounted", &error)) {
HAL_DEBUG (("Forcing unmount of child '%s'", vol_udi));
force_unmount (ctx, vol_udi);
}
/* teardown crypto */
if (is_crypto) {
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
/* tear down mapping */
HAL_DEBUG (("Teardown crypto for '%s'", vol_udi));
msg = dbus_message_new_method_call ("org.freedesktop.Hal", vol_udi,
"org.freedesktop.Hal.Device.Volume.Crypto",
"Teardown");
if (msg == NULL) {
HAL_ERROR (("Could not create dbus message for %s", vol_udi));
goto teardown_failed;
}
LIBHAL_FREE_DBUS_ERROR (&error);
if (!(reply = dbus_connection_send_with_reply_and_block (
libhal_ctx_get_dbus_connection (ctx), msg, -1, &error)) ||
dbus_error_is_set (&error)) {
HAL_DEBUG (("Teardown failed for %s: %s : %s\n", udi, error.name, error.message));
dbus_error_free (&error);
}
teardown_failed:
if (msg != NULL)
dbus_message_unref (msg);
if (reply != NULL)
dbus_message_unref (reply);
}
}
}
libhal_free_string_array (volumes);
}
LIBHAL_FREE_DBUS_ERROR (&error);
}
/** Entry point
*
* @param argc Number of arguments given to program
* @param argv Arguments given to program
* @return Return code
*/
int
main (int argc, char *argv[])
{
char *udi = NULL;
char *key = NULL;
int type;
dbus_bool_t is_hex = FALSE;
dbus_bool_t is_verbose = FALSE;
dbus_bool_t is_version = FALSE;
char *str;
DBusError error;
if (argc <= 1) {
usage (argc, argv);
return 1;
}
while (1) {
int c;
int option_index = 0;
const char *opt;
static struct option long_options[] = {
{"udi", 1, NULL, 0},
{"key", 1, NULL, 0},
{"hex", 0, NULL, 0},
{"verbose", 0, NULL, 0},
{"version", 0, NULL, 0},
{"help", 0, NULL, 0},
{NULL, 0, NULL, 0}
};
c = getopt_long (argc, argv, "",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0:
opt = long_options[option_index].name;
if (strcmp (opt, "help") == 0) {
usage (argc, argv);
return 0;
} else if (strcmp (opt, "hex") == 0) {
is_hex = TRUE;
} else if (strcmp (opt, "verbose") == 0) {
is_verbose = TRUE;
} else if (strcmp (opt, "version") == 0) {
is_version = TRUE;
} else if (strcmp (opt, "key") == 0) {
key = strdup (optarg);
} else if (strcmp (opt, "udi") == 0) {
udi = strdup (optarg);
}
break;
default:
usage (argc, argv);
return 1;
break;
}
}
if (is_version) {
printf ("hal-get-property " PACKAGE_VERSION "\n");
return 0;
}
if (udi == NULL || key == NULL) {
usage (argc, argv);
return 1;
}
dbus_error_init (&error);
if ((hal_ctx = libhal_ctx_new ()) == NULL) {
fprintf (stderr, "error: libhal_ctx_new\n");
return 1;
}
if (!libhal_ctx_set_dbus_connection (hal_ctx, dbus_bus_get (DBUS_BUS_SYSTEM, &error))) {
fprintf (stderr, "error: libhal_ctx_set_dbus_connection: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
if (!libhal_ctx_init (hal_ctx, &error)) {
if (dbus_error_is_set(&error)) {
fprintf (stderr, "error: libhal_ctx_init: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
}
fprintf (stderr, "Could not initialise connection to hald.\n"
"Normally this means the HAL daemon (hald) is not running or not ready.\n");
return 1;
}
type = libhal_device_get_property_type (hal_ctx, udi, key, &error);
if (type == LIBHAL_PROPERTY_TYPE_INVALID) {
fprintf (stderr, "error: libhal_device_get_property_type: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
/* emit the value to stdout */
switch (type) {
case LIBHAL_PROPERTY_TYPE_STRING:
str = libhal_device_get_property_string (hal_ctx, udi, key, &error);
if (is_verbose)
printf ("Type is string\n");
printf ("%s\n", str);
libhal_free_string (str);
break;
case LIBHAL_PROPERTY_TYPE_INT32:
if (is_verbose)
printf ("Type is integer (shown in %s)\n",
(is_hex ? "hexadecimal" : "decimal"));
printf ((is_hex ? "%x\n" : "%d\n"),
libhal_device_get_property_int (hal_ctx, udi, key, &error));
break;
case LIBHAL_PROPERTY_TYPE_UINT64:
if (is_verbose)
printf ("Type is uint64 (shown in %s)\n",
(is_hex ? "hexadecimal" : "decimal"));
printf ((is_hex ? "%llx\n" : "%llu\n"),
(long long unsigned int) libhal_device_get_property_uint64 (hal_ctx, udi, key, &error));
break;
case LIBHAL_PROPERTY_TYPE_DOUBLE:
if (is_verbose)
printf ("Type is double\n");
printf ("%f\n",
libhal_device_get_property_double (hal_ctx, udi, key, &error));
break;
case LIBHAL_PROPERTY_TYPE_BOOLEAN:
if (is_verbose)
printf ("Type is boolean\n");
printf ("%s\n",
libhal_device_get_property_bool (hal_ctx, udi, key, &error) ? "true" : "false");
break;
case LIBHAL_PROPERTY_TYPE_STRLIST:
{
unsigned int i;
char **strlist;
if ((strlist = libhal_device_get_property_strlist (hal_ctx, udi, key, &error)) != NULL) {
for (i = 0; strlist[i] != 0; i++) {
printf ("%s", strlist[i]);
if (strlist[i+1] != NULL)
printf (" ");
}
}
break;
}
default:
printf ("Unknown type %d='%c'\n", type, type);
return 1;
break;
}
if (dbus_error_is_set (&error)) {
fprintf (stderr, "error: %s: %s\n", error.name, error.message);
dbus_error_free (&error);
return 1;
}
return 0;
}
/**
* Listens for new connections on the given address. If there are
* multiple semicolon-separated address entries in the address, tries
* each one and listens on the first one that works.
*
* Returns #NULL and sets error if listening fails for any reason.
* Otherwise returns a new #DBusServer.
* dbus_server_set_new_connection_function(),
* dbus_server_set_watch_functions(), and
* dbus_server_set_timeout_functions() should be called immediately to
* render the server fully functional.
*
* To free the server, applications must call first
* dbus_server_disconnect() and then dbus_server_unref().
*
* @param address the address of this server.
* @param error location to store reason for failure.
* @returns a new #DBusServer, or #NULL on failure.
*
*/
DBusServer*
dbus_server_listen (const char *address,
DBusError *error)
{
DBusServer *server;
DBusAddressEntry **entries;
int len, i;
DBusError first_connect_error = DBUS_ERROR_INIT;
dbus_bool_t handled_once;
_dbus_return_val_if_fail (address != NULL, NULL);
_dbus_return_val_if_error_is_set (error, NULL);
if (!dbus_parse_address (address, &entries, &len, error))
return NULL;
server = NULL;
handled_once = FALSE;
for (i = 0; i < len; i++)
{
int j;
for (j = 0; j < (int) _DBUS_N_ELEMENTS (listen_funcs); ++j)
{
DBusServerListenResult result;
DBusError tmp_error = DBUS_ERROR_INIT;
result = (* listen_funcs[j].func) (entries[i],
&server,
&tmp_error);
if (result == DBUS_SERVER_LISTEN_OK)
{
_dbus_assert (server != NULL);
_DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
handled_once = TRUE;
goto out;
}
else if (result == DBUS_SERVER_LISTEN_ADDRESS_ALREADY_USED)
{
_dbus_assert (server == NULL);
dbus_set_error (error,
DBUS_ERROR_ADDRESS_IN_USE,
"Address '%s' already used",
dbus_address_entry_get_method (entries[0]));
handled_once = TRUE;
goto out;
}
else if (result == DBUS_SERVER_LISTEN_BAD_ADDRESS)
{
_dbus_assert (server == NULL);
_DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
dbus_move_error (&tmp_error, error);
handled_once = TRUE;
goto out;
}
else if (result == DBUS_SERVER_LISTEN_NOT_HANDLED)
{
_dbus_assert (server == NULL);
_DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
/* keep trying addresses */
}
else if (result == DBUS_SERVER_LISTEN_DID_NOT_CONNECT)
{
_dbus_assert (server == NULL);
_DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
if (!dbus_error_is_set (&first_connect_error))
dbus_move_error (&tmp_error, &first_connect_error);
else
dbus_error_free (&tmp_error);
handled_once = TRUE;
/* keep trying addresses */
}
}
_dbus_assert (server == NULL);
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
}
out:
if (!handled_once)
{
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
if (len > 0)
dbus_set_error (error,
DBUS_ERROR_BAD_ADDRESS,
"Unknown address type '%s'",
dbus_address_entry_get_method (entries[0]));
else
dbus_set_error (error,
DBUS_ERROR_BAD_ADDRESS,
"Empty address '%s'",
address);
}
dbus_address_entries_free (entries);
if (server == NULL)
{
_dbus_assert (error == NULL || dbus_error_is_set (&first_connect_error) ||
dbus_error_is_set (error));
if (error && dbus_error_is_set (error))
{
/* already set the error */
}
else
{
/* didn't set the error but either error should be
* NULL or first_connect_error should be set.
*/
_dbus_assert (error == NULL || dbus_error_is_set (&first_connect_error));
dbus_move_error (&first_connect_error, error);
}
_DBUS_ASSERT_ERROR_IS_CLEAR (&first_connect_error); /* be sure we freed it */
_DBUS_ASSERT_ERROR_IS_SET (error);
return NULL;
}
else
{
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
return server;
}
}
static DBusHandlerResult object_handler(
DBusConnection *c,
DBusMessage *m,
void *userdata) {
rd_device *d;
DBusError error;
DBusMessage *reply = NULL;
dbus_error_init(&error);
d = userdata;
assert(d->ref >= 1);
if (dbus_message_is_method_call(
m,
"org.freedesktop.ReserveDevice1",
"RequestRelease")) {
int32_t priority;
dbus_bool_t ret;
if (!dbus_message_get_args(
m,
&error,
DBUS_TYPE_INT32, &priority,
DBUS_TYPE_INVALID))
goto invalid;
ret = FALSE;
if (priority > d->priority && d->request_cb) {
d->ref++;
if (d->request_cb(d, 0) > 0) {
ret = TRUE;
d->gave_up = 1;
}
rd_release(d);
}
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_BOOLEAN, &ret,
DBUS_TYPE_INVALID))
goto oom;
if (!dbus_connection_send(c, reply, NULL))
goto oom;
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(
m,
"org.freedesktop.DBus.Properties",
"Get")) {
const char *interface, *property;
if (!dbus_message_get_args(
m,
&error,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &property,
DBUS_TYPE_INVALID))
goto invalid;
if (strcmp(interface, "org.freedesktop.ReserveDevice1") == 0) {
const char *empty = "";
if (strcmp(property, "ApplicationName") == 0 && d->application_name) {
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!add_variant(
reply,
DBUS_TYPE_STRING,
d->application_name ? (const char * const *) &d->application_name : &empty))
goto oom;
} else if (strcmp(property, "ApplicationDeviceName") == 0) {
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!add_variant(
reply,
DBUS_TYPE_STRING,
d->application_device_name ? (const char * const *) &d->application_device_name : &empty))
goto oom;
} else if (strcmp(property, "Priority") == 0) {
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!add_variant(
reply,
DBUS_TYPE_INT32,
&d->priority))
goto oom;
} else {
if (!(reply = dbus_message_new_error_printf(
m,
DBUS_ERROR_UNKNOWN_METHOD,
"Unknown property %s",
property)))
goto oom;
}
if (!dbus_connection_send(c, reply, NULL))
goto oom;
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
} else if (dbus_message_is_method_call(
m,
"org.freedesktop.DBus.Introspectable",
"Introspect")) {
const char *i = introspection;
if (!(reply = dbus_message_new_method_return(m)))
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_STRING,
&i,
DBUS_TYPE_INVALID))
goto oom;
if (!dbus_connection_send(c, reply, NULL))
goto oom;
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
invalid:
if (reply)
dbus_message_unref(reply);
if (!(reply = dbus_message_new_error(
m,
DBUS_ERROR_INVALID_ARGS,
"Invalid arguments")))
goto oom;
if (!dbus_connection_send(c, reply, NULL))
goto oom;
dbus_message_unref(reply);
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_HANDLED;
oom:
if (reply)
dbus_message_unref(reply);
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
char* resolve_service(int interface, int protocol, char *name, char *type, char *domain)
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
DBusPendingCall* pending;
//dbus_int32_t interface = 2;
//dbus_int32_t protocol = 1;
//char *name = "TestService";
//char *type = "_http._tcp";
//char *domain = "local";
dbus_int32_t aprotocol = -1;
dbus_uint32_t flags = 0;
printf ("parameter for ResolvesService:%d, %d, %s, %s, %s, %d, %d.\n", interface, protocol, name, type, domain, aprotocol, flags);
// initialiset the errors
printf("Calling remote method: %s\n", "org.freedesktop.Avahi");
// 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
"/", // object to call on
"org.freedesktop.Avahi.Server", // interface to call on
"ResolveService"); // 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_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_INT32, &aprotocol))
{
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);
}
// 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);
char *address;
char *host;
dbus_uint16_t port;//gint16
GPtrArray *byte_arraies;
dbus_uint32_t m_flags;
if (!dbus_message_iter_init(msg, &args))
g_message("dbus_message_iter_init fail\n");
else
{
//g_message("signature of container args: %s", dbus_message_iter_get_signature(&args));
//g_message("first type: %d", dbus_message_iter_get_arg_type(&args));
//g_message("DBUS_TYPE_INT32: %d", DBUS_TYPE_INT32);
//g_message("DBUS_TYPE_STRING: %d", DBUS_TYPE_STRING);
//char *value;
//dbus_message_iter_get_basic(&args, &value);
//g_message("DBUS_TYPE_STRING: %s", value);
if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message( "Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &interface);
printf("interface : %d\n", interface);
}
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &protocol);
printf("protocol : %d\n", protocol);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &name);
printf("name : %s\n", name);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &type);
printf("type : %s\n", type);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &domain);
printf("domain : %s\n", domain);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &host);
printf("host : %s\n", host);
}
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &aprotocol);
printf("aprotocol : %d\n", aprotocol);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &address);
printf("address : %s\n", address);
}
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &port);
printf("port : %d\n", port);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (strcmp("aay", dbus_message_iter_get_signature(&args)))
g_message("Argument is not error!\n");
else{
DBusMessageIter container_ay, container_y;
unsigned char *values;int size;
//dbus_message_iter_get_basic(&args, &flags);
//dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "ay", &container_ay);
//dbus_message_iter_open_container(&container_ay, DBUS_TYPE_BYTE, "y", &container_y);
dbus_message_iter_recurse(&args, &container_ay);
dbus_message_iter_recurse(&container_ay, &container_y);
dbus_message_iter_get_fixed_array(&container_y, &values, &size);
g_message("size: %d, %s", size, values);
/*
g_message("container args: %s", dbus_message_iter_get_signature(&args));
g_message("container_ay: %s", dbus_message_iter_get_signature(&container_ay));
g_message("container_y: %s", dbus_message_iter_get_signature(&container_y));
g_message("type of container_y: %d", dbus_message_iter_get_arg_type(&container_y));
g_message("value of DBUS_TYPE_BYTE: %d", DBUS_TYPE_BYTE);
*/
// && strcmp("ay", dbus_message_iter_get_signature(&container_ay))
while(dbus_message_iter_next(&container_ay)){
dbus_message_iter_recurse(&container_ay, &container_y);
dbus_message_iter_get_fixed_array(&container_y, &values, &size);
g_message("size: %d, %s", size, values);
}
}
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &m_flags);
printf("m_flags : %d\n", m_flags);
}
/*
dbus_message_iter_next(&args);
g_message("g_message_iter_get_signature: %s", dbus_message_iter_get_signature(&args));
*/
/*
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &flags);
*/
// printf("discovered:%d, %d, %s, %s, %s, %d.\n", interface, protocol, name, type, domain, flags);
}
dbus_message_unref(msg);
}
static DBusHandlerResult filter_handler(
DBusConnection *c,
DBusMessage *m,
void *userdata) {
rd_device *d;
DBusError error;
char *name_owner = NULL;
dbus_error_init(&error);
d = userdata;
assert(d->ref >= 1);
if (dbus_message_is_signal(m, "org.freedesktop.DBus", "NameLost")) {
const char *name;
if (!dbus_message_get_args(
m,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
goto invalid;
if (strcmp(name, d->service_name) == 0 && d->owning) {
/* Verify the actual owner of the name to avoid leaked NameLost
* signals from previous reservations. The D-Bus daemon will send
* all messages asynchronously in the correct order, but we could
* potentially process them too late due to the pseudo-blocking
* call mechanism used during both acquisition and release. This
* can happen if we release the device and immediately after
* reacquire it before NameLost is processed. */
if (!d->gave_up) {
const char *un;
if ((un = dbus_bus_get_unique_name(c)) && rd_dbus_get_name_owner(c, d->service_name, &name_owner, &error) == 0)
if (name_owner && strcmp(name_owner, un) == 0)
goto invalid; /* Name still owned by us */
}
d->owning = 0;
if (!d->gave_up) {
d->ref++;
if (d->request_cb)
d->request_cb(d, 1);
d->gave_up = 1;
rd_release(d);
}
}
}
invalid:
free(name_owner);
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
char* get_entry_group_path()
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
DBusPendingCall* pending;
char *entry_group_path;
// initialiset the errors
printf("Calling remote method: %s\n", "org.freedesktop.Avahi");
// 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
"/", // object to call on
"org.freedesktop.Avahi.Server", // interface to call on
"EntryGroupNew"); // method nameResolveHostName
if (NULL == msg)
{
fprintf(stderr, "Message Null\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);
}
if (dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_ERROR) {
fprintf("message returned error: %s", dbus_message_get_error_name(msg));
}
// 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_OBJECT_PATH != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not DBUS_TYPE_OBJECT_PATH!\n");
else
dbus_message_iter_get_basic(&args, &entry_group_path);
printf("Got Reply: %s\n", entry_group_path);
dbus_message_unref(msg);
return entry_group_path;
}
int rd_acquire(
rd_device **_d,
DBusConnection *connection,
const char *device_name,
const char *application_name,
int32_t priority,
rd_request_cb_t request_cb,
DBusError *error) {
rd_device *d = NULL;
int r, k;
DBusError _error;
DBusMessage *m = NULL, *reply = NULL;
dbus_bool_t good;
if (!error)
error = &_error;
dbus_error_init(error);
if (!_d)
return -EINVAL;
if (!connection)
return -EINVAL;
if (!device_name)
return -EINVAL;
if (!request_cb && priority != INT32_MAX)
return -EINVAL;
if (!(d = calloc(sizeof(rd_device), 1)))
return -ENOMEM;
d->ref = 1;
if (!(d->device_name = strdup(device_name))) {
r = -ENOMEM;
goto fail;
}
if (!(d->application_name = strdup(application_name))) {
r = -ENOMEM;
goto fail;
}
d->priority = priority;
d->connection = dbus_connection_ref(connection);
d->request_cb = request_cb;
if (!(d->service_name = malloc(sizeof(SERVICE_PREFIX) + strlen(device_name)))) {
r = -ENOMEM;
goto fail;
}
sprintf(d->service_name, SERVICE_PREFIX "%s", d->device_name);
if (!(d->object_path = malloc(sizeof(OBJECT_PREFIX) + strlen(device_name)))) {
r = -ENOMEM;
goto fail;
}
sprintf(d->object_path, OBJECT_PREFIX "%s", d->device_name);
if ((k = dbus_bus_request_name(
d->connection,
d->service_name,
DBUS_NAME_FLAG_DO_NOT_QUEUE|
(priority < INT32_MAX ? DBUS_NAME_FLAG_ALLOW_REPLACEMENT : 0),
error)) < 0) {
r = -EIO;
goto fail;
}
if (k == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
goto success;
if (k != DBUS_REQUEST_NAME_REPLY_EXISTS) {
r = -EIO;
goto fail;
}
if (priority <= INT32_MIN) {
r = -EBUSY;
goto fail;
}
if (!(m = dbus_message_new_method_call(
d->service_name,
d->object_path,
"org.freedesktop.ReserveDevice1",
"RequestRelease"))) {
r = -ENOMEM;
goto fail;
}
if (!dbus_message_append_args(
m,
DBUS_TYPE_INT32, &d->priority,
DBUS_TYPE_INVALID)) {
r = -ENOMEM;
goto fail;
}
if (!(reply = dbus_connection_send_with_reply_and_block(
d->connection,
m,
5000, /* 5s */
error))) {
if (dbus_error_has_name(error, DBUS_ERROR_TIMED_OUT) ||
dbus_error_has_name(error, DBUS_ERROR_UNKNOWN_METHOD) ||
dbus_error_has_name(error, DBUS_ERROR_NO_REPLY)) {
/* This must be treated as denied. */
r = -EBUSY;
goto fail;
}
r = -EIO;
goto fail;
}
if (!dbus_message_get_args(
reply,
error,
DBUS_TYPE_BOOLEAN, &good,
DBUS_TYPE_INVALID)) {
r = -EIO;
goto fail;
}
if (!good) {
r = -EBUSY;
goto fail;
}
if ((k = dbus_bus_request_name(
d->connection,
d->service_name,
DBUS_NAME_FLAG_DO_NOT_QUEUE|
(priority < INT32_MAX ? DBUS_NAME_FLAG_ALLOW_REPLACEMENT : 0)|
DBUS_NAME_FLAG_REPLACE_EXISTING,
error)) < 0) {
r = -EIO;
goto fail;
}
if (k != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
r = -EIO;
goto fail;
}
success:
d->owning = 1;
if (!(dbus_connection_register_object_path(
d->connection,
d->object_path,
&vtable,
d))) {
r = -ENOMEM;
goto fail;
}
d->registered = 1;
if (!dbus_connection_add_filter(
d->connection,
filter_handler,
d,
NULL)) {
r = -ENOMEM;
goto fail;
}
d->filtering = 1;
*_d = d;
return 0;
fail:
if (m)
dbus_message_unref(m);
if (reply)
dbus_message_unref(reply);
if (&_error == error)
dbus_error_free(&_error);
if (d)
rd_release(d);
return r;
}
void method_GetState(char *path){
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
DBusPendingCall* pending;
// 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);
}
//char *path = malloc(sizeof(char) * strlen(mpath));
//strcpy(path, mpath);
//printf("*0mpath: %s / %s\n", path, mpath);
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
"GetState"); // method nameResolveHostName
//printf("*1mpath: %s / %s\n", path, mpath);
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
//printf("*2mpath: %s / %s\n", path, mpath);
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);
dbus_uint32_t m_state;
if (!dbus_message_iter_init(msg, &args)){
g_message("dbus_message_iter_init fail\n");
}
if(dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_ERROR){
char *result;
g_message("arg type: %d", dbus_message_iter_get_arg_type(&args));
dbus_message_iter_get_basic(&args, &result);
g_message("error: %s", result);
}else{
if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not DBUS_TYPE_INT32!\n");
else{
dbus_message_iter_get_basic(&args, &m_state);
printf("m_state : %d\n", m_state);
}
}
dbus_message_unref(msg);
}
void* FcitxNotificationItemCreate(FcitxInstance* instance)
{
FcitxNotificationItem* notificationitem = fcitx_utils_new(FcitxNotificationItem);
notificationitem->owner = instance;
DBusError err;
dbus_error_init(&err);
do {
DBusConnection *conn = FcitxDBusGetConnection(instance);
if (conn == NULL) {
FcitxLog(ERROR, "DBus Not initialized");
break;
}
notificationitem->conn = conn;
if (!dbus_connection_add_filter(notificationitem->conn, FcitxNotificationItemDBusFilter, notificationitem, NULL)) {
FcitxLog(ERROR, "No memory");
break;
}
DBusObjectPathVTable fcitxIPCVTable = {NULL, &FcitxNotificationItemEventHandler, NULL, NULL, NULL, NULL };
if (!dbus_connection_register_object_path(notificationitem->conn, NOTIFICATION_ITEM_DEFAULT_OBJ, &fcitxIPCVTable, notificationitem)) {
FcitxLog(ERROR, "No memory");
break;
}
if (!FcitxDBusMenuCreate(notificationitem)) {
FcitxLog(ERROR, "No memory");
break;
}
dbus_bus_add_match(notificationitem->conn,
"type='signal',"
"interface='" DBUS_INTERFACE_DBUS "',"
"path='" DBUS_PATH_DBUS "',"
"member='NameOwnerChanged',"
"arg0='" NOTIFICATION_WATCHER_DBUS_ADDR "'",
&err);
dbus_connection_flush(notificationitem->conn);
if (dbus_error_is_set(&err)) {
FcitxLog(ERROR, "Match Error (%s)", err.message);
break;
}
const char* notificationWatcher = NOTIFICATION_WATCHER_DBUS_ADDR;
DBusMessage* message = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "NameHasOwner");
dbus_message_append_args(message, DBUS_TYPE_STRING, ¬ificationWatcher, DBUS_TYPE_INVALID);
DBusPendingCall* call = NULL;
dbus_bool_t reply = dbus_connection_send_with_reply(notificationitem->conn, message,
&call,
0);
if (reply == TRUE) {
dbus_pending_call_set_notify(call,
NotificationWatcherServiceExistCallback,
notificationitem,
NULL);
}
dbus_connection_flush(notificationitem->conn);
dbus_message_unref(message);
FcitxIMEventHook hk;
hk.arg = notificationitem;
hk.func = FcitxNotificationItemIMChanged;
FcitxInstanceRegisterIMChangedHook(instance, hk);
FcitxInstanceRegisterInputFocusHook(instance, hk);
FcitxInstanceRegisterInputUnFocusHook(instance, hk);
dbus_error_free(&err);
FcitxNotificationItemAddFunctions(instance);
return notificationitem;
} while(0);
dbus_error_free(&err);
FcitxNotificationItemDestroy(notificationitem);
return NULL;
}
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 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;
}