pa_mainloop_api *mainloop;
DBusConnection *connection;
pa_defer_event* dispatch_event;
- pa_bool_t use_rtclock:1;
+ bool use_rtclock:1;
};
struct timeout_data {
- pa_dbus_wrap_connection *c;
+ pa_dbus_wrap_connection *connection;
DBusTimeout *timeout;
};
static void dispatch_cb(pa_mainloop_api *ea, pa_defer_event *ev, void *userdata) {
DBusConnection *conn = userdata;
- if (dbus_connection_dispatch(conn) == DBUS_DISPATCH_COMPLETE) {
+ if (dbus_connection_dispatch(conn) == DBUS_DISPATCH_COMPLETE)
/* no more data to process, disable the deferred */
ea->defer_enable(ev, 0);
- }
}
/* DBusDispatchStatusFunction callback for the pa mainloop */
struct timeout_data *d = userdata;
pa_assert(d);
- pa_assert(d->c);
+ pa_assert(d->connection);
if (dbus_timeout_get_enabled(d->timeout)) {
- dbus_timeout_handle(d->timeout);
+ /* Restart it for the next scheduled time. We do this before
+ * calling dbus_timeout_handle() to make sure that the time
+ * event is still around. */
+ ea->time_restart(e, pa_timeval_rtstore(&tv,
+ pa_timeval_load(t) + dbus_timeout_get_interval(d->timeout) * PA_USEC_PER_MSEC,
+ d->connection->use_rtclock));
- /* restart it for the next scheduled time */
- ea->time_restart(e, pa_timeval_rtstore(&tv, pa_timeval_load(t) + dbus_timeout_get_interval(d->timeout) * PA_USEC_PER_MSEC, d->c->use_rtclock));
+ dbus_timeout_handle(d->timeout);
}
}
dbus_watch_set_data(watch, ev, NULL);
- return TRUE;
+ return true;
}
/* DBusRemoveWatchFunction callback for pa mainloop */
pa_assert(c);
if (!dbus_timeout_get_enabled(timeout))
- return FALSE;
+ return false;
d = pa_xnew(struct timeout_data, 1);
- d->c = c;
+ d->connection = c;
d->timeout = timeout;
ev = c->mainloop->time_new(c->mainloop, pa_timeval_rtstore(&tv, pa_rtclock_now() + dbus_timeout_get_interval(timeout) * PA_USEC_PER_MSEC, c->use_rtclock), handle_time_event, d);
c->mainloop->time_set_destroy(ev, time_event_destroy_cb);
dbus_timeout_set_data(timeout, ev, NULL);
- return TRUE;
+ return true;
}
/* DBusRemoveTimeoutFunction callback for pa mainloop */
struct timeval tv;
pa_assert(d);
- pa_assert(d->c);
+ pa_assert(d->connection);
pa_assert(timeout);
pa_assert_se(ev = dbus_timeout_get_data(timeout));
- if (dbus_timeout_get_enabled(timeout)) {
- d->c->mainloop->time_restart(ev, pa_timeval_rtstore(&tv, pa_rtclock_now() + dbus_timeout_get_interval(timeout) * PA_USEC_PER_MSEC, d->c->use_rtclock));
- } else
- d->c->mainloop->time_restart(ev, pa_timeval_rtstore(&tv, PA_USEC_INVALID, d->c->use_rtclock));
+ if (dbus_timeout_get_enabled(timeout))
+ d->connection->mainloop->time_restart(ev, pa_timeval_rtstore(&tv, pa_rtclock_now() + dbus_timeout_get_interval(timeout) * PA_USEC_PER_MSEC, d->connection->use_rtclock));
+ else
+ d->connection->mainloop->time_restart(ev, pa_timeval_rtstore(&tv, PA_USEC_INVALID, d->connection->use_rtclock));
}
static void wakeup_main(void *userdata) {
c->mainloop->defer_enable(c->dispatch_event, 1);
}
-pa_dbus_wrap_connection* pa_dbus_wrap_connection_new(pa_mainloop_api *m, pa_bool_t use_rtclock, DBusBusType type, DBusError *error) {
+pa_dbus_wrap_connection* pa_dbus_wrap_connection_new(pa_mainloop_api *m, bool use_rtclock, DBusBusType type, DBusError *error) {
DBusConnection *conn;
pa_dbus_wrap_connection *pconn;
char *id;
pconn->connection = conn;
pconn->use_rtclock = use_rtclock;
- dbus_connection_set_exit_on_disconnect(conn, FALSE);
+ dbus_connection_set_exit_on_disconnect(conn, false);
dbus_connection_set_dispatch_status_function(conn, dispatch_status, pconn, NULL);
dbus_connection_set_watch_functions(conn, add_watch, remove_watch, toggle_watch, pconn, NULL);
dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout, toggle_timeout, pconn, NULL);
pa_dbus_wrap_connection* pa_dbus_wrap_connection_new_from_existing(
pa_mainloop_api *m,
- pa_bool_t use_rtclock,
+ bool use_rtclock,
DBusConnection *conn) {
pa_dbus_wrap_connection *pconn;
pconn->connection = dbus_connection_ref(conn);
pconn->use_rtclock = use_rtclock;
- dbus_connection_set_exit_on_disconnect(conn, FALSE);
+ dbus_connection_set_exit_on_disconnect(conn, false);
dbus_connection_set_dispatch_status_function(conn, dispatch_status, pconn, NULL);
dbus_connection_set_watch_functions(conn, add_watch, remove_watch, toggle_watch, pconn, NULL);
dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout, toggle_timeout, pconn, NULL);
va_end(ap);
va_start(ap, error);
for (; k > 0; k--) {
- DBusError e;
-
pa_assert_se(t = va_arg(ap, const char*));
-
- dbus_error_init(&e);
- dbus_bus_remove_match(c, t, &e);
- dbus_error_free(&e);
+ dbus_bus_remove_match(c, t, NULL);
}
va_end(ap);
void pa_dbus_remove_matches(DBusConnection *c, ...) {
const char *t;
va_list ap;
- DBusError error;
pa_assert(c);
- dbus_error_init(&error);
-
va_start(ap, c);
- while ((t = va_arg(ap, const char*))) {
- dbus_bus_remove_match(c, t, &error);
- dbus_error_free(&error);
- }
+ while ((t = va_arg(ap, const char*)))
+ dbus_bus_remove_match(c, t, NULL);
va_end(ap);
}
}
}
+const char *pa_dbus_get_error_message(DBusMessage *m) {
+ const char *message;
+
+ pa_assert(m);
+ pa_assert(dbus_message_get_type(m) == DBUS_MESSAGE_TYPE_ERROR);
+
+ if (dbus_message_get_signature(m)[0] != 's')
+ return "<no explanation>";
+
+ pa_assert_se(dbus_message_get_args(m, NULL, DBUS_TYPE_STRING, &message, DBUS_TYPE_INVALID));
+
+ return message;
+}
+
void pa_dbus_send_error(DBusConnection *c, DBusMessage *in_reply_to, const char *name, const char *format, ...) {
va_list ap;
char *message;
pa_assert_se(dbus_message_iter_append_basic(&array_iter, item_type, &((uint8_t*) array)[i * item_size]));
pa_assert_se(dbus_message_iter_close_container(iter, &array_iter));
-};
+}
void pa_dbus_append_basic_variant(DBusMessageIter *iter, int type, void *data) {
DBusMessageIter variant_iter;