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;
}
static DBusMessage *port_connect(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct serial_device *device = user_data;
struct serial_port *port;
const char *pattern;
int err;
if (dbus_message_has_member(msg, "ConnectFD") && DBUS_TYPE_UNIX_FD < 0)
return btd_error_not_supported(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern,
DBUS_TYPE_INVALID) == FALSE)
return NULL;
port = find_port(device->ports, pattern);
if (!port) {
char *endptr = NULL;
int channel;
channel = strtol(pattern, &endptr, 10);
if ((endptr && *endptr != '\0') || channel < 1 || channel > 30)
return btd_error_does_not_exist(msg);
port = create_port(device, NULL, channel);
}
if (port->listener_id)
return btd_error_failed(msg, "Port already in use");
port->listener_id = g_dbus_add_disconnect_watch(conn,
dbus_message_get_sender(msg),
port_owner_exited, port,
NULL);
port->msg = dbus_message_ref(msg);
err = connect_port(port);
if (err < 0) {
error("%s", strerror(-err));
g_dbus_remove_watch(conn, port->listener_id);
port->listener_id = 0;
return btd_error_failed(msg, strerror(-err));
}
return NULL;
}
DBusHandlerResult PulseAudioControl::stepsUpdatedSignalHandler(DBusConnection *, DBusMessage *message, void *control)
{
if (message && dbus_message_has_member(message, "StepsUpdated")) {
DBusError error;
quint32 currentStep = 0;
quint32 stepCount = 0;
dbus_error_init(&error);
if (dbus_message_get_args(message, &error, DBUS_TYPE_UINT32, &stepCount, DBUS_TYPE_UINT32, ¤tStep, DBUS_TYPE_INVALID)) {
static_cast<PulseAudioControl*>(control)->setSteps(currentStep, stepCount);
}
DBUS_ERR_CHECK (error);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
void VolumeBarLogic::stepsUpdatedSignal (
DBusConnection *conn, DBusMessage *message, VolumeBarLogic *logic)
{
Q_UNUSED (conn);
if (message && dbus_message_has_member (message, "StepsUpdated")) {
DBusError error;
quint32 value = 0;
quint32 maxvalue = 0;
dbus_error_init (&error);
if (dbus_message_get_args (message, &error,
DBUS_TYPE_UINT32, &maxvalue,
DBUS_TYPE_UINT32, &value,
DBUS_TYPE_INVALID)) {
logic->stepsUpdated (value, maxvalue);
}
DBUS_ERR_CHECK (error);
}
}
static void rfcomm_connect_cb(GIOChannel *chan, GError *conn_err,
gpointer user_data)
{
struct serial_port *port = user_data;
struct serial_device *device = port->device;
struct rfcomm_dev_req req;
int sk, fd;
DBusMessage *reply;
/* Owner exited? */
if (!port->listener_id)
return;
if (conn_err) {
error("%s", conn_err->message);
reply = btd_error_failed(port->msg, conn_err->message);
goto fail;
}
sk = g_io_channel_unix_get_fd(chan);
if (dbus_message_has_member(port->msg, "ConnectFD")) {
reply = g_dbus_create_reply(port->msg, DBUS_TYPE_UNIX_FD, &sk,
DBUS_TYPE_INVALID);
g_dbus_send_message(device->conn, reply);
close(sk);
g_dbus_remove_watch(device->conn, port->listener_id);
port->listener_id = 0;
return;
}
memset(&req, 0, sizeof(req));
req.dev_id = -1;
req.flags = (1 << RFCOMM_REUSE_DLC);
bacpy(&req.src, &device->src);
bacpy(&req.dst, &device->dst);
req.channel = port->channel;
g_io_channel_unref(port->io);
port->io = NULL;
port->id = ioctl(sk, RFCOMMCREATEDEV, &req);
if (port->id < 0) {
int err = -errno;
error("ioctl(RFCOMMCREATEDEV): %s (%d)", strerror(-err), -err);
reply = btd_error_failed(port->msg, strerror(-err));
g_io_channel_shutdown(chan, TRUE, NULL);
goto fail;
}
port->dev = g_strdup_printf("/dev/rfcomm%d", port->id);
DBG("Serial port %s created", port->dev);
g_io_channel_shutdown(chan, TRUE, NULL);
/* Addressing connect port */
fd = port_open(port);
if (fd < 0)
/* Open in progress: Wait the callback */
return;
open_notify(fd, 0, port);
return;
fail:
g_dbus_send_message(device->conn, reply);
g_dbus_remove_watch(device->conn, port->listener_id);
port->listener_id = 0;
}
bool SignalMessage::has_member( const std::string& m ) const
{
return dbus_message_has_member( m_cobj, m.c_str() );
}
static DBusHandlerResult
mafw_proxy_source_dispatch_message(DBusConnection *conn,
DBusMessage *msg,
MafwProxySource *self)
{
MafwProxySourcePrivate *priv;
gchar *domain_str;
gint code;
gchar *message;
GError *error = NULL;
g_assert(conn != NULL);
g_assert(msg != NULL);
priv = MAFW_PROXY_SOURCE_GET_PRIVATE(self);
if (dbus_message_has_interface(msg, MAFW_EXTENSION_INTERFACE))
return proxy_extension_dispatch(conn, msg, self);
if (dbus_message_has_member(msg,
MAFW_PROXY_SOURCE_METHOD_BROWSE_RESULT)) {
MafwProxySourceBrowseReq *new_req = NULL;
guint browse_id;
gint remaining_count;
guint index;
gchar *object_id;
GHashTable *metadata;
DBusMessageIter imsg, iary, istr;
g_return_val_if_fail(
priv->browse_requests != NULL,
DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
dbus_message_iter_init(msg, &imsg);
dbus_message_iter_get_basic(&imsg, &browse_id);
dbus_message_iter_next(&imsg);
g_assert(dbus_message_iter_get_arg_type(&imsg) ==
DBUS_TYPE_ARRAY);
dbus_message_iter_recurse(&imsg, &iary);
while (dbus_message_iter_get_arg_type(&iary) !=
DBUS_TYPE_INVALID)
{
dbus_message_iter_recurse(&iary, &istr);
g_assert(dbus_message_iter_get_arg_type(&istr)
== DBUS_TYPE_INT32);
dbus_message_iter_get_basic(&istr,
&remaining_count);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &index);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &object_id);
dbus_message_iter_next(&istr);
mafw_dbus_message_parse_metadata(&istr,
&metadata);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &domain_str);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &code);
dbus_message_iter_next(&istr);
dbus_message_iter_get_basic(&istr, &message);
if (domain_str && domain_str[0])
g_set_error(&error,
g_quark_from_string(domain_str),
code, "%s", message);
dbus_message_iter_next(&iary);
if (!new_req)
{
new_req = g_hash_table_lookup(
priv->browse_requests,
GUINT_TO_POINTER(browse_id));
if (new_req)
new_req->emitting = TRUE;
}
if (new_req) {
new_req->browse_cb(MAFW_SOURCE(self),
browse_id,
remaining_count,
index,
object_id[0] ?
object_id :
NULL,
metadata,
new_req->user_data,
error);
if (remaining_count == 0 || new_req->stop_emitting)
{
g_hash_table_remove(
priv->browse_requests,
GUINT_TO_POINTER(browse_id));
new_req = NULL;
g_clear_error(&error);
mafw_metadata_release(metadata);
break;
}
}
else
{
g_clear_error(&error);
mafw_metadata_release(metadata);
break;
}
g_clear_error(&error);
mafw_metadata_release(metadata);
}
if (new_req) {
new_req->emitting = FALSE;
}
return DBUS_HANDLER_RESULT_HANDLED;
} else if (!dbus_message_has_path(msg,
proxy_extension_return_path(self))) {
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_METADATA_CHANGED)) {
return handle_metadata_changed_signal(self, msg);
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_CONTAINER_CHANGED)) {
return handle_container_changed_signal(self, msg);
} else if (mafw_dbus_is_signal(msg,
MAFW_SOURCE_SIGNAL_UPDATING)) {
return handle_updating_signal(self, msg);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusHandlerResult
filter_cb (DBusConnection *connection, DBusMessage *msg, void *data)
{
(void) connection;
(void) data;
const char *obj_path;
char *stream_name;
GList *list, *i;
SubscribeItem *item;
int volume = 0;
if (dbus_message_has_interface (msg, DBUS_INTERFACE_LOCAL) &&
dbus_message_has_path (msg, DBUS_PATH_LOCAL) &&
dbus_message_has_member (msg, DISCONNECTED_SIG))
{
N_DEBUG (LOG_CAT "pulseaudio disconnected, reconnecting in %d seconds",
RETRY_TIMEOUT);
disconnect_from_pulseaudio ();
// After disconnecting re-query stream restore object names.
if (subscribe_map && object_map) {
list = g_hash_table_get_values (subscribe_map);
for (i = g_list_first (list); i; i = g_list_next (i)) {
SubscribeItem *item = (SubscribeItem*) i->data;
if (item->object_path) {
g_free (item->object_path);
item->object_path = NULL;
}
}
g_list_free (list);
queue_subscribe = TRUE;
}
// If PulseAudio is restarting path to runtime files may change so we'll
// have to request DBus address again.
if (volume_pulse_address) {
g_free(volume_pulse_address);
volume_pulse_address = NULL;
}
retry_connect();
}
else if (subscribe_callback &&
dbus_message_has_interface (msg, STREAM_RESTORE_IF) &&
dbus_message_has_path (msg, STREAM_RESTORE_PATH) &&
dbus_message_has_member (msg, NEW_ENTRY_MEMBER))
{
if (!dbus_message_get_args (msg, NULL, DBUS_TYPE_OBJECT_PATH, &obj_path, DBUS_TYPE_INVALID)) {
N_WARNING (LOG_CAT "failed to get arguments for new entry");
goto end;
}
// If the entry is in subscribe_map but not in object_map, look up the entry
// and add to object_map
if (!object_map_complete && !g_hash_table_lookup (object_map, obj_path)) {
if ((stream_name = get_object_name (obj_path))) {
if ((item = g_hash_table_lookup (subscribe_map, stream_name))) {
item->object_path = g_strdup (obj_path);
N_DEBUG (LOG_CAT "stream restore entry for %s appeared (%s)", item->stream_name, item->object_path);
update_object_map_listen ();
}
g_free (stream_name);
}
}
}
else if (subscribe_callback &&
dbus_message_has_interface (msg, STREAM_RESTORE_IF) &&
dbus_message_has_path (msg, STREAM_RESTORE_PATH) &&
dbus_message_has_member (msg, ENTRY_REMOVED_MEMBER))
{
if (!dbus_message_get_args (msg, NULL, DBUS_TYPE_OBJECT_PATH, &obj_path, DBUS_TYPE_INVALID)) {
N_WARNING (LOG_CAT "failed to get arguments for removed entry");
goto end;
}
if ((item = g_hash_table_lookup (object_map, obj_path))) {
g_hash_table_remove (object_map, item->object_path);
g_free (item->object_path);
item->object_path = NULL;
update_object_map_listen ();
N_DEBUG (LOG_CAT "removed entry %s from object map (%s)", item->stream_name, obj_path);
}
}
else if (subscribe_callback &&
dbus_message_has_interface (msg, STREAM_ENTRY_IF) &&
dbus_message_has_member (msg, VOLUME_UPDATED_MEMBER))
{
if (!(obj_path = dbus_message_get_path (msg)))
goto end;
if ((item = g_hash_table_lookup (object_map, obj_path))) {
N_DEBUG (LOG_CAT "volume updated for stream %s (%s)", item->stream_name, item->object_path);
if (get_volume (msg, &volume)) {
subscribe_callback (item->stream_name, FROM_PA_VOL(volume), item->data, subscribe_userdata);
}
}
}
end:
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
