/** Initialize server timer. */
su_inline
int server_timer_init(server_t *srv)
{
if (0) {
srv->srv_timer = su_timer_create(su_root_task(srv->srv_root), SERVER_TICK);
return su_timer_set(srv->srv_timer, server_timer, srv);
}
return 0;
}
static void keepalive_timer(su_root_magic_t *root_magic,
su_timer_t *t,
su_timer_arg_t *ob_casted_as_timer_arg)
{
outbound_t *ob = (outbound_t *)ob_casted_as_timer_arg;
(void)root_magic;
if (keepalive_options(ob) < 0)
su_timer_set(t, keepalive_timer, ob_casted_as_timer_arg); /* XXX */
}
/**
* Server timer routine.
*/
static
void server_timer(su_root_magic_t *rm, su_timer_t *timer, server_t *srv)
{
uint32_t now;
su_timer_set(timer, server_timer, srv);
now = su_time_ms(su_now()); now += now == 0; srv->srv_now = now;
/* Xyzzy */
srv->srv_now = 0;
}
void SipDialog::setSessionTimer( unsigned long nSecs, SessionRefresher_t whoIsResponsible ) {
assert( NULL == m_timerSessionRefresh ) ;
m_refresher = whoIsResponsible ;
su_duration_t nMilliseconds = nSecs * 1000 ;
m_nSessionExpiresSecs = nSecs ;
DR_LOG(log_debug) << "Session expires has been set to " << nSecs << " seconds and refresher is " << (areWeRefresher() ? "us" : "them") ;
/* if we are the refresher, then we want the timer to go off halfway through the interval */
if( areWeRefresher() ) nMilliseconds /= 2 ;
m_timerSessionRefresh = su_timer_create( su_root_task(theOneAndOnlyController->getRoot()), nMilliseconds ) ;
m_ppSelf = new boost::weak_ptr<SipDialog>( shared_from_this() ) ;
su_timer_set(m_timerSessionRefresh, session_timer_handler, (su_timer_arg_t *) m_ppSelf );
}
void
print_stamp(struct tester *x, su_timer_t *t, struct timing *ti)
{
su_time_t now = su_now(), prev = ti->t_prev;
ti->t_prev = now;
printf("timer interval %f\n", 1000 * su_time_diff(now, prev));
if (!ti->t_run)
su_timer_set(t, print_stamp, ti);
if (++ti->t_times >= 10)
su_timer_reset(t);
}
/**@internal
* Timer routine.
*
* Go through all active handles and execute pending tasks
*/
void nua_stack_timer(nua_t *nua, su_timer_t *t, su_timer_arg_t *a)
{
nua_handle_t *nh, *nh_next;
sip_time_t now = sip_now();
su_root_t *root = su_timer_root(t);
su_timer_set(t, nua_stack_timer, a);
if (nua->nua_shutdown) {
nua_stack_shutdown(nua);
return;
}
for (nh = nua->nua_handles; nh; nh = nh_next) {
nh_next = nh->nh_next;
nh_call_pending(nh, now);
su_root_yield(root); /* Handle received packets */
}
}
/**
* Engine timer routine.
*/
static
void he_timer(su_root_magic_t *rm, su_timer_t *timer, nth_engine_t * he)
{
unsigned i;
uint32_t now;
hc_htable_t *hct = he->he_clients;
now = su_time_ms(su_now());
now += now == 0;
he->he_now = now;
if (hct)
for (i = hct->hct_size; i > 0;)
if (hct->hct_table[--i])
hc_timer(he, hct->hct_table[i], now);
su_timer_set(timer, he_timer, he);
he->he_now = 0;
}
/** @internal Shut down stack. */
void nua_stack_shutdown(nua_t *nua)
{
nua_handle_t *nh, *nh_next;
int busy = 0;
sip_time_t now = sip_now();
int status;
char const *phrase;
enter;
if (!nua->nua_shutdown)
nua->nua_shutdown = now;
for (nh = nua->nua_handles; nh; nh = nh_next) {
nua_dialog_state_t *ds = nh->nh_ds;
nh_next = nh->nh_next;
busy += nua_dialog_repeat_shutdown(nh, ds);
if (nh->nh_ds->ds_soa)
soa_destroy(nh->nh_ds->ds_soa), nh->nh_ds->ds_soa = NULL;
if (nua_client_request_pending(ds->ds_cr))
busy++;
if (nh_notifier_shutdown(nh, NULL, NEATAG_REASON("noresource"), TAG_END()))
busy++;
}
if (!busy)
SET_STATUS(200, "Shutdown successful");
else if (now == nua->nua_shutdown)
SET_STATUS(100, "Shutdown started");
else if (now - nua->nua_shutdown < 30)
SET_STATUS(101, "Shutdown in progress");
else
SET_STATUS(500, "Shutdown timeout");
if (status >= 200) {
for (nh = nua->nua_handles; nh; nh = nh_next) {
nh_next = nh->nh_next;
while (nh->nh_ds && nh->nh_ds->ds_usage) {
nua_dialog_usage_remove(nh, nh->nh_ds, nh->nh_ds->ds_usage, NULL, NULL);
}
}
if (nua->nua_shutdown_timer) {
su_timer_destroy(nua->nua_shutdown_timer);
nua->nua_shutdown_timer = NULL;
}
nta_agent_destroy(nua->nua_nta), nua->nua_nta = NULL;
} else {
if (!nua->nua_shutdown_timer)
nua->nua_shutdown_timer = su_timer_create(su_root_task(nua->nua_root),
NUA_SHUTDOWN_TIMER_INTERVAL);
if (nua->nua_shutdown_timer)
su_timer_set(nua->nua_shutdown_timer, nua_stack_shutdown_timer, NULL);
else
SET_STATUS(500, "Shutdown timer creation failed");
}
nua_stack_event(nua, NULL, NULL, nua_r_shutdown, status, phrase, NULL);
}
static int process_response_to_keepalive_options(outbound_t *ob,
nta_outgoing_t *orq,
sip_t const *sip,
int status,
char const *phrase)
{
int binding_check;
int challenged = 0, credentials = 0;
msg_t *_reqmsg = nta_outgoing_getrequest(orq);
sip_t *request = sip_object(_reqmsg); msg_destroy(_reqmsg);
if (sip == NULL) {
SU_DEBUG_3(("outbound(%p): keepalive %u %s\n", (void *)ob->ob_owner,
status, phrase));
ob->ob_oo->oo_keepalive_error(ob->ob_owner, ob, status, phrase, TAG_END());
return 0;
}
if (status == 401 || status == 407) {
if (sip->sip_www_authenticate)
challenged += auc_challenge(ob->ob_keepalive.auc,
ob->ob_home,
sip->sip_www_authenticate,
sip_authorization_class) > 0;
if (sip->sip_proxy_authenticate)
challenged += auc_challenge(ob->ob_keepalive.auc,
ob->ob_home,
sip->sip_proxy_authenticate,
sip_proxy_authorization_class) > 0;
if (ob->ob_oo->oo_credentials)
credentials = ob->ob_oo->oo_credentials(ob->ob_owner,
ob->ob_keepalive.auc);
}
binding_check = outbound_nat_detect(ob, request, sip);
if (binding_check > 1) {
/* Bindings have changed */
if (outbound_contacts_from_via(ob, sip->sip_via) == 0) {
/* XXX - Destroy old keepalive template message */
/* re-REGISTER */
ob->ob_oo->oo_refresh(ob->ob_owner, ob);
return 0;
}
}
if (binding_check <= 1 && ob->ob_registered && ob->ob_keepalive.validating) {
int failed = 0;
unsigned loglevel = 3;
if (challenged > 0 && credentials > 0) {
keepalive_options_with_registration_probe(ob);
return 0;
}
if (status < 300 && ob->ob_keepalive.validated) {
loglevel = 5;
if (ob->ob_validated)
loglevel = 99; /* only once */
ob->ob_validated = ob->ob_once_validated = 1;
}
else if (status == 401 || status == 407 || status == 403)
loglevel = 5, failed = 1;
else
loglevel = 3, failed = 1;
if (loglevel >= SU_LOG->log_level) {
sip_contact_t const *m = ob->ob_rcontact;
if (m)
su_llog(SU_LOG, loglevel,
"outbound(%p): %s <" URL_PRINT_FORMAT ">\n",
(void *)ob->ob_owner,
failed ? "FAILED to validate" : "validated",
URL_PRINT_ARGS(m->m_url));
else
su_llog(SU_LOG, loglevel,
"outbound(%p): %s registration\n",
(void *)ob->ob_owner,
failed ? "FAILED to validate" : "validated");
if (failed)
su_llog(SU_LOG, loglevel, "outbound(%p): FAILED with %u %s\n",
(void *)ob->ob_owner, status, phrase);
}
if (failed)
ob->ob_oo->oo_probe_error(ob->ob_owner, ob, status, phrase, TAG_END());
}
else if (status == 408) {
SU_DEBUG_3(("outbound(%p): keepalive timeout\n", (void *)ob->ob_owner));
ob->ob_oo->oo_keepalive_error(ob->ob_owner, ob, status, phrase, TAG_END());
return 0;
}
ob->ob_keepalive.validating = 0;
if (ob->ob_keepalive.timer)
su_timer_set(ob->ob_keepalive.timer, keepalive_timer, ob);
return 0;
}
void
print_X(struct tester *x, su_timer_t *t1, struct timing *ti)
{
su_timer_set(t1, print_X, ti);
putchar('X'); fflush(stdout);
}
/*
* test su_timer functionality:
*
* Create a timer, executing print_stamp() in every 20 ms
*/
int main(int argc, char *argv[])
{
su_root_t *root;
su_timer_t *t, *t1, *t_end;
su_timer_t **timers;
su_duration_t interval = 60;
char *argv0 = argv[0];
char *s;
int use_t1 = 0;
su_time_t now, started;
intptr_t i, N = 500;
GSource *source;
struct timing timing[1] = {{ 0 }};
struct tester tester[1] = {{ 0 }};
while (argv[1] && argv[1][0] == '-') {
char *o = argv[1] + 1;
while (*o) {
if (*o == '1')
o++, use_t1 = 1;
else if (*o == 'r')
o++, timing->t_run = 1;
else if (*o == 'N') {
if (o[1])
N = strtoul(o + 1, &o, 0);
else if (argv[2])
N = strtoul(argv++[2], &o, 0);
break;
}
else
break;
}
if (*o)
usage(argv0);
argv++;
}
if (argv[1]) {
interval = strtoul(argv[1], &s, 10);
if (interval == 0 || s == argv[1])
usage(argv0);
}
su_init(); atexit(su_deinit);
tester->root = root = su_glib_root_create(tester);
source = su_root_gsource(tester->root);
g_source_attach(source, NULL /*g_main_context_default ()*/);
su_msg_create(intr_msg,
su_root_task(root),
su_root_task(root),
test_break, 0);
signal(SIGINT, intr_handler);
#if HAVE_SIGPIPE
signal(SIGPIPE, intr_handler);
signal(SIGQUIT, intr_handler);
signal(SIGHUP, intr_handler);
#endif
t = su_timer_create(su_root_task(root), interval);
t1 = su_timer_create(su_root_task(root), 1);
t_end = su_timer_create(su_root_task(root), 20 * interval);
if (t == NULL || t1 == NULL || t_end == NULL)
su_perror("su_timer_create"), exit(1);
tester->t = t, tester->t1 = t1;
timing->t_prev = su_now();
if (timing->t_run)
su_timer_run(t, print_stamp, timing);
else
su_timer_set(t, print_stamp, timing);
if (use_t1)
su_timer_set(t1, print_X, NULL);
su_timer_set(t_end, end_test, NULL);
su_root_run(root);
su_msg_destroy(intr_msg);
su_timer_destroy(t);
su_timer_destroy(t1);
if (timing->t_times != 10) {
fprintf(stderr, "%s: t expired %d times (expecting 10)\n",
argv0, timing->t_times);
return 1;
}
/* Insert timers in order */
timers = calloc(N, sizeof *timers);
if (!timers) { perror("calloc"); exit(1); }
now = started = su_now();
for (i = 0; i < N; i++) {
t = su_timer_create(su_root_task(root), 1000);
if (!t) { perror("su_timer_create"); exit(1); }
if (++now.tv_usec == 0) ++now.tv_sec;
su_timer_set_at(t, increment, (void *)i, now);
timers[i] = t;
}
tester->sentinel = (void*)(i - 1);
su_root_run(root);
printf("Processing %u timers took %f millisec (%f expected)\n",
(unsigned)i, su_time_diff(su_now(), started) * 1000, (double)i / 1000);
for (i = 0; i < N; i++) {
su_timer_destroy(timers[i]);
}
su_root_destroy(root);
su_deinit();
return 0;
}
/** Initialize engine timer. */
static
int he_timer_init(nth_engine_t * he)
{
he->he_timer = su_timer_create(su_root_task(he->he_root), HE_TIMER);
return su_timer_set(he->he_timer, he_timer, he);
}
