void DBus_RemoveTimeout(DBusTimeout *timeout, void *data)
{
Tcl_TimerToken token;
token = dbus_timeout_get_data(timeout);
Tcl_DeleteTimerHandler(token);
}
/**
* Computes the time until the next timeout expiration.
* @note Interface lock must be held.
* @return The time in milliseconds until the next expiration,
* or -1 if there are no pending timeouts.
*/
static int next_timeout(intf_thread_t *intf)
{
intf_sys_t *sys = intf->p_sys;
mtime_t next_timeout = LAST_MDATE;
unsigned count = vlc_array_count(sys->p_timeouts);
for (unsigned i = 0; i < count; i++)
{
DBusTimeout *to = vlc_array_item_at_index(sys->p_timeouts, i);
if (!dbus_timeout_get_enabled(to))
continue;
mtime_t *expiry = dbus_timeout_get_data(to);
if (next_timeout > *expiry)
next_timeout = *expiry;
}
if (next_timeout >= LAST_MDATE)
return -1;
next_timeout /= 1000;
if (next_timeout > INT_MAX)
return INT_MAX;
return (int)next_timeout;
}
/**
* UpdateTimeouts() updates the remaining time for each timeout and
* returns how much time is left until the next timeout.
*
* This function must be called with p_sys->lock locked
*
* @return int The time remaining until the next timeout, in milliseconds
* or -1 if there are no timeouts
*
* @param intf_thread_t *p_intf This interface thread's state
* @param mtime_t i_loop_interval The time which has elapsed since the last
* call to this function
*/
static int UpdateTimeouts( intf_thread_t *p_intf, mtime_t i_loop_interval )
{
intf_sys_t *p_sys = p_intf->p_sys;
mtime_t i_next_timeout = LAST_MDATE;
unsigned int i_timeouts = vlc_array_count( p_sys->p_timeouts );
if( 0 == i_timeouts )
return -1;
for( unsigned int i = 0; i < i_timeouts; i++ )
{
timeout_info_t *p_info = NULL;
DBusTimeout *p_timeout = NULL;
mtime_t i_interval = 0;
p_timeout = vlc_array_item_at_index( p_sys->p_timeouts, i );
i_interval = dbus_timeout_get_interval( p_timeout ) * 1000; /* µs */
p_info = (timeout_info_t*) dbus_timeout_get_data( p_timeout );
p_info->i_remaining -= __MAX( 0, i_loop_interval ) % i_interval;
if( !dbus_timeout_get_enabled( p_timeout ) )
continue;
/* The correct poll timeout value is the shortest one
* in the dbus timeouts list */
i_next_timeout = __MIN( i_next_timeout,
__MAX( 0, p_info->i_remaining ) );
}
/* next timeout in milliseconds */
return i_next_timeout / 1000;
}
static void
connection_setup_remove_timeout (ConnectionSetup *cs, DBusTimeout *timeout)
{
TimeoutHandler *handler = dbus_timeout_get_data (timeout);
if (handler != NULL)
timeout_handler_destroy_source (handler);
}
static void
timeout_toggle(DBusTimeout *timeout, void *data)
{
struct timeout *t;
(void)data;
lem_debug("timeout = %p, interval = %d, enabled = %s",
(void *)timeout,
dbus_timeout_get_interval(timeout),
dbus_timeout_get_enabled(timeout) ? "true" : "false");
t = dbus_timeout_get_data(timeout);
if (dbus_timeout_get_enabled(timeout)) {
ev_tstamp interval =
((ev_tstamp)dbus_timeout_get_interval(timeout))/1000.0;
if (ev_is_active(&t->ev))
ev_timer_stop(EV_G_ &t->ev);
ev_timer_set(&t->ev, interval, interval);
ev_timer_start(EV_G_ &t->ev);
} else
ev_timer_stop(EV_G_ &t->ev);
}
static void toggle_timeout(DBusTimeout *timeout, void *data){
/* reset expiration data */
struct timeval *expires = dbus_timeout_get_data(timeout);
timer_remove_by_data (timeout);
asdbus_set_dbus_timer (expires, timeout);
}
static void timeout_toggled(DBusTimeout *dbus_timeout, AVAHI_GCC_UNUSED void *userdata) {
TimeoutData *timeout;
assert(dbus_timeout);
timeout = dbus_timeout_get_data(dbus_timeout);
assert(timeout);
update_timeout(timeout);
}
/**
* Callback for removing D-Bus timeout.
*/
static void
cdbus_callback_remove_timeout(DBusTimeout *timeout, void *data) {
session_t *ps = data;
timeout_t *ptmout = dbus_timeout_get_data(timeout);
assert(ptmout);
if (ptmout)
timeout_drop(ps, ptmout);
}
static void weston_dbus_remove_timeout(DBusTimeout *timeout, void *data)
{
struct wl_event_source *s;
s = dbus_timeout_get_data(timeout);
if (!s)
return;
wl_event_source_remove(s);
}
/* DBusRemoveTimeoutFunction callback for pa mainloop */
static void remove_timeout(DBusTimeout *timeout, void *data) {
pa_dbus_wrap_connection *c = data;
pa_time_event *ev;
pa_assert(timeout);
pa_assert(c);
if ((ev = dbus_timeout_get_data(timeout)))
c->mainloop->time_free(ev);
}
static void weston_dbus_toggle_timeout(DBusTimeout *timeout, void *data)
{
struct wl_event_source *s;
s = dbus_timeout_get_data(timeout);
if (!s)
return;
weston_dbus_adjust_timeout(timeout, s);
}
void DBusHandler::Callbacks::removeTimeout(DBusTimeout* timeout, void* data)
{
wl_event_source* s = (wl_event_source*) dbus_timeout_get_data(timeout);
if(!s)
{
ny::sendWarning("dbusRemoveTimeout: dbus timeout has no data");
return;
}
wl_event_source_remove(s);
}
void DBusHandler::Callbacks::toggleTimeout(DBusTimeout* timeout, void* data)
{
wl_event_source* s = (wl_event_source*) dbus_timeout_get_data(timeout);
if(!s)
{
ny::sendWarning("dbusToggleTimeout: dbus timeout has no data");
return;
}
adjustTimeout(timeout, s);
}
static void
pcmk_dbus_timeout_remove(DBusTimeout *timeout, void *data){
void *vid = dbus_timeout_get_data(timeout);
guint id = GPOINTER_TO_UINT(vid);
crm_trace("Removing timeout %p (%p)", timeout, data);
if(id) {
g_source_remove(id);
dbus_timeout_set_data(timeout, 0, NULL);
}
}
/**
* Callback for toggling a D-Bus timeout.
*/
static void
cdbus_callback_timeout_toggled(DBusTimeout *timeout, void *data) {
timeout_t *ptmout = dbus_timeout_get_data(timeout);
assert(ptmout);
if (ptmout) {
ptmout->enabled = dbus_timeout_get_enabled(timeout);
// Refresh interval as libdbus doc says: "Whenever a timeout is toggled,
// its interval may change."
ptmout->interval = dbus_timeout_get_interval(timeout);
}
}
static void remove_timeout(DBusTimeout *timeout, void *data) {
EpollData _cleanup_free_ *e = NULL;
assert(timeout);
e = dbus_timeout_get_data(timeout);
if (!e)
return;
assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_DEL, e->fd, NULL) >= 0);
close_nointr_nofail(e->fd);
}
static void remove_timeout(DBusTimeout *dbus_timeout, void *userdata) {
ConnectionData *d = userdata;
TimeoutData *timeout;
assert(dbus_timeout);
assert(d);
timeout = dbus_timeout_get_data(dbus_timeout);
assert(timeout);
d->poll_api->timeout_free(timeout->avahi_timeout);
timeout->avahi_timeout = NULL;
}
static void toggle_timeout(DBusTimeout *to, void *data)
{
intf_thread_t *intf = data;
intf_sys_t *sys = intf->p_sys;
mtime_t *expiry = dbus_timeout_get_data(to);
vlc_mutex_lock(&sys->lock);
if (dbus_timeout_get_enabled(to))
*expiry = mdate() + UINT64_C(1000) * dbus_timeout_get_interval(to);
vlc_mutex_unlock(&sys->lock);
wakeup_main_loop(intf);
}
static void toggle_timeout(DBusTimeout *timeout, void *data) {
EpollData *e;
int r;
assert(timeout);
e = dbus_timeout_get_data(timeout);
if (!e)
return;
r = timeout_arm(e);
if (r < 0)
log_error("Failed to rearm timer: %s", strerror(-r));
}
static void
timeout_remove(DBusTimeout *timeout, void *data)
{
struct timeout *t;
(void)data;
lem_debug("timeout = %p, interval = %d, enabled = %s",
(void *)timeout,
dbus_timeout_get_interval(timeout),
dbus_timeout_get_enabled(timeout) ? "true" : "false");
t = dbus_timeout_get_data(timeout);
ev_timer_stop(EV_G_ &t->ev);
free(t);
}
/* DBusTimeoutToggledFunction callback for pa mainloop */
static void toggle_timeout(DBusTimeout *timeout, void *data) {
struct timeout_data *d = data;
pa_time_event *ev;
struct timeval tv;
pa_assert(d);
pa_assert(d->connection);
pa_assert(timeout);
pa_assert_se(ev = dbus_timeout_get_data(timeout));
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
connection_setup_add_timeout (ConnectionSetup *cs,
DBusTimeout *timeout)
{
TimeoutHandler *handler;
if (!dbus_timeout_get_enabled (timeout))
return;
g_assert (dbus_timeout_get_data (timeout) == NULL);
handler = g_new0 (TimeoutHandler, 1);
handler->cs = cs;
handler->timeout = timeout;
handler->source = g_timeout_source_new (dbus_timeout_get_interval (timeout));
g_source_set_callback (handler->source, timeout_handler_dispatch, handler,
timeout_handler_source_finalized);
g_source_attach (handler->source, handler->cs->context);
cs->timeouts = g_slist_prepend (cs->timeouts, handler);
dbus_timeout_set_data (timeout, handler, timeout_handler_timeout_freed);
}
/**
* ProcessTimeouts() handles DBus timeouts
*
* This function must be called with p_sys->lock locked
*
* @param intf_thread_t *p_intf This interface thread state
* @param DBusTimeout **p_timeouts List of timeouts to process
* @param int i_timeouts Size of p_timeouts
*/
static void ProcessTimeouts( intf_thread_t *p_intf,
DBusTimeout **p_timeouts, int i_timeouts )
{
VLC_UNUSED( p_intf );
for( int i = 0; i < i_timeouts; i++ )
{
timeout_info_t *p_info = NULL;
p_info = (timeout_info_t*) dbus_timeout_get_data( p_timeouts[i] );
if( !dbus_timeout_get_enabled( p_info->p_timeout ) )
continue;
if( p_info->i_remaining > 0 )
continue;
dbus_timeout_handle( p_info->p_timeout );
p_info->i_remaining = dbus_timeout_get_interval( p_info->p_timeout );
}
}
/**
* Process pending D-Bus timeouts.
*
* @note Interface lock must be held.
*/
static void process_timeouts(intf_thread_t *intf)
{
intf_sys_t *sys = intf->p_sys;
for (int i = 0; i < vlc_array_count(sys->p_timeouts); i++)
{
DBusTimeout *to = vlc_array_item_at_index(sys->p_timeouts, i);
if (!dbus_timeout_get_enabled(to))
continue;
mtime_t *expiry = dbus_timeout_get_data(to);
if (*expiry > mdate())
continue;
expiry += UINT64_C(1000) * dbus_timeout_get_interval(to);
vlc_mutex_unlock(&sys->lock);
dbus_timeout_handle(to);
vlc_mutex_lock(&sys->lock);
i = -1; /* lost track of state, restart from beginning */
}
}
