/*
* fake_udp_shutdown()
*
* Start graceful FAKE_UDP shutdown.
*/
static pj_status_t fake_udp_shutdown(pjsip_transport *transport)
{
return pjsip_transport_dec_ref(transport);
}
/*
* 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;
}
static void regc_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_bool_t handled = PJ_TRUE;
pj_bool_t update_contact = PJ_FALSE;
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);
}
}
if (regc->_delete_flag == 0 && regc->tsx_cb &&
regc->current_op == REGC_REGISTERING)
{
struct pjsip_regc_tsx_cb_param param;
param.contact_cnt = -1;
cbparam_init(¶m.cbparam, regc, PJ_SUCCESS, tsx->status_code,
&tsx->status_text,
(event->body.tsx_state.type==PJSIP_EVENT_RX_MSG) ?
event->body.tsx_state.src.rdata : NULL,
-1, 0, NULL, PJ_FALSE);
/* Call regc tsx callback before handling any response */
pj_lock_release(regc->lock);
(*regc->tsx_cb)(¶m);
pj_lock_acquire(regc->lock);
if (param.contact_cnt >= 0) {
/* Since we receive non-2xx response, it means that (some) contact
* bindings haven't been established so we can safely remove these
* contact headers. This is to avoid removing non-existent contact
* bindings later.
*/
if (tsx->status_code/100 != 2) {
pjsip_contact_hdr *h;
h = regc->contact_hdr_list.next;
while (h != ®c->contact_hdr_list) {
pjsip_contact_hdr *next = h->next;
if (h->expires == -1) {
pj_list_erase(h);
}
h = next;
}
}
/* Update contact address */
pjsip_regc_update_contact(regc, param.contact_cnt, param.contact);
update_contact = PJ_TRUE;
}
}
/* 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;
pj_bool_t is_unreg;
/* reset current op */
is_unreg = (regc->current_op == REGC_UNREGISTERING);
regc->current_op = REGC_IDLE;
if (update_contact) {
pjsip_msg *msg;
pjsip_hdr *hdr, *ins_hdr;
pjsip_contact_hdr *chdr;
/* Delete Contact headers, but we shouldn't delete headers
* which are supposed to remove contact bindings since
* we cannot reconstruct those headers.
*/
msg = tsx->last_tx->msg;
hdr = msg->hdr.next;
ins_hdr = &msg->hdr;
while (hdr != &msg->hdr) {
pjsip_hdr *next = hdr->next;
if (hdr->type == PJSIP_H_CONTACT) {
chdr = (pjsip_contact_hdr *)hdr;
if (chdr->expires != 0) {
pj_list_erase(hdr);
ins_hdr = next;
}
}
hdr = next;
}
/* Add Contact headers. */
chdr = regc->contact_hdr_list.next;
while (chdr != ®c->contact_hdr_list) {
pj_list_insert_before(ins_hdr, (pjsip_hdr*)
pjsip_hdr_clone(tsx->last_tx->pool, chdr));
chdr = chdr->next;
}
/* Also add bindings which are to be removed */
while (!pj_list_empty(®c->removed_contact_hdr_list)) {
chdr = regc->removed_contact_hdr_list.next;
pj_list_insert_before(ins_hdr, (pjsip_hdr*)
pjsip_hdr_clone(tsx->last_tx->pool, chdr));
pj_list_erase(chdr);
}
}
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, is_unreg);
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 if (tsx->status_code == PJSIP_SC_INTERVAL_TOO_BRIEF &&
regc->current_op == REGC_REGISTERING)
{
/* Handle 423 response automatically:
* - set requested expiration to Min-Expires header, ONLY IF
* the original request is a registration (as opposed to
* unregistration) and the requested expiration was indeed
* lower than Min-Expires)
* - resend the request
*/
pjsip_rx_data *rdata = event->body.tsx_state.src.rdata;
pjsip_min_expires_hdr *me_hdr;
pjsip_tx_data *tdata;
pj_int32_t min_exp;
/* reset current op */
regc->current_op = REGC_IDLE;
/* Update requested expiration */
me_hdr = (pjsip_min_expires_hdr*)
pjsip_msg_find_hdr(rdata->msg_info.msg,
PJSIP_H_MIN_EXPIRES, NULL);
if (me_hdr) {
min_exp = me_hdr->ivalue;
} else {
/* Broken server, Min-Expires doesn't exist.
* Just guestimate then, BUT ONLY if if this is the
* first time we received such response.
*/
enum {
/* Note: changing this value would require changing couple of
* Python test scripts.
*/
UNSPECIFIED_MIN_EXPIRES = 3601
};
if (!regc->expires_hdr ||
regc->expires_hdr->ivalue != UNSPECIFIED_MIN_EXPIRES)
{
min_exp = UNSPECIFIED_MIN_EXPIRES;
} else {
handled = PJ_FALSE;
PJ_LOG(4,(THIS_FILE, "Registration failed: 423 response "
"without Min-Expires header is invalid"));
goto handle_err;
}
}
if (regc->expires_hdr && regc->expires_hdr->ivalue >= min_exp) {
/* But we already send with greater expiration time, why does
* the server send us with 423? Oh well, just fail the request.
*/
handled = PJ_FALSE;
PJ_LOG(4,(THIS_FILE, "Registration failed: invalid "
"Min-Expires header value in response"));
goto handle_err;
}
set_expires(regc, min_exp);
status = pjsip_regc_register(regc, regc->auto_reg, &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) {
/* 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_FALSE);
pj_lock_acquire(regc->lock);
}
}
} else {
handled = PJ_FALSE;
}
handle_err:
if (!handled) {
pjsip_rx_data *rdata;
pj_int32_t expiration = NOEXP;
unsigned contact_cnt = 0;
pjsip_contact_hdr *contact[PJSIP_REGC_MAX_CONTACT];
pj_bool_t is_unreg;
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);
/* Schedule next registration */
schedule_registration(regc, expiration);
} 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;
/* Mark operation as complete */
is_unreg = (regc->current_op == REGC_UNREGISTERING);
regc->current_op = REGC_IDLE;
/* 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
: &tsx->status_text),
rdata, expiration,
contact_cnt, contact, is_unreg);
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);
}
}
PJ_DEF(pj_status_t) pjsip_regc_send(pjsip_regc *regc, pjsip_tx_data *tdata)
{
pj_status_t status;
pjsip_cseq_hdr *cseq_hdr;
pjsip_expires_hdr *expires_hdr;
pj_uint32_t cseq;
pj_atomic_inc(regc->busy_ctr);
pj_lock_acquire(regc->lock);
/* Make sure we don't have pending transaction. */
if (regc->has_tsx) {
PJ_LOG(4,(THIS_FILE, "Unable to send request, regc has another "
"transaction pending"));
pjsip_tx_data_dec_ref( tdata );
pj_lock_release(regc->lock);
pj_atomic_dec(regc->busy_ctr);
return PJSIP_EBUSY;
}
/* Just regc->has_tsx check above should be enough. This assertion check
* may cause problem, e.g: when regc_tsx_callback() invokes callback,
* lock is released and 'has_tsx' is set to FALSE and 'current_op' has
* not been updated to REGC_IDLE yet.
*/
//pj_assert(regc->current_op == REGC_IDLE);
/* Invalidate message buffer. */
pjsip_tx_data_invalidate_msg(tdata);
/* Increment CSeq */
cseq = ++regc->cseq_hdr->cseq;
cseq_hdr = (pjsip_cseq_hdr*)
pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ, NULL);
cseq_hdr->cseq = cseq;
/* Find Expires header */
expires_hdr = (pjsip_expires_hdr*)
pjsip_msg_find_hdr(tdata->msg, PJSIP_H_EXPIRES, NULL);
/* Bind to transport selector */
pjsip_tx_data_set_transport(tdata, ®c->tp_sel);
regc->has_tsx = PJ_TRUE;
/* Set current operation based on the value of Expires header */
if (expires_hdr && expires_hdr->ivalue==0)
regc->current_op = REGC_UNREGISTERING;
else
regc->current_op = REGC_REGISTERING;
if (expires_hdr && expires_hdr->ivalue)
regc->expires_requested = expires_hdr->ivalue;
/* Prevent deletion of tdata, e.g: when something wrong in sending,
* we need tdata to retrieve the transport.
*/
pjsip_tx_data_add_ref(tdata);
/* If via_addr is set, use this address for the Via header. */
if (regc->via_addr.host.slen > 0) {
tdata->via_addr = regc->via_addr;
tdata->via_tp = regc->via_tp;
}
/* Need to unlock the regc temporarily while sending the message to
* prevent deadlock (https://trac.pjsip.org/repos/ticket/1247).
* It should be safe to do this since the regc's refcount has been
* incremented.
*/
pj_lock_release(regc->lock);
/* Now send the message */
status = pjsip_endpt_send_request(regc->endpt, tdata, REGC_TSX_TIMEOUT,
regc, ®c_tsx_callback);
if (status!=PJ_SUCCESS) {
/* On failure, regc_tsx_callback() may not be called, so we need
* to reset regc->has_tsx here (see also ticket #1936).
*/
regc->has_tsx = PJ_FALSE;
PJ_LOG(4,(THIS_FILE, "Error sending request, status=%d", status));
}
/* Reacquire the lock */
pj_lock_acquire(regc->lock);
/* Get last transport used and add reference to it */
if (tdata->tp_info.transport != regc->last_transport &&
status==PJ_SUCCESS)
{
if (regc->last_transport) {
pjsip_transport_dec_ref(regc->last_transport);
regc->last_transport = NULL;
}
if (tdata->tp_info.transport) {
regc->last_transport = tdata->tp_info.transport;
pjsip_transport_add_ref(regc->last_transport);
}
}
/* Release tdata */
pjsip_tx_data_dec_ref(tdata);
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);
}
return status;
}
int regc_test(void)
{
struct test_rec {
unsigned check_contact;
unsigned add_xuid_param;
const char *title;
char *alt_registrar;
unsigned contact_cnt;
char *contacts[4];
unsigned expires;
struct registrar_cfg server_cfg;
struct client client_cfg;
} test_rec[] =
{
/* immediate error */
{
OFF, /* check_contact */
OFF, /* add_xuid_param */
"immediate error", /* title */
"sip:unresolved-host-xyy", /* alt_registrar */
1, /* contact cnt */
{ "sip:[email protected]:5060" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_FALSE, 200, PJ_FALSE, NONE, 0, 0, {NULL, 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 503, PJ_FALSE, -1, 0, PJ_FALSE}
},
/* timeout test */
{
OFF, /* check_contact */
OFF, /* add_xuid_param */
"timeout test (takes ~32 secs)",/* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "sip:[email protected]:5060" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_FALSE, 200, PJ_FALSE, NONE, 0, 0, {NULL, 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth? */
{ PJ_FALSE, 408, PJ_FALSE, -1, 0, PJ_FALSE}
},
/* Basic successful registration scenario:
* a good registrar returns the Contact header as is and
* add expires parameter. In this test no additional bindings
* are returned.
*/
{
ON_OFF, /* check_contact */
ON_OFF, /* add_xuid_param */
"basic", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060;transport=udp;x-param=1234>" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 200, PJ_FALSE, EXACT, 75, 65, {NULL, 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 200, PJ_TRUE, 75, 1, PJ_FALSE}
},
/* Basic successful registration scenario with authentication
*/
{
ON_OFF, /* check_contact */
ON_OFF, /* add_xuid_param */
"authentication", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060;transport=udp;x-param=1234>" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 200, PJ_TRUE, EXACT, 75, 65, {NULL, 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 200, PJ_TRUE, 75, 1, PJ_TRUE}
},
/* a good registrar returns the Contact header as is and
* add expires parameter. Also it adds bindings from other
* clients in this test.
*/
{
ON_OFF, /* check_contact */
ON, /* add_xuid_param */
"more bindings in response", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060;transport=udp>" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 200, PJ_FALSE, EXACT, 75, 65, {"<sip:a@a>;expires=70", 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 200, PJ_TRUE, 75, 2, PJ_FALSE}
},
/* a bad registrar returns modified Contact header, but it
* still returns all parameters intact. In this case
* the expiration is taken from the expires param because
* of matching xuid param or because the number of
* Contact header matches.
*/
{
ON_OFF, /* check_contact */
ON_OFF, /* add_xuid_param */
"registrar modifies Contact header", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060>" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 200, PJ_FALSE, MODIFIED, 75, 65, {NULL, 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 200, PJ_TRUE, 75, 1, PJ_FALSE}
},
/* a bad registrar returns modified Contact header, but it
* still returns all parameters intact. In addition it returns
* bindings from other clients.
*
* In this case the expiration is taken from the expires param
* because add_xuid_param is enabled.
*/
{
ON_OFF, /* check_contact */
ON, /* add_xuid_param */
"registrar modifies Contact header and add bindings", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060>" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 200, PJ_FALSE, MODIFIED, 75, 65, {"<sip:a@a>;expires=70", 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 200, PJ_TRUE, 75, 2, PJ_FALSE}
},
/* a bad registrar returns completely different Contact and
* all parameters are gone. In this case the expiration is
* also taken from the expires param since the number of
* header matches.
*/
{
ON_OFF, /* check_contact */
ON_OFF, /* add_xuid_param */
"registrar replaces Contact header", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060>" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 202, PJ_FALSE, NONE, 0, 65, {"<sip:a@A>;expires=75", 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 202, PJ_TRUE, 75, 1, PJ_FALSE}
},
/* a bad registrar returns completely different Contact (and
* all parameters are gone) and it also includes bindings from
* other clients.
* In this case the expiration is taken from the Expires header.
*/
{
ON_OFF, /* check_contact */
ON_OFF, /* add_xuid_param */
" as above with additional bindings", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060>" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 200, PJ_FALSE, NONE, 0, 65, {"<sip:a@A>;expires=75, <sip:b@B;expires=70>", 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 200, PJ_TRUE, 65, 2, PJ_FALSE}
},
/* the registrar doesn't return any bindings, but for some
* reason it includes an Expires header.
* In this case the expiration is taken from the Expires header.
*/
{
ON_OFF, /* check_contact */
ON_OFF, /* add_xuid_param */
"no Contact but with Expires", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060>" }, /* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 200, PJ_FALSE, NONE, 0, 65, {NULL, 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 200, PJ_TRUE, 65, 0, PJ_FALSE}
},
/* Neither Contact header nor Expires header are present.
* In this case the expiration is taken from the request.
*/
{
ON_OFF, /* check_contact */
ON_OFF, /* add_xuid_param */
"no Contact and no Expires", /* title */
NULL, /* alt_registrar */
1, /* contact cnt */
{ "<sip:[email protected]:5060>" },/* contacts[] */
600, /* expires */
/* registrar config: */
/* respond code auth contact exp_prm expires more_contacts */
{ PJ_TRUE, 200, PJ_FALSE, NONE, 0, 0, {NULL, 0}},
/* client expected results: */
/* error code have_reg expiration contact_cnt auth?*/
{ PJ_FALSE, 200, PJ_TRUE, 600, 0, PJ_FALSE}
},
};
unsigned i;
pj_sockaddr_in addr;
pjsip_transport *udp = NULL;
pj_uint16_t port;
char registrar_uri_buf[80];
pj_str_t registrar_uri;
int rc = 0;
pj_sockaddr_in_init(&addr, 0, 0);
/* Acquire existing transport, if any */
rc = pjsip_endpt_acquire_transport(endpt, PJSIP_TRANSPORT_UDP, &addr, sizeof(addr), NULL, &udp);
if (rc == PJ_SUCCESS) {
port = pj_sockaddr_get_port(&udp->local_addr);
pjsip_transport_dec_ref(udp);
udp = NULL;
} else {
rc = pjsip_udp_transport_start(endpt, NULL, NULL, 1, &udp);
if (rc != PJ_SUCCESS) {
app_perror(" error creating UDP transport", rc);
rc = -2;
goto on_return;
}
port = pj_sockaddr_get_port(&udp->local_addr);
}
/* Register registrar module */
rc = pjsip_endpt_register_module(endpt, ®istrar.mod);
if (rc != PJ_SUCCESS) {
app_perror(" error registering module", rc);
rc = -3;
goto on_return;
}
/* Register send module */
rc = pjsip_endpt_register_module(endpt, &send_mod.mod);
if (rc != PJ_SUCCESS) {
app_perror(" error registering module", rc);
rc = -3;
goto on_return;
}
pj_ansi_snprintf(registrar_uri_buf, sizeof(registrar_uri_buf),
"sip:127.0.0.1:%d", (int)port);
registrar_uri = pj_str(registrar_uri_buf);
for (i=0; i<PJ_ARRAY_SIZE(test_rec); ++i) {
struct test_rec *t = &test_rec[i];
unsigned j, x;
pj_str_t reg_uri;
pj_str_t contacts[8];
/* Fill in the registrar address if it's not specified */
if (t->alt_registrar == NULL) {
reg_uri = registrar_uri;
} else {
reg_uri = pj_str(t->alt_registrar);
}
/* Build contact pj_str_t's */
for (j=0; j<t->contact_cnt; ++j) {
contacts[j] = pj_str(t->contacts[j]);
}
/* Normalize more_contacts field */
if (t->server_cfg.more_contacts.ptr)
t->server_cfg.more_contacts.slen = strlen(t->server_cfg.more_contacts.ptr);
/* Do tests with three combinations:
* - check_contact on/off
* - add_xuid_param on/off
* - destroy_on_callback on/off
*/
for (x=1; x<=2; ++x) {
unsigned y;
if ((t->check_contact & x) == 0)
continue;
pjsip_cfg()->regc.check_contact = (x-1);
for (y=1; y<=2; ++y) {
unsigned z;
if ((t->add_xuid_param & y) == 0)
continue;
pjsip_cfg()->regc.add_xuid_param = (y-1);
for (z=0; z<=1; ++z) {
char new_title[200];
t->client_cfg.destroy_on_cb = z;
sprintf(new_title, "%s [check=%d, xuid=%d, destroy=%d]",
t->title, pjsip_cfg()->regc.check_contact,
pjsip_cfg()->regc.add_xuid_param, z);
rc = do_test(new_title, &t->server_cfg, &t->client_cfg,
®_uri, t->contact_cnt, contacts,
t->expires, PJ_FALSE, NULL);
if (rc != 0)
goto on_return;
}
}
}
/* Sleep between test groups to avoid using up too many
* active transactions.
*/
pj_thread_sleep(1000);
}
/* keep-alive test */
rc = keep_alive_test(®istrar_uri);
if (rc != 0)
goto on_return;
/* Send error on refresh without destroy on callback */
rc = refresh_error(®istrar_uri, PJ_FALSE);
if (rc != 0)
goto on_return;
/* Send error on refresh, destroy on callback */
rc = refresh_error(®istrar_uri, PJ_TRUE);
if (rc != 0)
goto on_return;
/* Updating contact */
rc = update_test(®istrar_uri);
if (rc != 0)
goto on_return;
/* Send error during auth, don't destroy on callback */
rc = auth_send_error(®istrar_uri, PJ_FALSE);
if (rc != 0)
goto on_return;
/* Send error during auth, destroy on callback */
rc = auth_send_error(®istrar_uri, PJ_FALSE);
if (rc != 0)
goto on_return;
on_return:
if (registrar.mod.id != -1) {
pjsip_endpt_unregister_module(endpt, ®istrar.mod);
}
if (send_mod.mod.id != -1) {
pjsip_endpt_unregister_module(endpt, &send_mod.mod);
}
if (udp) {
pjsip_transport_dec_ref(udp);
}
return rc;
}
