static DBusHandlerResult message_cb(DBusConnection *conn, DBusMessage *msg, void *user_data) {
pa_dbusobj_server_lookup *sl = user_data;
pa_assert(conn);
pa_assert(msg);
pa_assert(sl);
/* pa_log("Got message! type = %s path = %s iface = %s member = %s dest = %s", dbus_message_type_to_string(dbus_message_get_type(msg)), dbus_message_get_path(msg), dbus_message_get_interface(msg), dbus_message_get_member(msg), dbus_message_get_destination(msg)); */
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_METHOD_CALL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE, "Introspect") ||
(!dbus_message_get_interface(msg) && dbus_message_has_member(msg, "Introspect")))
return handle_introspect(conn, msg, sl);
if (dbus_message_is_method_call(msg, DBUS_INTERFACE_PROPERTIES, "Get") ||
(!dbus_message_get_interface(msg) && dbus_message_has_member(msg, "Get")))
return handle_get(conn, msg, sl);
if (dbus_message_is_method_call(msg, DBUS_INTERFACE_PROPERTIES, "Set") ||
(!dbus_message_get_interface(msg) && dbus_message_has_member(msg, "Set")))
return handle_set(conn, msg, sl);
if (dbus_message_is_method_call(msg, DBUS_INTERFACE_PROPERTIES, "GetAll") ||
(!dbus_message_get_interface(msg) && dbus_message_has_member(msg, "GetAll")))
return handle_get_all(conn, msg, sl);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult avahi_dbus_msg_record_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) {
DBusError error;
RecordBrowserInfo *i = userdata;
assert(c);
assert(m);
assert(i);
dbus_error_init(&error);
avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s",
dbus_message_get_interface(m),
dbus_message_get_path(m),
dbus_message_get_member(m));
/* Introspection */
if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
return avahi_dbus_handle_introspect(c, m, "org.freedesktop.Avahi.RecordBrowser.xml");
/* Access control */
if (strcmp(dbus_message_get_sender(m), i->client->name))
return avahi_dbus_respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL);
if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "Free")) {
if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
avahi_log_warn("Error parsing RecordBrowser::Free message");
goto fail;
}
avahi_dbus_record_browser_free(i);
return avahi_dbus_respond_ok(c, m);
}
if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "Start")) {
if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) {
avahi_log_warn("Error parsing RecordBrowser::Start message");
goto fail;
}
avahi_dbus_record_browser_start(i);
return avahi_dbus_respond_ok(c, m);
}
avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m));
fail:
if (dbus_error_is_set(&error))
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
dbus_incoming_message(DBusConnection *conn, DBusMessage *msg, void *user_data)
{
DBusMessage *reply;
if (strcmp(DBUS_IFACE, dbus_message_get_interface(msg)) == 0) {
DBusError error;
dbus_error_init(&error);
if (strcmp("SetAudioState", dbus_message_get_member(msg)) == 0)
reply_to_set_audio_state(msg, conn);
if (strcmp("SetBrightness", dbus_message_get_member(msg)) == 0)
reply_to_set_brightness(msg, conn);
if (strcmp("GetBrightness", dbus_message_get_member(msg)) == 0)
reply_to_get_brightness(msg, conn);
if (strcmp("Shutdown", dbus_message_get_member(msg)) == 0)
reply_to_shutdown(msg, conn);
if (strcmp("Suspend", dbus_message_get_member(msg)) == 0)
reply_to_suspend(msg, conn);
if (strcmp("Reboot", dbus_message_get_member(msg)) == 0)
reply_to_reboot(msg, conn);
if (strcmp("GetDevice", dbus_message_get_member(msg)) == 0)
reply_to_get_device(msg, conn);
else {
reply = dbus_message_new_error(msg,
"org.cneo.System.UnknownMethod",
"Unknown method");
dbus_connection_send(conn, reply, NULL);
dbus_message_unref(reply);
}
} else {
fprintf(stderr, "Ignoring message with %s.%s\n",
dbus_message_get_interface(msg),
dbus_message_get_member(msg));
reply = dbus_message_new_error(msg,
"org.cneo.System.UnknownMethod",
"Unknown method");
dbus_connection_send(conn, reply, NULL);
dbus_message_unref(reply);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult message_handler(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *method = dbus_message_get_member(msg);
const char *iface = dbus_message_get_interface(msg);
if ((strcmp("Introspect", method) == 0) &&
(strcmp("org.freedesktop.DBus.Introspectable", iface) == 0))
return introspect(conn, msg);
if (strcmp("org.bluez.Agent", iface) != 0)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (strcmp("Release", method) == 0) {
g_main_loop_quit(main_loop);
return generic_message(conn, msg);
}
else if (strcmp("RequestPasskey", method) == 0)
return request_passkey_message(conn, msg);
else if (strcmp("Authorize", method) == 0)
return authorize_message(conn, msg);
else if (strcmp("ConfirmModeChange", method) == 0)
return confirm_mode_message(conn, msg);
else if (strcmp("Cancel", method) == 0)
return generic_message(conn, msg);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult watch_signal(DBusConnection* connection, DBusMessage *msg,
void *no_use)
{
NOUSED(no_use);
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (__sig_info_hash == NULL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
const char* iface = dbus_message_get_interface(msg);
const char* s_name = dbus_message_get_member(msg);
const char* path = dbus_message_get_path(msg);
char* server_id = dbus_connection_get_server_id(connection);
char* key = g_strdup_printf("%s:%s:%s@%s", path, iface, s_name, server_id);
free(server_id);
GHashTable* cbs_info = g_hash_table_lookup(__sig_info_hash, key);
g_free(key);
if (cbs_info == NULL) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else {
struct HandleSignalInfo *t = g_new(struct HandleSignalInfo, 1);
t->cbs = cbs_info;
t->msg = dbus_message_ref(msg);
g_timeout_add(get_timeout(), delay_handle_signal, t);
return DBUS_HANDLER_RESULT_HANDLED;
}
}
static DBusHandlerResult devicelock_unlocked_cb(DBusConnection *conn, DBusMessage *msg, void *user_data)
{
DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
const char *interface = dbus_message_get_interface(msg);
const char *member = dbus_message_get_member(msg);
const char *object = dbus_message_get_path(msg);
int type = dbus_message_get_type(msg);
int ret=0, ret1 = 0;
(void) user_data;
// sanity checks
if( !interface || !member || !object ) goto cleanup;
if( type != DBUS_MESSAGE_TYPE_SIGNAL ) goto cleanup;
if( strcmp(interface, DEVICELOCK_REQUEST_IF) ) goto cleanup;
if( strcmp(object, DEVICELOCK_REQUEST_PATH) ) goto cleanup;
// handle known signals
else if( !strcmp(member, "stateChanged") )
{
dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &ret1, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
log_debug("Devicelock state changed. New state = %d\n", ret);
if(ret == 0 && get_usb_connection_state() == 1 )
{
if(!strcmp(get_usb_mode(), MODE_UNDEFINED) || !strcmp(get_usb_mode(), MODE_CHARGING))
set_usb_connected_state();
}
}
result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
cleanup:
return result;
}
static DBusHandlerResult generic_message(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct generic_data *data = user_data;
struct interface_data *iface;
const GDBusMethodTable *method;
const char *interface;
interface = dbus_message_get_interface(message);
iface = find_interface(data->interfaces, interface);
if (iface == NULL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
for (method = iface->methods; method &&
method->name && method->function; method++) {
if (dbus_message_is_method_call(message, iface->name,
method->name) == FALSE)
continue;
if (dbus_message_has_signature(message,
method->signature) == FALSE)
continue;
if (check_privilege(connection, message, method,
iface->user_data) == TRUE)
return DBUS_HANDLER_RESULT_HANDLED;
return process_message(connection, message, method,
iface->user_data);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message)
{
dbus_bool_t result = FALSE;
if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL)
dbus_message_set_no_reply(message, TRUE);
else if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL) {
const char *path = dbus_message_get_path(message);
const char *interface = dbus_message_get_interface(message);
const char *name = dbus_message_get_member(message);
const GDBusArgInfo *args;
if (!check_signal(connection, path, interface, name, &args))
goto out;
}
/* Flush pending signal to guarantee message order */
g_dbus_flush(connection);
result = dbus_connection_send(connection, message, NULL);
out:
dbus_message_unref(message);
return result;
}
void
handle_core_message(DBusMessage *bus_msg, const char *path, const char *iface, const char *method, const char *sender, PyObject *py_args)
{
if (strcmp(method, "setLocale") == 0) {
PyDict_SetItemString(PyDict_GetItemString(py_core, "locales"), sender, PyTuple_GetItem(py_args, 0));
bus_reply_object(bus_msg, Py_True, "b");
}
else if (strcmp(method, "cancel") == 0) {
log_debug("Cancel requested.\n");
int i;
int total = 0;
// Iterate over all child processes
for (i = 0; i < my_proc.nr_children; i++) {
struct ProcChild *child = &my_proc.children[i];
if (dbus_message_has_sender(child->bus_msg, sender)) {
kill(child->pid, SIGINT);
total++;
}
}
log_debug("Killed %d processes.\n", total);
bus_reply_object(bus_msg, PyInt_FromLong((long) total), "i");
}
else if (strcmp(method, "listRunning") == 0) {
int i;
PyObject *py_list = PyList_New(0);
// Iterate over all child processes
for (i = 0; i < my_proc.nr_children; i++) {
struct ProcChild *child = &my_proc.children[i];
if (PyTuple_GetItem(py_args, 0) == Py_True || dbus_message_has_sender(child->bus_msg, sender)) {
PyList_Append(py_list, PyString_FromFormat("%s.%s", dbus_message_get_interface(child->bus_msg), dbus_message_get_member(child->bus_msg)));
}
}
bus_reply_object(bus_msg, py_list, "as");
}
}
static DBusHandlerResult
client_dbus_filter_function (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
GsmDBusClient *client = GSM_DBUS_CLIENT (user_data);
const char *path;
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);
path = dbus_message_get_path (message);
g_debug ("GsmDBusClient: obj_path=%s interface=%s method=%s",
dbus_message_get_path (message),
dbus_message_get_interface (message),
dbus_message_get_member (message));
if (dbus_message_is_method_call (message, SM_DBUS_CLIENT_PRIVATE_INTERFACE, "EndSessionResponse")) {
g_assert (gsm_client_peek_id (GSM_CLIENT (client)) != NULL);
if (path != NULL && strcmp (path, gsm_client_peek_id (GSM_CLIENT (client))) != 0) {
/* Different object path */
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
handle_end_session_response (client, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult message_filter(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
GDBusClient *client = user_data;
const char *sender, *path, *interface;
if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
sender = dbus_message_get_sender(message);
if (sender == NULL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
path = dbus_message_get_path(message);
interface = dbus_message_get_interface(message);
if (g_str_has_prefix(path, client->base_path) == FALSE)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (g_str_equal(interface, DBUS_INTERFACE_PROPERTIES) == TRUE)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (client->signal_func)
client->signal_func(connection, message, client->signal_data);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult dispatch_method(DBusConnection *c,
DBusMessage *msg, void *data)
{
#define SAFESTR(str) (str ? str : "<none>")
const char *path = dbus_message_get_path(msg);
const char *interface = dbus_message_get_interface(msg);
const char *member = dbus_message_get_member(msg);
const char *message;
char reply[1024];
MRP_UNUSED(data);
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_METHOD_CALL || !member)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (strcmp(path, DBUS_PATH) ||
strcmp(interface, DBUS_IFACE) ||
strcmp(member, DBUS_METHOD))
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
/*info("DBUS server: got call: path='%s', interface='%s', member='%s')...",
SAFESTR(path), SAFESTR(interface), SAFESTR(member));*/
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_STRING, &message, DBUS_TYPE_INVALID)) {
snprintf(reply, sizeof(reply), "ACK: got '%s'", message);
if (!send_dbus_reply(c, msg, reply))
fatal("failed to sent reply to DBUS message");
}
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
signal_handler(lua_State *S, DBusMessage *msg)
{
lua_State *T;
const char *path = dbus_message_get_path(msg);
const char *interface = dbus_message_get_interface(msg);
const char *member = dbus_message_get_member(msg);
lem_debug("received signal\n %s\n %s\n %s(%s)",
path, interface, member,
dbus_message_get_signature(msg));
/* NOTE: this magic string representation of an
* incoming signal must match the one in the Lua code */
lua_pushfstring(S, "%s\n%s\n%s",
path ? path : "",
interface ? interface : "",
member ? member : "");
lua_rawget(S, LEM_DBUS_SIGNAL_TABLE);
if (lua_type(S, -1) != LUA_TFUNCTION) {
lua_settop(S, LEM_DBUS_TOP);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/* create new thread */
T = lem_newthread();
lua_xmove(S, T, 1);
lem_queue(T, lem_dbus_push_arguments(T, msg));
return DBUS_HANDLER_RESULT_HANDLED;
}
// Called by dbus during WaitForAndDispatchEventNative()
// This function is called on the IOThread
static DBusHandlerResult
EventFilter(DBusConnection *aConn, DBusMessage *aMsg,
void *aData)
{
DBusError err;
dbus_error_init(&err);
if (dbus_message_get_type(aMsg) != DBUS_MESSAGE_TYPE_SIGNAL) {
LOG("%s: not interested (not a signal).\n", __FUNCTION__);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
LOG("%s: Received signal %s:%s from %s\n", __FUNCTION__,
dbus_message_get_interface(aMsg), dbus_message_get_member(aMsg),
dbus_message_get_path(aMsg));
// TODO: Parse DBusMessage* on the IOThread and return as a BluetoothEvent so
// we aren't passing the pointer at all, as well as offloading parsing (not
// that it's that heavy.)
nsCOMPtr<DistributeDBusMessageTask> t(new DistributeDBusMessageTask(aMsg));
if (NS_FAILED(NS_DispatchToMainThread(t))) {
NS_WARNING("Failed to dispatch to main thread!");
}
return DBUS_HANDLER_RESULT_HANDLED;
}
static void
profile_print_with_attrs (const char *type, DBusMessage *message,
struct timeval *t, ProfileAttributeFlags attrs)
{
printf (PROFILE_TIMED_FORMAT, type, t->tv_sec, t->tv_usec);
if (attrs & PROFILE_ATTRIBUTE_FLAG_SERIAL)
printf ("\t%u", dbus_message_get_serial (message));
if (attrs & PROFILE_ATTRIBUTE_FLAG_REPLY_SERIAL)
printf ("\t%u", dbus_message_get_reply_serial (message));
if (attrs & PROFILE_ATTRIBUTE_FLAG_SENDER)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_sender (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_DESTINATION)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_destination (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_PATH)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_path (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_INTERFACE)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_interface (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_MEMBER)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_member (message)));
if (attrs & PROFILE_ATTRIBUTE_FLAG_ERROR_NAME)
printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_error_name (message)));
printf ("\n");
}
static DBusHandlerResult
default_message_filter
( DBusConnection *connection,
DBusMessage *message,
void *p
)
{
DBusConnectionState *cs = p;
uint32_t type =dbus_message_get_type( message ),
serial =dbus_message_get_serial( message );
uint8_t reply =dbus_message_get_no_reply( message )==0;
const char
*path = dbus_message_get_path( message ),
*dest = dbus_message_get_destination( message ),
*member = dbus_message_get_member( message ),
*interface=dbus_message_get_interface( message ),
*sender =dbus_message_get_sender( message ),
*signature=dbus_message_get_signature( message );
connection = connection;
if(cs->mf)
return
(*(cs->mf))( cs, type, reply, serial, dest, path, member, interface, 0L,
sender, signature, message, 0L, 0L, 0L, cs->def_mf_obj
) ;
return HANDLED;
}
bool CUDisks2Provider::PumpDriveChangeEvents(IStorageEventsCallback *callback)
{
if (m_connection)
{
dbus_connection_read_write(m_connection, 0);
DBusMessagePtr msg(dbus_connection_pop_message(m_connection));
if (msg)
{
CLog::Log(LOGDEBUG, LOGDBUS, "UDisks2: Message received (interface: %s, member: %s)",
dbus_message_get_interface(msg.get()), dbus_message_get_member(msg.get()));
if (dbus_message_is_signal(msg.get(), DBUS_INTERFACE_OBJECT_MANAGER, "InterfacesAdded"))
{
HandleInterfacesAdded(msg.get());
return false;
}
else if (dbus_message_is_signal(msg.get(), DBUS_INTERFACE_OBJECT_MANAGER, "InterfacesRemoved"))
{
return HandleInterfacesRemoved(msg.get(), callback);
}
else if (dbus_message_is_signal(msg.get(), DBUS_INTERFACE_PROPERTIES, "PropertiesChanged"))
{
return HandlePropertiesChanged(msg.get(), callback);
}
}
}
return false;
}
static DBusHandlerResult
xdbus_filter_cb(DBusConnection *con,
DBusMessage *msg,
void *aptr)
{
(void)con; (void)aptr;
DBusHandlerResult res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if( dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL )
goto EXIT;
const char *interface = dbus_message_get_interface(msg);
if( !interface )
goto EXIT;
const char *member = dbus_message_get_member(msg);
if( !member )
goto EXIT;
if( !strcmp(interface, MCE_SIGNAL_IF) )
{
if( !strcmp(member, MCE_DISPLAY_SIG) )
xdbus_handle_display_state_signal(msg);
}
EXIT:
return res;
}
//! Returns DBus message interface, used in scripts
static PyObject *
c_bus_interface(PyObject *self, PyObject *args)
{
const char *iface = dbus_message_get_interface(my_proc.bus_msg);
PyObject *py_str = PyString_FromString(iface);
Py_INCREF(py_str);
return py_str;
}
/* main() */
int main(int argc, char *argv[])
{
DBusConnection *conn = NULL;
DBusMessage *msg_query = NULL;
DBusMessage *msg_reply = NULL;
DBusError error;
const char *xml_data = NULL;
int return_code;
/* Initialize the error state. */
dbus_error_init(&error);
/* Connect to user-session D-Bus */
fprintf(stdout, "Connecting to Session D-Bus\n");
conn = dbus_bus_get(DBUS_BUS_SESSION, &error);
exit_on_error("Failed to open user-session bus.\n", &error);
/* Print unique name */
fprintf(stdout, "D-Bus unique name: %s\n", \
dbus_bus_get_unique_name(conn));
/* Request well-know name on the session bus */
return_code = dbus_bus_request_name(conn, DBUS_CLIENT_NAME, \
DBUS_NAME_FLAG_REPLACE_EXISTING, \
&error);
exit_on_error("Failed to get well-known name.", &error);
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != return_code)
exit(EXIT_FAILURE);
/* Send "Introspect" message */
msg_query = dbus_message_new_method_call(DBUS_SERVER_NAME, /* Target */
DBUS_OBJECT_PATH, /* Object */
DBUS_IFACE_INTRO, /* Interface */
"Introspect"); /* Method name */
msg_reply = dbus_connection_send_with_reply_and_block(conn, msg_query, 1000, &error);
exit_on_error("Failed to send Introspect message.", &error);
/* Get the string argument from Introspect call */
dbus_message_get_args(msg_reply, &error, DBUS_TYPE_STRING, \
&xml_data, DBUS_TYPE_INVALID);
/* Print message information */
fprintf(stdout, "Object Path \t= %s\n", dbus_message_get_path(msg_query));
fprintf(stdout, "Interface \t= %s\n", dbus_message_get_interface(msg_query));
fprintf(stdout, "Message \t= %s\n", dbus_message_get_member(msg_query));
fprintf(stdout, "Introspect xml_data:\n%s\n", xml_data);
/* Free messages */
dbus_message_unref(msg_query);
dbus_message_unref(msg_reply);
/* Free the connection. */
dbus_connection_unref(conn);
return EXIT_SUCCESS;
}
/**
* @brief Optionally prints a trace of a D-Bus message depending on the "level".
*
* @param [in] level Trace mask controlling whether trace appears.
* @param [in] msg The D-Bus message to trace.
*/
void
l2dbus_traceMessage
(
unsigned level,
struct DBusMessage* msg
)
{
const cdbus_Char* msgTypeStr ="UNKNOWN";
cdbus_Int32 msgType = DBUS_MESSAGE_TYPE_INVALID;
const cdbus_Char* path = NULL;
const cdbus_Char* intf = NULL;
const cdbus_Char* name = NULL;
const cdbus_Char* dest = NULL;
const cdbus_Char* errName = NULL;
if ( NULL != msg )
{
msgType = dbus_message_get_type(msg);
msgTypeStr = dbus_message_type_to_string(msgType);
if ( (DBUS_MESSAGE_TYPE_METHOD_CALL == msgType) ||
(DBUS_MESSAGE_TYPE_SIGNAL == msgType) )
{
path = dbus_message_get_path(msg);
intf = dbus_message_get_interface(msg);
name = dbus_message_get_member(msg);
l2dbus_trace(level, "(Ser=%u) [%s] <%s> %s%s%s",
dbus_message_get_serial(msg),
msgTypeStr,
path ? path : "",
intf ? intf : "",
intf ? "." : "",
name ? name : "");
}
else if (DBUS_MESSAGE_TYPE_METHOD_RETURN == msgType)
{
dest = dbus_message_get_destination(msg);
l2dbus_trace(level, "(RSer=%u) [%s] -> %s",
dbus_message_get_reply_serial(msg),
msgTypeStr,
dest ? dest : "");
}
else if (DBUS_MESSAGE_TYPE_ERROR == msgType )
{
errName = dbus_message_get_error_name(msg);
l2dbus_trace(level, "(RSer=%u) [%s] %s",
dbus_message_get_reply_serial(msg),
msgTypeStr,
errName ? errName : "");
}
else
{
l2dbus_trace(level, "(Ser=%u) [%s]",
dbus_message_get_serial(msg),
msgTypeStr);
}
}
}
static DBusHandlerResult
message_handler (DBusConnection *bus, DBusMessage *message, void *user_data)
{
const char *iface = dbus_message_get_interface (message);
const char *member = dbus_message_get_member (message);
DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
gboolean exit = FALSE;
DBusMessage *reply = NULL;
g_return_val_if_fail(iface != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
if (!strcmp(iface, "org.codethink.atspi.test"))
{
if (!strcmp(member, "next"))
{
next();
reply = dbus_message_new_method_return (message);
g_assert(reply != NULL);
result = DBUS_HANDLER_RESULT_HANDLED;
}
if (!strcmp(member, "finish"))
{
((VoidVoid) test_module_finished)();
reply = dbus_message_new_method_return (message);
g_assert(reply != NULL);
result = DBUS_HANDLER_RESULT_HANDLED;
exit = TRUE;
}
}
if (!strcmp(iface, "org.freedesktop.DBus.Introspectable"))
{
if (!strcmp(member, "Introspect"))
{
reply = dbus_message_new_method_return (message);
g_assert(reply != NULL);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_string,
DBUS_TYPE_INVALID);
result = DBUS_HANDLER_RESULT_HANDLED;
}
}
if (reply)
{
dbus_connection_send (bus, reply, NULL);
dbus_message_unref (reply);
}
if (exit == TRUE)
{
dbus_connection_flush(bus);
dbus_connection_unref(bus);
g_main_loop_quit(mainloop);
}
return result;
}
/*
* On success @param msg is unref'd or its ref is stolen by the returned
* Eldbus_Pending.
*/
Eldbus_Pending *
_eldbus_connection_send(Eldbus_Connection *conn, Eldbus_Message *msg, Eldbus_Message_Cb cb, const void *cb_data, double timeout)
{
Eldbus_Pending *pending;
Eldbus_Message *error_msg;
DBG("conn=%p, msg=%p, cb=%p, cb_data=%p, timeout=%f",
conn, msg, cb, cb_data, timeout);
if (!cb)
{
dbus_connection_send(conn->dbus_conn, msg->dbus_msg, NULL);
eldbus_message_unref(msg);
return NULL;
}
pending = calloc(1, sizeof(Eldbus_Pending));
EINA_SAFETY_ON_NULL_RETURN_VAL(pending, NULL);
pending->cb = cb;
pending->cb_data = cb_data;
pending->conn = conn;
pending->dest = eina_stringshare_add(dbus_message_get_destination(msg->dbus_msg));
pending->interface = eina_stringshare_add(dbus_message_get_interface(msg->dbus_msg));
pending->method = eina_stringshare_add(dbus_message_get_member(msg->dbus_msg));
pending->path = eina_stringshare_add(dbus_message_get_path(msg->dbus_msg));
/* Steal the reference */
pending->msg_sent = msg;
EINA_MAGIC_SET(pending, ELDBUS_PENDING_MAGIC);
if (!dbus_connection_send_with_reply(conn->dbus_conn,
msg->dbus_msg,
&pending->dbus_pending, timeout))
{
error_msg = _eldbus_message_error_get(msg, "org.enlightenment.DBus.NoConnection",
"Eldbus_Connection was closed.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
if (!pending->dbus_pending)
{
error_msg = _eldbus_message_error_get(msg, "org.enlightenment.DBus.Error",
"dbus_pending is NULL.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
if (dbus_pending_call_set_notify(pending->dbus_pending, cb_pending, pending, NULL))
return pending;
dbus_pending_call_cancel(pending->dbus_pending);
error_msg = _eldbus_message_error_get(pending->msg_sent,
"org.enlightenment.DBus.Error",
"Error when try set callback to message.");
eldbus_pending_dispatch(pending, error_msg);
return NULL;
}
static DBusHandlerResult
message_handler(DBusConnection *connection, DBusMessage *message, void *data)
{
DBusError error;
DBusMessage *reply;
struct connection_info *info = data;
/* ret is the overall D-Bus handler result, whereas err is the internal
* X error from our individual functions. */
int ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
int err;
DebugF("[config/dbus] received a message for %s\n",
dbus_message_get_interface(message));
dbus_error_init(&error);
reply = dbus_message_new_method_return(message);
if (!reply) {
ErrorF("[config/dbus] failed to create reply\n");
ret = DBUS_HANDLER_RESULT_NEED_MEMORY;
goto err_start;
}
if (strcmp(dbus_message_get_member(message), "add") == 0)
err = add_device(message, reply, &error);
else if (strcmp(dbus_message_get_member(message), "remove") == 0)
err = remove_device(message, reply, &error);
else if (strcmp(dbus_message_get_member(message), "listDevices") == 0)
err = list_devices(message, reply, &error);
else if (strcmp(dbus_message_get_member(message), "version") == 0)
err = get_version(message, reply, &error);
else
goto err_reply;
/* Failure to allocate is a special case. */
if (err == BadAlloc) {
ret = DBUS_HANDLER_RESULT_NEED_MEMORY;
goto err_reply;
}
/* While failure here is always an OOM, we don't return that,
* since that would result in devices being double-added/removed. */
if (dbus_connection_send(info->connection, reply, NULL))
dbus_connection_flush(info->connection);
else
ErrorF("[config/dbus] failed to send reply\n");
ret = DBUS_HANDLER_RESULT_HANDLED;
err_reply:
dbus_message_unref(reply);
err_start:
dbus_error_free(&error);
return ret;
}
static int ldbus_message_get_interface(lua_State *L) {
DBusMessage *message = check_DBusMessage(L, 1);
const char * interface = dbus_message_get_interface(message);
if (interface == NULL) {
lua_pushnil(L);
} else {
lua_pushstring(L, interface);
}
return 1;
}
/**
* message_handler - Handles incoming DBus messages
* @connection: DBus connection on which message was received
* @message: Received message
* @user_data: pointer to description of object to which message was sent
* Returns: Returns information whether message was handled or not
*
* Reads message interface and method name, then checks if they matches one
* of the special cases i.e. introspection call or properties get/getall/set
* methods and handles it. Else it iterates over registered methods list
* and tries to match method's name and interface to those read from message
* If appropriate method was found its handler function is called and
* response is sent. Otherwise, the DBUS_ERROR_UNKNOWN_METHOD error message
* will be sent.
*/
static DBusHandlerResult message_handler(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct wpa_dbus_object_desc *obj_dsc = user_data;
const char *method;
const char *path;
const char *msg_interface;
DBusMessage *reply;
/* get method, interface and path the message is addressed to */
method = dbus_message_get_member(message);
path = dbus_message_get_path(message);
msg_interface = dbus_message_get_interface(message);
if (!method || !path || !msg_interface)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
wpa_printf(MSG_MSGDUMP, "dbus: %s.%s (%s)",
msg_interface, method, path);
/* if message is introspection method call */
if (!os_strncmp(WPA_DBUS_INTROSPECTION_METHOD, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
!os_strncmp(WPA_DBUS_INTROSPECTION_INTERFACE, msg_interface,
WPAS_DBUS_INTERFACE_MAX)) {
#ifdef CONFIG_CTRL_IFACE_DBUS_INTRO
reply = wpa_dbus_introspect(message, obj_dsc);
#else /* CONFIG_CTRL_IFACE_DBUS_INTRO */
reply = dbus_message_new_error(
message, DBUS_ERROR_UNKNOWN_METHOD,
"wpa_supplicant was compiled without "
"introspection support.");
#endif /* CONFIG_CTRL_IFACE_DBUS_INTRO */
} else if (!os_strncmp(WPA_DBUS_PROPERTIES_INTERFACE, msg_interface,
WPAS_DBUS_INTERFACE_MAX)) {
/* if message is properties method call */
reply = properties_handler(message, obj_dsc);
} else {
reply = msg_method_handler(message, obj_dsc);
}
/* If handler succeed returning NULL, reply empty message */
if (!reply)
reply = dbus_message_new_method_return(message);
if (reply) {
if (!dbus_message_get_no_reply(message))
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
}
wpa_dbus_flush_all_changed_properties(connection);
return DBUS_HANDLER_RESULT_HANDLED;
}
static gboolean
call_dbus_method (DBusConnection *bus, DBusMessage *msg)
{
if (!dbus_connection_send (bus, msg, 0)) {
N_WARNING (LOG_CAT "failed to send DBus message %s",
dbus_message_get_member (msg), dbus_message_get_interface (msg));
return FALSE;
}
return TRUE;
}
void
print_message (DBusMessage *message, dbus_bool_t literal)
{
DBusMessageIter iter;
const char *sender;
const char *destination;
int message_type;
message_type = dbus_message_get_type (message);
sender = dbus_message_get_sender (message);
destination = dbus_message_get_destination (message);
if (!literal)
{
printf ("%s sender=%s -> dest=%s",
type_to_name (message_type),
sender ? sender : "(null sender)",
destination ? destination : "(null destination)");
switch (message_type)
{
case DBUS_MESSAGE_TYPE_METHOD_CALL:
case DBUS_MESSAGE_TYPE_SIGNAL:
printf (" serial=%u path=%s; interface=%s; member=%s\n",
dbus_message_get_serial (message),
dbus_message_get_path (message),
dbus_message_get_interface (message),
dbus_message_get_member (message));
break;
case DBUS_MESSAGE_TYPE_METHOD_RETURN:
printf (" reply_serial=%u\n",
dbus_message_get_reply_serial (message));
break;
case DBUS_MESSAGE_TYPE_ERROR:
printf (" error_name=%s reply_serial=%u\n",
dbus_message_get_error_name (message),
dbus_message_get_reply_serial (message));
break;
default:
printf ("\n");
break;
}
}
dbus_message_iter_init (message, &iter);
print_iter (&iter, literal, 1);
fflush (stdout);
}
DBusHandlerResult a2dp_event_filter(DBusMessage *msg, JNIEnv *env) {
DBusError err;
if (!nat) {
LOGV("... skipping %s\n", __FUNCTION__);
LOGV("... ignored\n");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
dbus_error_init(&err);
if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (dbus_message_is_signal(msg, "org.bluez.AudioSink",
"PropertyChanged")) {
jobjectArray str_array =
parse_property_change(env, msg, (Properties *)&sink_properties,
sizeof(sink_properties) / sizeof(Properties));
const char *c_path = dbus_message_get_path(msg);
jstring path = env->NewStringUTF(c_path);
env->CallVoidMethod(nat->me,
method_onSinkPropertyChanged,
path,
str_array);
env->DeleteLocalRef(path);
result = DBUS_HANDLER_RESULT_HANDLED;
return result;
} else if (dbus_message_is_signal(msg, "org.bluez.Control",
"GetPlayStatus")) {
const char *c_path = dbus_message_get_path(msg);
jstring path = env->NewStringUTF(c_path);
env->CallVoidMethod(nat->me, method_onGetPlayStatusRequest, path);
env->DeleteLocalRef(path);
result = DBUS_HANDLER_RESULT_HANDLED;
return result;
}else {
LOGV("... ignored");
}
if (env->ExceptionCheck()) {
LOGE("VM Exception occurred while handling %s.%s (%s) in %s,"
" leaving for VM",
dbus_message_get_interface(msg), dbus_message_get_member(msg),
dbus_message_get_path(msg), __FUNCTION__);
}
return result;
}
static DBusHandlerResult
server_message_func (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
if (gconfd_dbus_check_in_shutdown (connection, message))
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
{
g_print ("Not a method call\n");
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
if (g_strcmp0 (dbus_message_get_interface (message),
GCONF_DBUS_SERVER_INTERFACE) != 0)
{
g_print ("Not correct interface: \"%s\"\n",
dbus_message_get_interface (message));
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
if (dbus_message_is_method_call (message,
GCONF_DBUS_SERVER_INTERFACE,
GCONF_DBUS_SERVER_GET_DEFAULT_DB))
server_handle_get_default_db (connection, message);
else if (dbus_message_is_method_call (message,
GCONF_DBUS_SERVER_INTERFACE,
GCONF_DBUS_SERVER_GET_DB))
server_handle_get_db (connection, message);
else if (dbus_message_is_method_call (message,
GCONF_DBUS_SERVER_INTERFACE,
GCONF_DBUS_SERVER_SHUTDOWN))
server_handle_shutdown (connection, message);
else
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
return DBUS_HANDLER_RESULT_HANDLED;
}
