/* Start Session Timers */
static void start_timer(pjsip_inv_session *inv)
{
const pj_str_t UPDATE = { "UPDATE", 6 };
pjsip_timer *timer = inv->timer;
pj_time_val delay = {0};
pj_assert(inv->timer->active == PJ_TRUE);
stop_timer(inv);
inv->timer->use_update =
(pjsip_dlg_remote_has_cap(inv->dlg, PJSIP_H_ALLOW, NULL,
&UPDATE) == PJSIP_DIALOG_CAP_SUPPORTED);
if (!inv->timer->use_update) {
/* INVITE always needs SDP */
inv->timer->with_sdp = PJ_TRUE;
}
pj_timer_entry_init(&timer->timer,
1, /* id */
inv, /* user data */
timer_cb); /* callback */
/* Set delay based on role, refresher or refreshee */
if ((timer->refresher == TR_UAC && inv->timer->role == PJSIP_ROLE_UAC) ||
(timer->refresher == TR_UAS && inv->timer->role == PJSIP_ROLE_UAS))
{
/* Add refresher expire timer */
pj_timer_entry_init(&timer->expire_timer,
REFRESHER_EXPIRE_TIMER_ID, /* id */
inv, /* user data */
timer_cb); /* callback */
delay.sec = timer->setting.sess_expires;
/* Schedule the timer */
pjsip_endpt_schedule_timer(inv->dlg->endpt, &timer->expire_timer,
&delay);
/* Next refresh, the delay is half of session expire */
delay.sec = timer->setting.sess_expires / 2;
} else {
/* Send BYE if no refresh received until this timer fired, delay
* is the minimum of 32 seconds and one third of the session interval
* before session expiration.
*/
delay.sec = timer->setting.sess_expires -
timer->setting.sess_expires/3;
delay.sec = PJ_MAX((long)timer->setting.sess_expires-32, delay.sec);
}
/* Schedule the timer */
pjsip_endpt_schedule_timer(inv->dlg->endpt, &timer->timer, &delay);
/* Update last refresh time */
pj_gettimeofday(&timer->last_refresh);
}
/* This will update the UAC's refresh schedule. */
static void update_next_refresh(pjsip_event_sub *sub, int interval)
{
pj_time_val delay = {0, 0};
pj_parsed_time pt;
if (interval < SECONDS_BEFORE_EXPIRY) {
PJ_LOG(4,(THIS_FILE,
"event_sub%p (%s): expiration delay too short (%d sec)! updated.",
sub, state[sub->state].ptr, interval));
interval = SECONDS_BEFORE_EXPIRY;
}
if (sub->timer.id != 0)
pjsip_endpt_cancel_timer(sub->endpt, &sub->timer);
sub->timer.id = TIMER_ID_REFRESH;
sub->timer.user_data = sub;
sub->timer.cb = &refresh_timer_cb;
pj_gettimeofday(&sub->expiry_time);
delay.sec = interval - SECONDS_BEFORE_EXPIRY;
sub->expiry_time.sec += delay.sec;
pj_time_decode(&sub->expiry_time, &pt);
PJ_LOG(4,(THIS_FILE,
"event_sub%p (%s): will send SUBSCRIBE at %02d:%02d:%02d (in %d secs)",
sub, state[sub->state].ptr,
pt.hour, pt.min, pt.sec,
delay.sec));
pjsip_endpt_schedule_timer( sub->endpt, &sub->timer, &delay );
}
static void schedule_registration ( pjsip_regc *regc, pj_int32_t expiration )
{
if (regc->auto_reg && expiration > 0) {
pj_time_val delay = { 0, 0};
pj_timer_heap_cancel_if_active(pjsip_endpt_get_timer_heap(regc->endpt),
®c->timer, 0);
delay.sec = expiration - regc->delay_before_refresh;
if (regc->expires != PJSIP_REGC_EXPIRATION_NOT_SPECIFIED &&
delay.sec > (pj_int32_t)regc->expires)
{
delay.sec = regc->expires;
}
if (delay.sec < DELAY_BEFORE_REFRESH)
delay.sec = DELAY_BEFORE_REFRESH;
regc->timer.cb = ®c_refresh_timer_cb;
regc->timer.id = REFRESH_TIMER;
regc->timer.user_data = regc;
pjsip_endpt_schedule_timer( regc->endpt, ®c->timer, &delay);
pj_gettimeofday(®c->last_reg);
regc->next_reg = regc->last_reg;
regc->next_reg.sec += delay.sec;
}
}
static pj_bool_t rt_on_rx_response(pjsip_rx_data *rdata)
{
if (!pj_strncmp(&rdata->msg_info.cid->id, &rt_call_id, rt_call_id.slen)) {
char *pos = pj_strchr(&rdata->msg_info.cid->id, '/')+1;
int thread_id = (*pos - '0');
pj_timestamp recv_time;
pj_mutex_lock(rt_test_data[thread_id].mutex);
/* Stop timer. */
pjsip_endpt_cancel_timer(endpt, &rt_test_data[thread_id].timeout_timer);
/* Update counter and end-time. */
rt_test_data[thread_id].recv_response_count++;
pj_get_timestamp(&recv_time);
pj_sub_timestamp(&recv_time, &rt_test_data[thread_id].send_time);
pj_add_timestamp(&rt_test_data[thread_id].total_rt_time, &recv_time);
if (!rt_stop) {
pj_time_val tx_delay = { 0, 0 };
pj_assert(rt_test_data[thread_id].tx_timer.user_data == NULL);
rt_test_data[thread_id].tx_timer.user_data = (void*)1;
pjsip_endpt_schedule_timer(endpt, &rt_test_data[thread_id].tx_timer,
&tx_delay);
}
pj_mutex_unlock(rt_test_data[thread_id].mutex);
return PJ_TRUE;
}
return PJ_FALSE;
}
/*
* This callback is called by SSL socket when pending accept() operation
* has completed.
*/
static pj_bool_t on_accept_complete(pj_ssl_sock_t *ssock,
pj_ssl_sock_t *new_ssock,
const pj_sockaddr_t *src_addr,
int src_addr_len)
{
struct tls_listener *listener;
struct tls_transport *tls;
char addr[PJ_INET6_ADDRSTRLEN+10];
pj_status_t status;
PJ_UNUSED_ARG(src_addr_len);
listener = (struct tls_listener*) pj_ssl_sock_get_user_data(ssock);
PJ_ASSERT_RETURN(new_ssock, PJ_TRUE);
PJ_LOG(4,(listener->factory.obj_name,
"TLS listener %.*s:%d: got incoming TLS connection "
"from %s, sock=%d",
(int)listener->factory.addr_name.host.slen,
listener->factory.addr_name.host.ptr,
listener->factory.addr_name.port,
pj_sockaddr_print(src_addr, addr, sizeof(addr), 3),
new_ssock));
/*
* Incoming connection!
* Create TLS transport for the new socket.
*/
status = tls_create( listener, NULL, new_ssock, PJ_TRUE,
(const pj_sockaddr_in*)&listener->factory.local_addr,
(const pj_sockaddr_in*)src_addr, &tls);
if (status == PJ_SUCCESS) {
/* Set the "pending" SSL socket user data */
pj_ssl_sock_set_user_data(new_ssock, tls);
status = tls_start_read(tls);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(tls->base.obj_name, "New transport cancelled"));
tls_destroy(&tls->base, status);
} else {
/* Start keep-alive timer */
if (PJSIP_TCP_KEEP_ALIVE_INTERVAL) {
pj_time_val delay = {PJSIP_TCP_KEEP_ALIVE_INTERVAL, 0};
pjsip_endpt_schedule_timer(listener->endpt,
&tls->ka_timer,
&delay);
tls->ka_timer.id = PJ_TRUE;
pj_gettimeofday(&tls->last_activity);
}
}
}
return PJ_TRUE;
}
static pj_status_t rt_send_request(int thread_id)
{
pj_status_t status;
pj_str_t target, from, to, contact, call_id;
pjsip_tx_data *tdata;
pj_time_val timeout_delay;
pj_mutex_lock(rt_test_data[thread_id].mutex);
/* Create a request message. */
target = pj_str(rt_target_uri);
from = pj_str(FROM_HDR);
to = pj_str(rt_target_uri);
contact = pj_str(CONTACT_HDR);
call_id = rt_test_data[thread_id].call_id;
status = pjsip_endpt_create_request( endpt, &pjsip_options_method,
&target, &from, &to,
&contact, &call_id, -1,
NULL, &tdata );
if (status != PJ_SUCCESS) {
app_perror(" error: unable to create request", status);
pj_mutex_unlock(rt_test_data[thread_id].mutex);
return -610;
}
/* Start time. */
pj_get_timestamp(&rt_test_data[thread_id].send_time);
/* Send the message (statelessly). */
status = pjsip_endpt_send_request_stateless( endpt, tdata, NULL, NULL);
if (status != PJ_SUCCESS) {
/* Immediate error! */
app_perror(" error: send request", status);
pjsip_tx_data_dec_ref(tdata);
pj_mutex_unlock(rt_test_data[thread_id].mutex);
return -620;
}
/* Update counter. */
rt_test_data[thread_id].sent_request_count++;
/* Set timeout timer. */
if (rt_test_data[thread_id].timeout_timer.user_data != NULL) {
pjsip_endpt_cancel_timer(endpt, &rt_test_data[thread_id].timeout_timer);
}
timeout_delay.sec = 100; timeout_delay.msec = 0;
rt_test_data[thread_id].timeout_timer.user_data = (void*)1;
pjsip_endpt_schedule_timer(endpt, &rt_test_data[thread_id].timeout_timer,
&timeout_delay);
pj_mutex_unlock(rt_test_data[thread_id].mutex);
return PJ_SUCCESS;
}
/* Timer callback to re-create client subscription */
static void pres_timer_cb(pj_timer_heap_t *th,
pj_timer_entry *entry)
{
pj_time_val delay = { PJSUA_PRES_TIMER, 0 };
entry->id = PJ_FALSE;
refresh_client_subscriptions();
pjsip_endpt_schedule_timer(pjsua_var.endpt, entry, &delay);
entry->id = PJ_TRUE;
PJ_UNUSED_ARG(th);
}
/// Restart the timer using the specified id and timeout.
void Flow::restart_timer(int id, int timeout)
{
if (_timer.id)
{
// Stop the existing timer.
pjsip_endpt_cancel_timer(stack_data.endpt, &_timer);
_timer.id = 0;
}
pj_time_val delay = {timeout, 0};
pjsip_endpt_schedule_timer(stack_data.endpt, &_timer, &delay);
_timer.id = id;
}
/*
* Start presence subsystem.
*/
pj_status_t pjsua_pres_start(void)
{
/* Start presence timer to re-subscribe to buddy's presence when
* subscription has failed.
*/
if (pjsua_var.pres_timer.id == PJ_FALSE) {
pj_time_val pres_interval = {PJSUA_PRES_TIMER, 0};
pjsua_var.pres_timer.cb = &pres_timer_cb;
pjsip_endpt_schedule_timer(pjsua_var.endpt, &pjsua_var.pres_timer,
&pres_interval);
pjsua_var.pres_timer.id = PJ_TRUE;
}
return PJ_SUCCESS;
}
/* Schedule timer to terminate transaction. */
static void schedule_terminate_tsx( pjsip_transaction *tsx,
int status_code,
int msec_delay )
{
pj_time_val delay;
delay.sec = 0;
delay.msec = msec_delay;
pj_time_val_normalize(&delay);
pj_assert(pj_strcmp(&tsx->transaction_key, &tsx_key)==0);
timer.user_data = NULL;
timer.id = status_code;
timer.cb = &terminate_tsx_timer;
pjsip_endpt_schedule_timer(endpt, &timer, &delay);
}
static void rt_timeout_timer( pj_timer_heap_t *timer_heap,
struct pj_timer_entry *entry )
{
pj_mutex_lock(rt_test_data[entry->id].mutex);
PJ_UNUSED_ARG(timer_heap);
PJ_LOG(3,(THIS_FILE, " timeout waiting for response"));
rt_test_data[entry->id].timeout_timer.user_data = NULL;
if (rt_test_data[entry->id].tx_timer.user_data == NULL) {
pj_time_val delay = { 0, 0 };
rt_test_data[entry->id].tx_timer.user_data = (void*)1;
pjsip_endpt_schedule_timer(endpt, &rt_test_data[entry->id].tx_timer,
&delay);
}
pj_mutex_unlock(rt_test_data[entry->id].mutex);
}
/* Timer callback to re-create client subscription */
static void pres_timer_cb(pj_timer_heap_t *th,
pj_timer_entry *entry)
{
unsigned i;
pj_time_val delay = { PJSUA_PRES_TIMER, 0 };
/* Retry failed PUBLISH requests */
for (i=0; i<PJ_ARRAY_SIZE(pjsua_var.acc); ++i) {
pjsua_acc *acc = &pjsua_var.acc[i];
if (acc->cfg.publish_enabled && acc->publish_sess==NULL)
pjsua_pres_init_publish_acc(acc->index);
}
entry->id = PJ_FALSE;
refresh_client_subscriptions();
pjsip_endpt_schedule_timer(pjsua_var.endpt, entry, &delay);
entry->id = PJ_TRUE;
PJ_UNUSED_ARG(th);
}
/* Schedule timer to send response for the specified UAS transaction */
static void schedule_send_response( pjsip_rx_data *rdata,
const pj_str_t *tsx_key,
int status_code,
int msec_delay )
{
pj_status_t status;
pjsip_tx_data *tdata;
pj_timer_entry *t;
struct response *r;
pj_time_val delay;
status = pjsip_endpt_create_response( endpt, rdata, status_code, NULL,
&tdata);
if (status != PJ_SUCCESS) {
app_perror(" error: unable to create response", status);
test_complete = -198;
return;
}
r = PJ_POOL_ALLOC_T(tdata->pool, struct response);
pj_strdup(tdata->pool, &r->tsx_key, tsx_key);
r->tdata = tdata;
delay.sec = 0;
delay.msec = msec_delay;
pj_time_val_normalize(&delay);
t = PJ_POOL_ZALLOC_T(tdata->pool, pj_timer_entry);
t->user_data = r;
t->cb = &send_response_timer;
status = pjsip_endpt_schedule_timer(endpt, t, &delay);
if (status != PJ_SUCCESS) {
pjsip_tx_data_dec_ref(tdata);
app_perror(" error: unable to schedule timer", status);
test_complete = -199;
return;
}
}
/* Schedule notifier expiration. */
static void sub_schedule_uas_expire( pjsip_event_sub *sub, int sec_delay)
{
pj_time_val delay = { 0, 0 };
pj_parsed_time pt;
if (sub->timer.id != 0)
pjsip_endpt_cancel_timer(sub->endpt, &sub->timer);
pj_gettimeofday(&sub->expiry_time);
sub->expiry_time.sec += sec_delay;
sub->timer.id = TIMER_ID_UAS_EXPIRY;
sub->timer.user_data = sub;
sub->timer.cb = &uas_expire_timer_cb;
delay.sec = sec_delay;
pjsip_endpt_schedule_timer( sub->endpt, &sub->timer, &delay);
pj_time_decode(&sub->expiry_time, &pt);
PJ_LOG(4,(THIS_FILE,
"event_sub%p (%s)(UAS): will expire at %02d:%02d:%02d (in %d secs)",
sub, state[sub->state].ptr, pt.hour, pt.min, pt.sec, sec_delay));
}
/* Start Session Timers */
static void start_timer(pjsip_inv_session *inv)
{
pjsip_timer *timer = inv->timer;
pj_time_val delay = {0};
pj_assert(inv->timer->active == PJ_TRUE);
stop_timer(inv);
pj_timer_entry_init(&timer->timer,
1, /* id */
inv, /* user data */
timer_cb); /* callback */
/* Set delay based on role, refresher or refreshee */
if ((timer->refresher == TR_UAC && inv->timer->role == PJSIP_ROLE_UAC) ||
(timer->refresher == TR_UAS && inv->timer->role == PJSIP_ROLE_UAS))
{
/* Next refresh, the delay is half of session expire */
delay.sec = timer->setting.sess_expires / 2;
} else {
/* Send BYE if no refresh received until this timer fired, delay
* is the minimum of 32 seconds and one third of the session interval
* before session expiration.
*/
delay.sec = timer->setting.sess_expires -
timer->setting.sess_expires/3;
delay.sec = PJ_MAX((long)timer->setting.sess_expires-32, delay.sec);
}
/* Schedule the timer */
pjsip_endpt_schedule_timer(inv->dlg->endpt, &timer->timer, &delay);
/* Update last refresh time */
pj_gettimeofday(&timer->last_refresh);
}
static void tsx_callback(void *token, pjsip_event *event)
{
pj_status_t status;
pjsip_publishc *pubc = (pjsip_publishc*) token;
pjsip_transaction *tsx = event->body.tsx_state.tsx;
/* Decrement pending transaction counter. */
pj_assert(pubc->pending_tsx > 0);
--pubc->pending_tsx;
/* If publication data has been deleted by user then remove publication
* data from transaction's callback, and don't call callback.
*/
if (pubc->_delete_flag) {
/* Nothing to do */
;
} else if (tsx->status_code == PJSIP_SC_PROXY_AUTHENTICATION_REQUIRED ||
tsx->status_code == PJSIP_SC_UNAUTHORIZED)
{
pjsip_rx_data *rdata = event->body.tsx_state.src.rdata;
pjsip_tx_data *tdata;
status = pjsip_auth_clt_reinit_req( &pubc->auth_sess,
rdata,
tsx->last_tx,
&tdata);
if (status != PJ_SUCCESS) {
call_callback(pubc, status, tsx->status_code,
&rdata->msg_info.msg->line.status.reason,
rdata, -1);
} else {
status = pjsip_publishc_send(pubc, tdata);
}
} else {
pjsip_rx_data *rdata;
pj_int32_t expiration = 0xFFFF;
if (tsx->status_code/100 == 2) {
pjsip_msg *msg;
pjsip_expires_hdr *expires;
pjsip_generic_string_hdr *etag_hdr;
const pj_str_t STR_ETAG = { "SIP-ETag", 8 };
rdata = event->body.tsx_state.src.rdata;
msg = rdata->msg_info.msg;
/* Save ETag value */
etag_hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(msg, &STR_ETAG, NULL);
if (etag_hdr) {
pj_strdup(pubc->pool, &pubc->etag, &etag_hdr->hvalue);
} else {
pubc->etag.slen = 0;
}
/* Update expires value */
expires = (pjsip_expires_hdr*)
pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL);
if (expires)
expiration = expires->ivalue;
if (pubc->auto_refresh && expiration!=0 && expiration!=0xFFFF) {
pj_time_val delay = { 0, 0};
delay.sec = expiration - DELAY_BEFORE_REFRESH;
if (pubc->expires != PJSIP_PUBC_EXPIRATION_NOT_SPECIFIED &&
delay.sec > (pj_int32_t)pubc->expires)
{
delay.sec = pubc->expires;
}
if (delay.sec < DELAY_BEFORE_REFRESH)
delay.sec = DELAY_BEFORE_REFRESH;
pubc->timer.cb = &pubc_refresh_timer_cb;
pubc->timer.id = REFRESH_TIMER;
pubc->timer.user_data = pubc;
pjsip_endpt_schedule_timer( pubc->endpt, &pubc->timer, &delay);
pj_gettimeofday(&pubc->last_refresh);
pubc->next_refresh = pubc->last_refresh;
pubc->next_refresh.sec += delay.sec;
}
} else {
rdata = (event->body.tsx_state.type==PJSIP_EVENT_RX_MSG) ?
event->body.tsx_state.src.rdata : NULL;
}
/* Call callback. */
if (expiration == 0xFFFF) expiration = -1;
/* Temporarily increment pending_tsx to prevent callback from
* destroying pubc.
*/
++pubc->pending_tsx;
call_callback(pubc, PJ_SUCCESS, tsx->status_code,
(rdata ? &rdata->msg_info.msg->line.status.reason
: pjsip_get_status_text(tsx->status_code)),
rdata, expiration);
--pubc->pending_tsx;
}
/* Delete the record if user destroy pubc during the callback. */
if (pubc->_delete_flag && pubc->pending_tsx==0) {
pjsip_publishc_destroy(pubc);
}
}
static void tsx_callback(void *token, pjsip_event *event)
{
pj_status_t status;
pjsip_regc *regc = (pjsip_regc*) token;
pjsip_transaction *tsx = event->body.tsx_state.tsx;
pj_atomic_inc(regc->busy_ctr);
pj_lock_acquire(regc->lock);
/* Decrement pending transaction counter. */
pj_assert(regc->has_tsx);
regc->has_tsx = PJ_FALSE;
/* Add reference to the transport */
if (tsx->transport != regc->last_transport) {
if (regc->last_transport) {
pjsip_transport_dec_ref(regc->last_transport);
regc->last_transport = NULL;
}
if (tsx->transport) {
regc->last_transport = tsx->transport;
pjsip_transport_add_ref(regc->last_transport);
}
}
/* Handle 401/407 challenge (even when _delete_flag is set) */
if (tsx->status_code == PJSIP_SC_PROXY_AUTHENTICATION_REQUIRED ||
tsx->status_code == PJSIP_SC_UNAUTHORIZED)
{
pjsip_rx_data *rdata = event->body.tsx_state.src.rdata;
pjsip_tx_data *tdata;
/* reset current op */
regc->current_op = REGC_IDLE;
status = pjsip_auth_clt_reinit_req( ®c->auth_sess,
rdata,
tsx->last_tx,
&tdata);
if (status == PJ_SUCCESS) {
status = pjsip_regc_send(regc, tdata);
}
if (status != PJ_SUCCESS) {
/* Only call callback if application is still interested
* in it.
*/
if (regc->_delete_flag == 0) {
/* Should be safe to release the lock temporarily.
* We do this to avoid deadlock.
*/
pj_lock_release(regc->lock);
call_callback(regc, status, tsx->status_code,
&rdata->msg_info.msg->line.status.reason,
rdata, -1, 0, NULL);
pj_lock_acquire(regc->lock);
}
}
} else if (regc->_delete_flag) {
/* User has called pjsip_regc_destroy(), so don't call callback.
* This regc will be destroyed later in this function.
*/
/* Just reset current op */
regc->current_op = REGC_IDLE;
} else {
pjsip_rx_data *rdata;
pj_int32_t expiration = NOEXP;
unsigned contact_cnt = 0;
pjsip_contact_hdr *contact[PJSIP_REGC_MAX_CONTACT];
if (tsx->status_code/100 == 2) {
rdata = event->body.tsx_state.src.rdata;
/* Calculate expiration */
expiration = calculate_response_expiration(regc, rdata,
&contact_cnt,
PJSIP_REGC_MAX_CONTACT,
contact);
/* Mark operation as complete */
regc->current_op = REGC_IDLE;
/* Schedule next registration */
if (regc->auto_reg && expiration > 0) {
pj_time_val delay = { 0, 0};
delay.sec = expiration - DELAY_BEFORE_REFRESH;
if (regc->expires != PJSIP_REGC_EXPIRATION_NOT_SPECIFIED &&
delay.sec > (pj_int32_t)regc->expires)
{
delay.sec = regc->expires;
}
if (delay.sec < DELAY_BEFORE_REFRESH)
delay.sec = DELAY_BEFORE_REFRESH;
regc->timer.cb = ®c_refresh_timer_cb;
regc->timer.id = REFRESH_TIMER;
regc->timer.user_data = regc;
pjsip_endpt_schedule_timer( regc->endpt, ®c->timer, &delay);
pj_gettimeofday(®c->last_reg);
regc->next_reg = regc->last_reg;
regc->next_reg.sec += delay.sec;
}
} else {
rdata = (event->body.tsx_state.type==PJSIP_EVENT_RX_MSG) ?
event->body.tsx_state.src.rdata : NULL;
}
/* Update registration */
if (expiration==NOEXP) expiration=-1;
regc->expires = expiration;
/* Call callback. */
/* Should be safe to release the lock temporarily.
* We do this to avoid deadlock.
*/
pj_lock_release(regc->lock);
call_callback(regc, PJ_SUCCESS, tsx->status_code,
(rdata ? &rdata->msg_info.msg->line.status.reason
: pjsip_get_status_text(tsx->status_code)),
rdata, expiration,
contact_cnt, contact);
pj_lock_acquire(regc->lock);
}
pj_lock_release(regc->lock);
/* Delete the record if user destroy regc during the callback. */
if (pj_atomic_dec_and_get(regc->busy_ctr)==0 && regc->_delete_flag) {
pjsip_regc_destroy(regc);
}
}
/*
* This callback is called by SSL socket when pending accept() operation
* has completed.
*/
static pj_bool_t on_accept_complete(pj_ssl_sock_t *ssock,
pj_ssl_sock_t *new_ssock,
const pj_sockaddr_t *src_addr,
int src_addr_len)
{
struct tls_listener *listener;
struct tls_transport *tls;
pj_ssl_sock_info ssl_info;
char addr[PJ_INET6_ADDRSTRLEN+10];
pjsip_tp_state_callback state_cb;
pj_bool_t is_shutdown;
pj_status_t status;
PJ_UNUSED_ARG(src_addr_len);
listener = (struct tls_listener*) pj_ssl_sock_get_user_data(ssock);
PJ_ASSERT_RETURN(new_ssock, PJ_TRUE);
PJ_LOG(4,(listener->factory.obj_name,
"TLS listener %.*s:%d: got incoming TLS connection "
"from %s, sock=%d",
(int)listener->factory.addr_name.host.slen,
listener->factory.addr_name.host.ptr,
listener->factory.addr_name.port,
pj_sockaddr_print(src_addr, addr, sizeof(addr), 3),
new_ssock));
/* Retrieve SSL socket info, close the socket if this is failed
* as the SSL socket info availability is rather critical here.
*/
status = pj_ssl_sock_get_info(new_ssock, &ssl_info);
if (status != PJ_SUCCESS) {
pj_ssl_sock_close(new_ssock);
return PJ_TRUE;
}
/*
* Incoming connection!
* Create TLS transport for the new socket.
*/
status = tls_create( listener, NULL, new_ssock, PJ_TRUE,
(const pj_sockaddr_in*)&listener->factory.local_addr,
(const pj_sockaddr_in*)src_addr, NULL, &tls);
if (status != PJ_SUCCESS)
return PJ_TRUE;
/* Set the "pending" SSL socket user data */
pj_ssl_sock_set_user_data(new_ssock, tls);
/* Prevent immediate transport destroy as application may access it
* (getting info, etc) in transport state notification callback.
*/
pjsip_transport_add_ref(&tls->base);
/* If there is verification error and verification is mandatory, shutdown
* and destroy the transport.
*/
if (ssl_info.verify_status && listener->tls_setting.verify_client) {
if (tls->close_reason == PJ_SUCCESS)
tls->close_reason = PJSIP_TLS_ECERTVERIF;
pjsip_transport_shutdown(&tls->base);
}
/* Notify transport state to application */
state_cb = pjsip_tpmgr_get_state_cb(tls->base.tpmgr);
if (state_cb) {
pjsip_transport_state_info state_info;
pjsip_tls_state_info tls_info;
pjsip_transport_state tp_state;
/* Init transport state info */
pj_bzero(&tls_info, sizeof(tls_info));
pj_bzero(&state_info, sizeof(state_info));
tls_info.ssl_sock_info = &ssl_info;
state_info.ext_info = &tls_info;
/* Set transport state based on verification status */
if (ssl_info.verify_status && listener->tls_setting.verify_client)
{
tp_state = PJSIP_TP_STATE_DISCONNECTED;
state_info.status = PJSIP_TLS_ECERTVERIF;
} else {
tp_state = PJSIP_TP_STATE_CONNECTED;
state_info.status = PJ_SUCCESS;
}
(*state_cb)(&tls->base, tp_state, &state_info);
}
/* Release transport reference. If transport is shutting down, it may
* get destroyed here.
*/
is_shutdown = tls->base.is_shutdown;
pjsip_transport_dec_ref(&tls->base);
if (is_shutdown)
return PJ_TRUE;
status = tls_start_read(tls);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(tls->base.obj_name, "New transport cancelled"));
tls_init_shutdown(tls, status);
tls_destroy(&tls->base, status);
} else {
/* Start keep-alive timer */
if (PJSIP_TLS_KEEP_ALIVE_INTERVAL) {
pj_time_val delay = {PJSIP_TLS_KEEP_ALIVE_INTERVAL, 0};
pjsip_endpt_schedule_timer(listener->endpt,
&tls->ka_timer,
&delay);
tls->ka_timer.id = PJ_TRUE;
pj_gettimeofday(&tls->last_activity);
}
}
return PJ_TRUE;
}
/*
* This callback is called by active socket when pending accept() operation
* has completed.
*/
static pj_bool_t on_accept_complete(pj_activesock_t *asock,
pj_sock_t sock,
const pj_sockaddr_t *src_addr,
int src_addr_len)
{
struct tcp_listener *listener;
struct tcp_transport *tcp;
char addr[PJ_INET6_ADDRSTRLEN+10];
pjsip_tp_state_callback state_cb;
pj_sockaddr tmp_src_addr;
pj_status_t status;
PJ_UNUSED_ARG(src_addr_len);
listener = (struct tcp_listener*) pj_activesock_get_user_data(asock);
PJ_ASSERT_RETURN(sock != PJ_INVALID_SOCKET, PJ_TRUE);
PJ_LOG(4,(listener->factory.obj_name,
"TCP listener %.*s:%d: got incoming TCP connection "
"from %s, sock=%d",
(int)listener->factory.addr_name.host.slen,
listener->factory.addr_name.host.ptr,
listener->factory.addr_name.port,
pj_sockaddr_print(src_addr, addr, sizeof(addr), 3),
sock));
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, listener->qos_type,
&listener->qos_params,
2, listener->factory.obj_name,
"incoming SIP TCP socket");
/* tcp_create() expect pj_sockaddr, so copy src_addr to temporary var,
* just in case.
*/
pj_bzero(&tmp_src_addr, sizeof(tmp_src_addr));
pj_sockaddr_cp(&tmp_src_addr, src_addr);
/*
* Incoming connection!
* Create TCP transport for the new socket.
*/
status = tcp_create( listener, NULL, sock, PJ_TRUE,
&listener->factory.local_addr,
&tmp_src_addr, &tcp);
if (status == PJ_SUCCESS) {
status = tcp_start_read(tcp);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(tcp->base.obj_name, "New transport cancelled"));
tcp_destroy(&tcp->base, status);
} else {
/* Start keep-alive timer */
if (PJSIP_TCP_KEEP_ALIVE_INTERVAL) {
pj_time_val delay = {PJSIP_TCP_KEEP_ALIVE_INTERVAL, 0};
pjsip_endpt_schedule_timer(listener->endpt,
&tcp->ka_timer,
&delay);
tcp->ka_timer.id = PJ_TRUE;
pj_gettimeofday(&tcp->last_activity);
}
/* Notify application of transport state accepted */
state_cb = pjsip_tpmgr_get_state_cb(tcp->base.tpmgr);
if (state_cb) {
pjsip_transport_state_info state_info;
pj_bzero(&state_info, sizeof(state_info));
(*state_cb)(&tcp->base, PJSIP_TP_STATE_CONNECTED, &state_info);
}
}
}
return PJ_TRUE;
}
/*! \brief Helper function for changing the T.38 state */
static void t38_change_state(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
struct t38_state *state, enum ast_sip_session_t38state new_state)
{
enum ast_sip_session_t38state old_state = session->t38state;
struct ast_control_t38_parameters parameters = { .request_response = 0, };
pj_time_val delay = { .sec = T38_AUTOMATIC_REJECTION_SECONDS };
if (old_state == new_state) {
return;
}
session->t38state = new_state;
ast_debug(2, "T.38 state changed to '%u' from '%u' on channel '%s'\n",
new_state, old_state,
session->channel ? ast_channel_name(session->channel) : "<gone>");
if (pj_timer_heap_cancel(pjsip_endpt_get_timer_heap(ast_sip_get_pjsip_endpoint()), &state->timer)) {
ast_debug(2, "Automatic T.38 rejection on channel '%s' terminated\n",
session->channel ? ast_channel_name(session->channel) : "<gone>");
ao2_ref(session, -1);
}
if (!session->channel) {
return;
}
switch (new_state) {
case T38_PEER_REINVITE:
ao2_ref(session, +1);
if (pjsip_endpt_schedule_timer(ast_sip_get_pjsip_endpoint(), &state->timer, &delay) != PJ_SUCCESS) {
ast_log(LOG_WARNING, "Scheduling of automatic T.38 rejection for channel '%s' failed\n",
ast_channel_name(session->channel));
ao2_ref(session, -1);
}
parameters = state->their_parms;
parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
ast_udptl_set_tag(session_media->udptl, "%s", ast_channel_name(session->channel));
break;
case T38_ENABLED:
parameters = state->their_parms;
parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
parameters.request_response = AST_T38_NEGOTIATED;
ast_udptl_set_tag(session_media->udptl, "%s", ast_channel_name(session->channel));
break;
case T38_REJECTED:
case T38_DISABLED:
if (old_state == T38_ENABLED) {
parameters.request_response = AST_T38_TERMINATED;
} else if (old_state == T38_LOCAL_REINVITE) {
parameters.request_response = AST_T38_REFUSED;
}
break;
case T38_LOCAL_REINVITE:
/* wait until we get a peer response before responding to local reinvite */
break;
case T38_MAX_ENUM:
/* Well, that shouldn't happen */
ast_assert(0);
break;
}
if (parameters.request_response) {
ast_queue_control_data(session->channel, AST_CONTROL_T38_PARAMETERS, ¶meters, sizeof(parameters));
}
}
/*! \brief Task function which rejects a T.38 re-invite and resumes handling it */
static int t38_automatic_reject(void *obj)
{
RAII_VAR(struct ast_sip_session *, session, obj, ao2_cleanup);
RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, "t38"), ao2_cleanup);
RAII_VAR(struct ast_sip_session_media *, session_media, ao2_find(session->media, "image", OBJ_KEY), ao2_cleanup);
if (!datastore) {
return 0;
}
ast_debug(2, "Automatically rejecting T.38 request on channel '%s'\n",
session->channel ? ast_channel_name(session->channel) : "<gone>");
t38_change_state(session, session_media, datastore->data, T38_REJECTED);
ast_sip_session_resume_reinvite(session);
return 0;
}
static pj_bool_t mod_call_on_rx_request(pjsip_rx_data *rdata)
{
const pj_str_t call_user = { "2", 1 };
pjsip_uri *uri;
pjsip_sip_uri *sip_uri;
struct call *call;
pjsip_dialog *dlg;
pjmedia_sdp_session *sdp;
pjsip_tx_data *tdata;
pj_bool_t has_initial = PJ_FALSE;
pj_status_t status;
uri = pjsip_uri_get_uri(rdata->msg_info.msg->line.req.uri);
/* Only want to receive SIP/SIPS scheme */
if (!PJSIP_URI_SCHEME_IS_SIP(uri) && !PJSIP_URI_SCHEME_IS_SIPS(uri))
return PJ_FALSE;
sip_uri = (pjsip_sip_uri*) uri;
/* Only want to handle INVITE requests. */
if (rdata->msg_info.msg->line.req.method.id != PJSIP_INVITE_METHOD) {
return PJ_FALSE;
}
/* Check for matching user part. Incoming requests will be handled
* call-statefully if:
* - user part is "2", or
* - user part is not "0" nor "1" and method is INVITE.
*/
if (pj_strcmp(&sip_uri->user, &call_user) == 0 ||
sip_uri->user.slen != 1 ||
(*sip_uri->user.ptr != '0' && *sip_uri->user.ptr != '1'))
{
/* Match */
} else {
return PJ_FALSE;
}
/* Verify that we can handle the request. */
if (app.real_sdp) {
unsigned options = 0;
status = pjsip_inv_verify_request(rdata, &options, NULL, NULL,
app.sip_endpt, &tdata);
if (status != PJ_SUCCESS) {
/*
* No we can't handle the incoming INVITE request.
*/
if (tdata) {
pjsip_response_addr res_addr;
pjsip_get_response_addr(tdata->pool, rdata, &res_addr);
pjsip_endpt_send_response(app.sip_endpt, &res_addr, tdata,
NULL, NULL);
} else {
/* Respond with 500 (Internal Server Error) */
pjsip_endpt_respond_stateless(app.sip_endpt, rdata, 500, NULL,
NULL, NULL);
}
return PJ_TRUE;
}
}
/* Create UAS dialog */
status = pjsip_dlg_create_uas( pjsip_ua_instance(), rdata,
&app.local_contact, &dlg);
if (status != PJ_SUCCESS) {
const pj_str_t reason = pj_str("Unable to create dialog");
pjsip_endpt_respond_stateless( app.sip_endpt, rdata,
500, &reason,
NULL, NULL);
return PJ_TRUE;
}
/* Alloc call structure. */
call = pj_pool_zalloc(dlg->pool, sizeof(struct call));
/* Create SDP from PJMEDIA */
if (app.real_sdp) {
status = pjmedia_endpt_create_sdp(app.med_endpt, rdata->tp_info.pool,
app.skinfo_cnt, app.skinfo,
&sdp);
} else {
sdp = app.dummy_sdp;
}
/* Create UAS invite session */
status = pjsip_inv_create_uas( dlg, rdata, sdp, 0, &call->inv);
if (status != PJ_SUCCESS) {
pjsip_dlg_create_response(dlg, rdata, 500, NULL, &tdata);
pjsip_dlg_send_response(dlg, pjsip_rdata_get_tsx(rdata), tdata);
return PJ_TRUE;
}
/* Send 100/Trying if needed */
if (app.server.send_trying) {
status = send_response(call->inv, rdata, 100, &has_initial);
if (status != PJ_SUCCESS)
return PJ_TRUE;
}
/* Send 180/Ringing if needed */
if (app.server.send_ringing) {
status = send_response(call->inv, rdata, 180, &has_initial);
if (status != PJ_SUCCESS)
return PJ_TRUE;
}
/* Simulate call processing delay */
if (app.server.delay) {
pj_time_val delay;
call->ans_timer.id = 1;
call->ans_timer.user_data = call;
call->ans_timer.cb = &answer_timer_cb;
delay.sec = 0;
delay.msec = app.server.delay;
pj_time_val_normalize(&delay);
pjsip_endpt_schedule_timer(app.sip_endpt, &call->ans_timer, &delay);
} else {
/* Send the 200 response immediately . */
status = send_response(call->inv, rdata, 200, &has_initial);
PJ_ASSERT_ON_FAIL(status == PJ_SUCCESS, return PJ_TRUE);
}
/* Done */
app.server.cur_state.call_cnt++;
return PJ_TRUE;
}
/*
* This is the handler to receive message for this test. It is used to
* control and verify the behavior of the message transmitted by the
* transaction.
*/
static pj_bool_t msg_receiver_on_rx_request(pjsip_rx_data *rdata)
{
if (pj_strcmp2(&rdata->msg_info.via->branch_param, TEST1_BRANCH_ID) == 0) {
/*
* The TEST1_BRANCH_ID test performs the verifications for transaction
* retransmission mechanism. It will not answer the incoming request
* with any response.
*/
pjsip_msg *msg = rdata->msg_info.msg;
PJ_LOG(4,(THIS_FILE, " received request"));
/* Only wants to take INVITE or OPTIONS method. */
if (msg->line.req.method.id != PJSIP_INVITE_METHOD &&
msg->line.req.method.id != PJSIP_OPTIONS_METHOD)
{
PJ_LOG(3,(THIS_FILE, " error: received unexpected method %.*s",
msg->line.req.method.name.slen,
msg->line.req.method.name.ptr));
test_complete = -600;
return PJ_TRUE;
}
if (recv_count == 0) {
recv_count++;
//pj_gettimeofday(&recv_last);
recv_last = rdata->pkt_info.timestamp;
} else {
pj_time_val now;
unsigned msec_expected, msec_elapsed;
int max_received;
//pj_gettimeofday(&now);
now = rdata->pkt_info.timestamp;
PJ_TIME_VAL_SUB(now, recv_last);
msec_elapsed = now.sec*1000 + now.msec;
++recv_count;
msec_expected = (1<<(recv_count-2))*PJSIP_T1_TIMEOUT;
if (msg->line.req.method.id != PJSIP_INVITE_METHOD) {
if (msec_expected > PJSIP_T2_TIMEOUT)
msec_expected = PJSIP_T2_TIMEOUT;
max_received = 11;
} else {
max_received = 7;
}
if (DIFF(msec_expected, msec_elapsed) > TEST1_ALLOWED_DIFF) {
PJ_LOG(3,(THIS_FILE,
" error: expecting retransmission no. %d in %d "
"ms, received in %d ms",
recv_count-1, msec_expected, msec_elapsed));
test_complete = -610;
}
if (recv_count > max_received) {
PJ_LOG(3,(THIS_FILE,
" error: too many messages (%d) received",
recv_count));
test_complete = -620;
}
//pj_gettimeofday(&recv_last);
recv_last = rdata->pkt_info.timestamp;
}
return PJ_TRUE;
} else
if (pj_strcmp2(&rdata->msg_info.via->branch_param, TEST4_BRANCH_ID) == 0) {
/*
* The TEST4_BRANCH_ID test simulates transport failure after several
* retransmissions.
*/
recv_count++;
if (recv_count == TEST4_RETRANSMIT_CNT) {
/* Simulate transport failure. */
pjsip_loop_set_failure(loop, 2, NULL);
} else if (recv_count > TEST4_RETRANSMIT_CNT) {
PJ_LOG(3,(THIS_FILE," error: not expecting %d-th packet!",
recv_count));
test_complete = -631;
}
return PJ_TRUE;
} else
if (pj_strcmp2(&rdata->msg_info.via->branch_param, TEST5_BRANCH_ID) == 0) {
/*
* The TEST5_BRANCH_ID test simulates user terminating the transaction
* after several retransmissions.
*/
recv_count++;
if (recv_count == TEST5_RETRANSMIT_CNT+1) {
pj_str_t key;
pjsip_transaction *tsx;
pjsip_tsx_create_key( rdata->tp_info.pool, &key, PJSIP_ROLE_UAC,
&rdata->msg_info.msg->line.req.method, rdata);
tsx = pjsip_tsx_layer_find_tsx(&key, PJ_TRUE);
if (tsx) {
pjsip_tsx_terminate(tsx, PJSIP_SC_REQUEST_TERMINATED);
pj_mutex_unlock(tsx->mutex);
} else {
PJ_LOG(3,(THIS_FILE, " error: uac transaction not found!"));
test_complete = -633;
}
} else if (recv_count > TEST5_RETRANSMIT_CNT+1) {
PJ_LOG(3,(THIS_FILE," error: not expecting %d-th packet!",
recv_count));
test_complete = -634;
}
return PJ_TRUE;
} else
if (pj_strcmp2(&rdata->msg_info.via->branch_param, TEST6_BRANCH_ID) == 0) {
/*
* The TEST6_BRANCH_ID test successfull non-INVITE transaction.
*/
pj_status_t status;
recv_count++;
if (recv_count > 1) {
PJ_LOG(3,(THIS_FILE," error: not expecting %d-th packet!",
recv_count));
test_complete = -635;
}
status = pjsip_endpt_respond_stateless(endpt, rdata, 202, NULL,
NULL, NULL);
if (status != PJ_SUCCESS) {
app_perror(" error: unable to send response", status);
test_complete = -636;
}
return PJ_TRUE;
} else
if (pj_strcmp2(&rdata->msg_info.via->branch_param, TEST7_BRANCH_ID) == 0) {
/*
* The TEST7_BRANCH_ID test successfull non-INVITE transaction
* with provisional response.
*/
pj_status_t status;
pjsip_response_addr res_addr;
struct response *r;
pjsip_tx_data *tdata;
pj_time_val delay = { 2, 0 };
recv_count++;
if (recv_count > 1) {
PJ_LOG(3,(THIS_FILE," error: not expecting %d-th packet!",
recv_count));
test_complete = -640;
return PJ_TRUE;
}
/* Respond with provisional response */
status = pjsip_endpt_create_response(endpt, rdata, 100, NULL, &tdata);
pj_assert(status == PJ_SUCCESS);
status = pjsip_get_response_addr(tdata->pool, rdata, &res_addr);
pj_assert(status == PJ_SUCCESS);
status = pjsip_endpt_send_response(endpt, &res_addr, tdata,
NULL, NULL);
pj_assert(status == PJ_SUCCESS);
/* Create the final response. */
status = pjsip_endpt_create_response(endpt, rdata, 202, NULL, &tdata);
pj_assert(status == PJ_SUCCESS);
/* Schedule sending final response in couple of of secs. */
r = pj_pool_alloc(tdata->pool, sizeof(*r));
r->res_addr = res_addr;
r->tdata = tdata;
if (r->res_addr.transport)
pjsip_transport_add_ref(r->res_addr.transport);
timer.entry.cb = &send_response_callback;
timer.entry.user_data = r;
pjsip_endpt_schedule_timer(endpt, &timer.entry, &delay);
return PJ_TRUE;
} else
if (pj_strcmp2(&rdata->msg_info.via->branch_param, TEST8_BRANCH_ID) == 0) {
/*
* The TEST8_BRANCH_ID test failed INVITE transaction.
*/
pjsip_method *method;
pj_status_t status;
method = &rdata->msg_info.msg->line.req.method;
recv_count++;
if (method->id == PJSIP_INVITE_METHOD) {
if (recv_count > 1) {
PJ_LOG(3,(THIS_FILE," error: not expecting %d-th packet!",
recv_count));
test_complete = -635;
}
status = pjsip_endpt_respond_stateless(endpt, rdata, 301, NULL,
NULL, NULL);
if (status != PJ_SUCCESS) {
app_perror(" error: unable to send response", status);
test_complete = -636;
}
} else if (method->id == PJSIP_ACK_METHOD) {
if (recv_count == 2) {
pj_str_t key;
pj_time_val delay = { 5, 0 };
/* Schedule timer to destroy transaction after 5 seconds.
* This is to make sure that transaction does not
* retransmit ACK.
*/
pjsip_tsx_create_key(rdata->tp_info.pool, &key,
PJSIP_ROLE_UAC, &pjsip_invite_method,
rdata);
pj_strcpy(&timer.tsx_key, &key);
timer.entry.id = 301;
timer.entry.cb = &terminate_tsx_callback;
pjsip_endpt_schedule_timer(endpt, &timer.entry, &delay);
}
if (recv_count > 2) {
PJ_LOG(3,(THIS_FILE," error: not expecting %d-th packet!",
recv_count));
test_complete = -638;
}
} else {
PJ_LOG(3,(THIS_FILE," error: not expecting %s",
pjsip_rx_data_get_info(rdata)));
test_complete = -639;
}
} else
if (pj_strcmp2(&rdata->msg_info.via->branch_param, TEST9_BRANCH_ID) == 0) {
/*
* The TEST9_BRANCH_ID test failed INVITE transaction with
* provisional response.
*/
pjsip_method *method;
pj_status_t status;
method = &rdata->msg_info.msg->line.req.method;
recv_count++;
if (method->id == PJSIP_INVITE_METHOD) {
pjsip_response_addr res_addr;
struct response *r;
pjsip_tx_data *tdata;
pj_time_val delay = { 2, 0 };
if (recv_count > 1) {
PJ_LOG(3,(THIS_FILE," error: not expecting %d-th packet!",
recv_count));
test_complete = -650;
return PJ_TRUE;
}
/* Respond with provisional response */
status = pjsip_endpt_create_response(endpt, rdata, 100, NULL,
&tdata);
pj_assert(status == PJ_SUCCESS);
status = pjsip_get_response_addr(tdata->pool, rdata, &res_addr);
pj_assert(status == PJ_SUCCESS);
status = pjsip_endpt_send_response(endpt, &res_addr, tdata,
NULL, NULL);
pj_assert(status == PJ_SUCCESS);
/* Create the final response. */
status = pjsip_endpt_create_response(endpt, rdata, 302, NULL,
&tdata);
pj_assert(status == PJ_SUCCESS);
/* Schedule sending final response in couple of of secs. */
r = pj_pool_alloc(tdata->pool, sizeof(*r));
r->res_addr = res_addr;
r->tdata = tdata;
if (r->res_addr.transport)
pjsip_transport_add_ref(r->res_addr.transport);
timer.entry.cb = &send_response_callback;
timer.entry.user_data = r;
pjsip_endpt_schedule_timer(endpt, &timer.entry, &delay);
} else if (method->id == PJSIP_ACK_METHOD) {
if (recv_count == 2) {
pj_str_t key;
pj_time_val delay = { 5, 0 };
/* Schedule timer to destroy transaction after 5 seconds.
* This is to make sure that transaction does not
* retransmit ACK.
*/
pjsip_tsx_create_key(rdata->tp_info.pool, &key,
PJSIP_ROLE_UAC, &pjsip_invite_method,
rdata);
pj_strcpy(&timer.tsx_key, &key);
timer.entry.id = 302;
timer.entry.cb = &terminate_tsx_callback;
pjsip_endpt_schedule_timer(endpt, &timer.entry, &delay);
}
if (recv_count > 2) {
PJ_LOG(3,(THIS_FILE," error: not expecting %d-th packet!",
recv_count));
test_complete = -638;
}
} else {
PJ_LOG(3,(THIS_FILE," error: not expecting %s",
pjsip_rx_data_get_info(rdata)));
test_complete = -639;
}
return PJ_TRUE;
}
return PJ_FALSE;
}
/*
* Handler when invite state has changed.
*/
static void on_call_state(pjsua_call_id call_id, pjsip_event *e)
{
pjsua_call_info call_info;
PJ_UNUSED_ARG(e);
pjsua_call_get_info(call_id, &call_info);
if (call_info.state == PJSIP_INV_STATE_DISCONNECTED) {
/* Cancel duration timer, if any */
if (app_config.call_data[call_id].timer.id != PJSUA_INVALID_ID) {
struct call_data *cd = &app_config.call_data[call_id];
pjsip_endpoint *endpt = pjsua_get_pjsip_endpt();
cd->timer.id = PJSUA_INVALID_ID;
pjsip_endpt_cancel_timer(endpt, &cd->timer);
}
PJ_LOG(3,(THIS_FILE, "Call %d is DISCONNECTED [reason=%d (%s)]",
call_id,
call_info.last_status,
call_info.last_status_text.ptr));
if (call_id == current_call) {
find_next_call();
}
/* Dump media state upon disconnected */
if (1) {
PJ_LOG(5,(THIS_FILE,
"Call %d disconnected, dumping media stats..",
call_id));
log_call_dump(call_id);
}
} else {
if (app_config.duration!=NO_LIMIT &&
call_info.state == PJSIP_INV_STATE_CONFIRMED)
{
/* Schedule timer to hangup call after the specified duration */
struct call_data *cd = &app_config.call_data[call_id];
pjsip_endpoint *endpt = pjsua_get_pjsip_endpt();
pj_time_val delay;
cd->timer.id = call_id;
delay.sec = app_config.duration;
delay.msec = 0;
pjsip_endpt_schedule_timer(endpt, &cd->timer, &delay);
}
if (call_info.state == PJSIP_INV_STATE_EARLY) {
int code;
pj_str_t reason;
pjsip_msg *msg;
/* This can only occur because of TX or RX message */
pj_assert(e->type == PJSIP_EVENT_TSX_STATE);
if (e->body.tsx_state.type == PJSIP_EVENT_RX_MSG) {
msg = e->body.tsx_state.src.rdata->msg_info.msg;
} else {
msg = e->body.tsx_state.src.tdata->msg;
}
code = msg->line.status.code;
reason = msg->line.status.reason;
PJ_LOG(3,(THIS_FILE, "Call %d state changed to %s (%d %.*s)",
call_id, call_info.state_text.ptr,
code, (int)reason.slen, reason.ptr));
} else {
PJ_LOG(3,(THIS_FILE, "Call %d state changed to %s",
call_id,
call_info.state_text.ptr));
}
if (current_call==PJSUA_INVALID_ID)
current_call = call_id;
}
// callback
if (cb_callstate != 0) cb_callstate(call_id, call_info.state);
}
static void tsx_callback(void *token, pjsip_event *event)
{
pj_status_t status;
pjsip_publishc *pubc = (pjsip_publishc*) token;
pjsip_transaction *tsx = event->body.tsx_state.tsx;
/* Decrement pending transaction counter. */
pj_assert(pubc->pending_tsx > 0);
--pubc->pending_tsx;
/* Mark that we're in callback to prevent deletion (#1164) */
++pubc->in_callback;
/* If publication data has been deleted by user then remove publication
* data from transaction's callback, and don't call callback.
*/
if (pubc->_delete_flag) {
/* Nothing to do */
;
} else if (tsx->status_code == PJSIP_SC_PROXY_AUTHENTICATION_REQUIRED ||
tsx->status_code == PJSIP_SC_UNAUTHORIZED)
{
pjsip_rx_data *rdata = event->body.tsx_state.src.rdata;
pjsip_tx_data *tdata;
status = pjsip_auth_clt_reinit_req( &pubc->auth_sess,
rdata,
tsx->last_tx,
&tdata);
if (status != PJ_SUCCESS) {
call_callback(pubc, status, tsx->status_code,
&rdata->msg_info.msg->line.status.reason,
rdata, -1);
} else {
status = pjsip_publishc_send(pubc, tdata);
}
} else {
pjsip_rx_data *rdata;
pj_int32_t expiration = 0xFFFF;
if (tsx->status_code/100 == 2) {
pjsip_msg *msg;
pjsip_expires_hdr *expires;
pjsip_generic_string_hdr *etag_hdr;
const pj_str_t STR_ETAG = { "SIP-ETag", 8 };
rdata = event->body.tsx_state.src.rdata;
msg = rdata->msg_info.msg;
/* Save ETag value */
etag_hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(msg, &STR_ETAG, NULL);
if (etag_hdr) {
pj_strdup(pubc->pool, &pubc->etag, &etag_hdr->hvalue);
} else {
pubc->etag.slen = 0;
}
/* Update expires value */
expires = (pjsip_expires_hdr*)
pjsip_msg_find_hdr(msg, PJSIP_H_EXPIRES, NULL);
if (pubc->auto_refresh && expires)
expiration = expires->ivalue;
if (pubc->auto_refresh && expiration!=0 && expiration!=0xFFFF) {
pj_time_val delay = { 0, 0};
/* Cancel existing timer, if any */
if (pubc->timer.id != 0) {
pjsip_endpt_cancel_timer(pubc->endpt, &pubc->timer);
pubc->timer.id = 0;
}
delay.sec = expiration - DELAY_BEFORE_REFRESH;
if (pubc->expires != PJSIP_PUBC_EXPIRATION_NOT_SPECIFIED &&
delay.sec > (pj_int32_t)pubc->expires)
{
delay.sec = pubc->expires;
}
if (delay.sec < DELAY_BEFORE_REFRESH)
delay.sec = DELAY_BEFORE_REFRESH;
pubc->timer.cb = &pubc_refresh_timer_cb;
pubc->timer.id = REFRESH_TIMER;
pubc->timer.user_data = pubc;
pjsip_endpt_schedule_timer( pubc->endpt, &pubc->timer, &delay);
pj_gettimeofday(&pubc->last_refresh);
pubc->next_refresh = pubc->last_refresh;
pubc->next_refresh.sec += delay.sec;
}
} else {
rdata = (event->body.tsx_state.type==PJSIP_EVENT_RX_MSG) ?
event->body.tsx_state.src.rdata : NULL;
}
/* Call callback. */
if (expiration == 0xFFFF) expiration = -1;
/* Temporarily increment pending_tsx to prevent callback from
* destroying pubc.
*/
++pubc->pending_tsx;
call_callback(pubc, PJ_SUCCESS, tsx->status_code,
(rdata ? &rdata->msg_info.msg->line.status.reason
: pjsip_get_status_text(tsx->status_code)),
rdata, expiration);
--pubc->pending_tsx;
/* If we have pending request(s), send them now */
pj_mutex_lock(pubc->mutex);
while (!pj_list_empty(&pubc->pending_reqs)) {
pjsip_tx_data *tdata = pubc->pending_reqs.next;
pj_list_erase(tdata);
/* Add SIP-If-Match if we have etag and the request doesn't have
* one (http://trac.pjsip.org/repos/ticket/996)
*/
if (pubc->etag.slen) {
const pj_str_t STR_HNAME = { "SIP-If-Match", 12 };
pjsip_generic_string_hdr *sim_hdr;
sim_hdr = (pjsip_generic_string_hdr*)
pjsip_msg_find_hdr_by_name(tdata->msg, &STR_HNAME, NULL);
if (!sim_hdr) {
/* Create the header */
sim_hdr = pjsip_generic_string_hdr_create(tdata->pool,
&STR_HNAME,
&pubc->etag);
pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)sim_hdr);
} else {
/* Update */
if (pj_strcmp(&pubc->etag, &sim_hdr->hvalue))
pj_strdup(tdata->pool, &sim_hdr->hvalue, &pubc->etag);
}
}
status = pjsip_publishc_send(pubc, tdata);
if (status == PJ_EPENDING) {
pj_assert(!"Not expected");
pj_list_erase(tdata);
pjsip_tx_data_dec_ref(tdata);
} else if (status == PJ_SUCCESS) {
break;
}
}
pj_mutex_unlock(pubc->mutex);
}
/* No longer in callback. */
--pubc->in_callback;
/* Delete the record if user destroy pubc during the callback. */
if (pubc->_delete_flag && pubc->pending_tsx==0) {
pjsip_publishc_destroy(pubc);
}
}
/* Timer callback. When the timer is fired, it can be time to refresh
* the session if UA is the refresher, otherwise it is time to end
* the session.
*/
void timer_cb(pj_timer_heap_t *timer_heap, struct pj_timer_entry *entry)
{
pjsip_inv_session *inv = (pjsip_inv_session*) entry->user_data;
pjsip_tx_data *tdata = NULL;
pj_status_t status;
pj_bool_t as_refresher;
pj_assert(inv);
PJ_UNUSED_ARG(timer_heap);
/* When there is a pending INVITE transaction, delay/reschedule this timer
* for five seconds to cover the case that pending INVITE fails and the
* previous session is still active. If the pending INVITE is successful,
* timer state will be updated, i.e: restarted or stopped.
*/
if (inv->invite_tsx != NULL) {
pj_time_val delay = {5};
inv->timer->timer.id = 1;
pjsip_endpt_schedule_timer(inv->dlg->endpt, &inv->timer->timer, &delay);
return;
}
/* Lock dialog. */
pjsip_dlg_inc_lock(inv->dlg);
/* Check our role */
as_refresher =
(inv->timer->refresher == TR_UAC && inv->timer->role == PJSIP_ROLE_UAC) ||
(inv->timer->refresher == TR_UAS && inv->timer->role == PJSIP_ROLE_UAS);
/* Do action based on role, refresher or refreshee */
if (as_refresher) {
pj_time_val now;
/* Refresher, refresh the session */
if (inv->timer->use_update) {
/* Create UPDATE request without offer */
status = pjsip_inv_update(inv, NULL, NULL, &tdata);
} else {
/* Create re-INVITE without modifying session */
pjsip_msg_body *body;
const pjmedia_sdp_session *offer = NULL;
pj_assert(pjmedia_sdp_neg_get_state(inv->neg) ==
PJMEDIA_SDP_NEG_STATE_DONE);
status = pjsip_inv_invite(inv, &tdata);
if (status == PJ_SUCCESS)
status = pjmedia_sdp_neg_send_local_offer(inv->pool_prov,
inv->neg, &offer);
if (status == PJ_SUCCESS)
status = pjmedia_sdp_neg_get_neg_local(inv->neg, &offer);
if (status == PJ_SUCCESS) {
status = pjsip_create_sdp_body(tdata->pool,
(pjmedia_sdp_session*)offer, &body);
tdata->msg->body = body;
}
}
pj_gettimeofday(&now);
PJ_LOG(4, (inv->pool->obj_name,
"Refresh session after %ds (expiration period=%ds)",
(now.sec-inv->timer->last_refresh.sec),
inv->timer->setting.sess_expires));
} else {
pj_time_val now;
/* Refreshee, terminate the session */
status = pjsip_inv_end_session(inv, PJSIP_SC_REQUEST_TIMEOUT,
NULL, &tdata);
pj_gettimeofday(&now);
PJ_LOG(3, (inv->pool->obj_name,
"No session refresh received after %ds "
"(expiration period=%ds), stopping session now!",
(now.sec-inv->timer->last_refresh.sec),
inv->timer->setting.sess_expires));
}
/* Unlock dialog. */
pjsip_dlg_dec_lock(inv->dlg);
/* Send message, if any */
if (tdata && status == PJ_SUCCESS) {
status = pjsip_inv_send_msg(inv, tdata);
}
/* Print error message, if any */
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
if (tdata)
pjsip_tx_data_dec_ref(tdata);
pj_strerror(status, errmsg, sizeof(errmsg));
PJ_LOG(2, (inv->pool->obj_name, "Session timer fails in %s session, "
"err code=%d (%s)",
(as_refresher? "refreshing" :
"terminating"),
status, errmsg));
}
}
int transport_rt_test( pjsip_transport_type_e tp_type,
pjsip_transport *ref_tp,
char *target_url,
int *lost)
{
enum { THREADS = 4, INTERVAL = 10 };
int i;
pj_status_t status;
pj_pool_t *pool;
pj_bool_t logger_enabled;
pj_timestamp zero_time, total_time;
unsigned usec_rt;
unsigned total_sent;
unsigned total_recv;
PJ_UNUSED_ARG(tp_type);
PJ_UNUSED_ARG(ref_tp);
PJ_LOG(3,(THIS_FILE, " multithreaded round-trip test (%d threads)...",
THREADS));
PJ_LOG(3,(THIS_FILE, " this will take approx %d seconds, please wait..",
INTERVAL));
/* Make sure msg logger is disabled. */
logger_enabled = msg_logger_set_enabled(0);
/* Register module (if not yet registered) */
if (rt_module.id == -1) {
status = pjsip_endpt_register_module( endpt, &rt_module );
if (status != PJ_SUCCESS) {
app_perror(" error: unable to register module", status);
return -600;
}
}
/* Create pool for this test. */
pool = pjsip_endpt_create_pool(endpt, NULL, 4000, 4000);
if (!pool)
return -610;
/* Initialize static test data. */
pj_ansi_strcpy(rt_target_uri, target_url);
rt_call_id = pj_str("RT-Call-Id/");
rt_stop = PJ_FALSE;
/* Initialize thread data. */
for (i=0; i<THREADS; ++i) {
char buf[1];
pj_str_t str_id;
pj_strset(&str_id, buf, 1);
pj_bzero(&rt_test_data[i], sizeof(rt_test_data[i]));
/* Init timer entry */
rt_test_data[i].tx_timer.id = i;
rt_test_data[i].tx_timer.cb = &rt_tx_timer;
rt_test_data[i].timeout_timer.id = i;
rt_test_data[i].timeout_timer.cb = &rt_timeout_timer;
/* Generate Call-ID for each thread. */
rt_test_data[i].call_id.ptr = (char*) pj_pool_alloc(pool, rt_call_id.slen+1);
pj_strcpy(&rt_test_data[i].call_id, &rt_call_id);
buf[0] = '0' + (char)i;
pj_strcat(&rt_test_data[i].call_id, &str_id);
/* Init mutex. */
status = pj_mutex_create_recursive(pool, "rt", &rt_test_data[i].mutex);
if (status != PJ_SUCCESS) {
app_perror(" error: unable to create mutex", status);
return -615;
}
/* Create thread, suspended. */
status = pj_thread_create(pool, "rttest%p", &rt_worker_thread, (void*)(long)i, 0,
PJ_THREAD_SUSPENDED, &rt_test_data[i].thread);
if (status != PJ_SUCCESS) {
app_perror(" error: unable to create thread", status);
return -620;
}
}
/* Start threads! */
for (i=0; i<THREADS; ++i) {
pj_time_val delay = {0,0};
pj_thread_resume(rt_test_data[i].thread);
/* Schedule first message transmissions. */
rt_test_data[i].tx_timer.user_data = (void*)1;
pjsip_endpt_schedule_timer(endpt, &rt_test_data[i].tx_timer, &delay);
}
/* Sleep for some time. */
pj_thread_sleep(INTERVAL * 1000);
/* Signal thread to stop. */
rt_stop = PJ_TRUE;
/* Wait threads to complete. */
for (i=0; i<THREADS; ++i) {
pj_thread_join(rt_test_data[i].thread);
pj_thread_destroy(rt_test_data[i].thread);
}
/* Destroy rt_test_data */
for (i=0; i<THREADS; ++i) {
pj_mutex_destroy(rt_test_data[i].mutex);
pjsip_endpt_cancel_timer(endpt, &rt_test_data[i].timeout_timer);
}
/* Gather statistics. */
pj_bzero(&total_time, sizeof(total_time));
pj_bzero(&zero_time, sizeof(zero_time));
usec_rt = total_sent = total_recv = 0;
for (i=0; i<THREADS; ++i) {
total_sent += rt_test_data[i].sent_request_count;
total_recv += rt_test_data[i].recv_response_count;
pj_add_timestamp(&total_time, &rt_test_data[i].total_rt_time);
}
/* Display statistics. */
if (total_recv)
total_time.u64 = total_time.u64/total_recv;
else
total_time.u64 = 0;
usec_rt = pj_elapsed_usec(&zero_time, &total_time);
PJ_LOG(3,(THIS_FILE, " done."));
PJ_LOG(3,(THIS_FILE, " total %d messages sent", total_sent));
PJ_LOG(3,(THIS_FILE, " average round-trip=%d usec", usec_rt));
pjsip_endpt_release_pool(endpt, pool);
*lost = total_sent-total_recv;
/* Flush events. */
flush_events(500);
/* Restore msg logger. */
msg_logger_set_enabled(logger_enabled);
return 0;
}
/* Timer callback. When the timer is fired, it can be time to refresh
* the session if UA is the refresher, otherwise it is time to end
* the session.
*/
static void timer_cb(pj_timer_heap_t *timer_heap, struct pj_timer_entry *entry)
{
pjsip_inv_session *inv = (pjsip_inv_session*) entry->user_data;
pjsip_tx_data *tdata = NULL;
pj_status_t status;
pj_bool_t as_refresher;
pj_assert(inv);
PJ_UNUSED_ARG(timer_heap);
/* Lock dialog. */
pjsip_dlg_inc_lock(inv->dlg);
/* Check our role */
as_refresher =
(inv->timer->refresher == TR_UAC && inv->timer->role == PJSIP_ROLE_UAC) ||
(inv->timer->refresher == TR_UAS && inv->timer->role == PJSIP_ROLE_UAS);
/* Do action based on role(refresher or refreshee).
* As refresher:
* - send refresh, or
* - end session if there is no response to the refresh request.
* As refreshee:
* - end session if there is no refresh request received.
*/
if (as_refresher && (entry->id != REFRESHER_EXPIRE_TIMER_ID)) {
pj_time_val now;
/* As refresher, reshedule the refresh request on the following:
* - must not send re-INVITE if another INVITE or SDP negotiation
* is in progress.
* - must not send UPDATE with SDP if SDP negotiation is in progress
*/
pjmedia_sdp_neg_state neg_state = pjmedia_sdp_neg_get_state(inv->neg);
inv->timer->timer.id = 0;
if ( (!inv->timer->use_update && (
inv->invite_tsx != NULL ||
neg_state != PJMEDIA_SDP_NEG_STATE_DONE)
)
||
(inv->timer->use_update && inv->timer->with_sdp &&
neg_state != PJMEDIA_SDP_NEG_STATE_DONE
)
)
{
pj_time_val delay = {1, 0};
inv->timer->timer.id = 1;
pjsip_endpt_schedule_timer(inv->dlg->endpt, &inv->timer->timer,
&delay);
pjsip_dlg_dec_lock(inv->dlg);
return;
}
/* Refresher, refresh the session */
if (inv->timer->use_update) {
const pjmedia_sdp_session *offer = NULL;
if (inv->timer->with_sdp) {
pjmedia_sdp_neg_get_active_local(inv->neg, &offer);
}
status = pjsip_inv_update(inv, NULL, offer, &tdata);
} else {
/* Create re-INVITE without modifying session */
pjsip_msg_body *body;
const pjmedia_sdp_session *offer = NULL;
pj_assert(pjmedia_sdp_neg_get_state(inv->neg) ==
PJMEDIA_SDP_NEG_STATE_DONE);
status = pjsip_inv_invite(inv, &tdata);
if (status == PJ_SUCCESS)
status = pjmedia_sdp_neg_send_local_offer(inv->pool_prov,
inv->neg, &offer);
if (status == PJ_SUCCESS)
status = pjmedia_sdp_neg_get_neg_local(inv->neg, &offer);
if (status == PJ_SUCCESS) {
status = pjsip_create_sdp_body(tdata->pool,
(pjmedia_sdp_session*)offer, &body);
tdata->msg->body = body;
}
}
pj_gettimeofday(&now);
PJ_LOG(4, (inv->pool->obj_name,
"Refreshing session after %ds (expiration period=%ds)",
(now.sec-inv->timer->last_refresh.sec),
inv->timer->setting.sess_expires));
} else {
pj_time_val now;
if (as_refresher)
inv->timer->expire_timer.id = 0;
else
inv->timer->timer.id = 0;
/* Terminate the session */
status = pjsip_inv_end_session(inv, PJSIP_SC_REQUEST_TIMEOUT,
NULL, &tdata);
pj_gettimeofday(&now);
PJ_LOG(3, (inv->pool->obj_name,
"No session %s received after %ds "
"(expiration period=%ds), stopping session now!",
(as_refresher?"refresh response":"refresh"),
(now.sec-inv->timer->last_refresh.sec),
inv->timer->setting.sess_expires));
}
/* Unlock dialog. */
pjsip_dlg_dec_lock(inv->dlg);
/* Send message, if any */
if (tdata && status == PJ_SUCCESS) {
inv->timer->refresh_tdata = tdata;
status = pjsip_inv_send_msg(inv, tdata);
}
/* Print error message, if any */
if (status != PJ_SUCCESS) {
PJ_PERROR(2, (inv->pool->obj_name, status,
"Error in %s session timer",
((as_refresher && entry->id != REFRESHER_EXPIRE_TIMER_ID)?
"refreshing" : "terminating")));
}
}