static int xhttp_process_request(sip_msg_t* orig_msg,
char* new_buf, unsigned int new_len)
{
int ret;
sip_msg_t tmp_msg, *msg;
struct run_act_ctx ra_ctx;
ret=0;
if (new_buf && new_len)
{
memset(&tmp_msg, 0, sizeof(sip_msg_t));
tmp_msg.buf = new_buf;
tmp_msg.len = new_len;
tmp_msg.rcv = orig_msg->rcv;
tmp_msg.id = orig_msg->id;
tmp_msg.set_global_address = orig_msg->set_global_address;
tmp_msg.set_global_port = orig_msg->set_global_port;
if (parse_msg(new_buf, new_len, &tmp_msg) != 0)
{
LM_ERR("parse_msg failed\n");
goto error;
}
msg = &tmp_msg;
} else {
msg = orig_msg;
}
if ((msg->first_line.type != SIP_REQUEST) || (msg->via1 == 0) ||
(msg->via1->error != PARSE_OK))
{
LM_CRIT("strange message: %.*s\n", msg->len, msg->buf);
goto error;
}
if (exec_pre_script_cb(msg, REQUEST_CB_TYPE) == 0)
{
goto done;
}
init_run_actions_ctx(&ra_ctx);
if (run_actions(&ra_ctx, event_rt.rlist[xhttp_route_no], msg) < 0)
{
ret=-1;
LM_DBG("error while trying script\n");
goto done;
}
done:
exec_post_script_cb(msg, REQUEST_CB_TYPE);
if (msg != orig_msg)
{
free_sip_msg(msg);
}
return ret;
error:
return -1;
}
/*!
* \brief Timer function that removes expired dialogs, run timeout route
* \param tl dialog timer list
*/
void dlg_ontimeout(struct dlg_tl *tl) {
struct dlg_cell *dlg;
int new_state, old_state, unref;
struct sip_msg *fmsg;
/* get the dialog tl payload */
dlg = ((struct dlg_cell*) ((char *) (tl) -
(unsigned long) (&((struct dlg_cell*) 0)->tl)));
if (dlg->toroute > 0 && dlg->toroute < main_rt.entries
&& main_rt.rlist[dlg->toroute] != NULL) {
fmsg = faked_msg_next();
if (exec_pre_script_cb(fmsg, REQUEST_CB_TYPE) > 0) {
dlg_set_ctx_dialog(dlg);
LM_DBG("executing route %d on timeout\n", dlg->toroute);
set_route_type(REQUEST_ROUTE);
run_top_route(main_rt.rlist[dlg->toroute], fmsg, 0);
dlg_set_ctx_dialog(0);
exec_post_script_cb(fmsg, REQUEST_CB_TYPE);
}
}
if ((dlg->dflags & DLG_FLAG_TOBYE)
&& (dlg->state == DLG_STATE_CONFIRMED)) {
//TODO: dlg_bye_all(dlg, NULL);
unref_dlg(dlg, 1);
return;
}
next_state_dlg(dlg, DLG_EVENT_REQBYE, &old_state, &new_state, &unref, 0);
if (new_state == DLG_STATE_DELETED && old_state != DLG_STATE_DELETED) {
LM_WARN("timeout for dlg with CallID '%.*s' and tags '%.*s'\n",
dlg->callid.len, dlg->callid.s,
dlg->from_tag.len, dlg->from_tag.s);
/* dialog timeout */
run_dlg_callbacks(DLGCB_EXPIRED, dlg, NULL, NULL, DLG_DIR_NONE, 0);
unref_dlg(dlg, unref + 1);
} else {
unref_dlg(dlg, 1);
}
return;
}
/*!
* \brief Execute event routes based on new state
*
*/
void dlg_run_event_route(dlg_cell_t *dlg, sip_msg_t *msg, int ostate, int nstate)
{
sip_msg_t *fmsg;
int rt;
int bkroute;
if(dlg==NULL)
return;
if(ostate==nstate)
return;
rt = -1;
if(nstate==DLG_STATE_CONFIRMED_NA) {
rt = dlg_event_rt[DLG_EVENTRT_START];
} else if(nstate==DLG_STATE_DELETED) {
if(ostate==DLG_STATE_CONFIRMED || ostate==DLG_STATE_CONFIRMED_NA)
rt = dlg_event_rt[DLG_EVENTRT_END];
else if(ostate==DLG_STATE_UNCONFIRMED || ostate==DLG_STATE_EARLY)
rt = dlg_event_rt[DLG_EVENTRT_FAILED];
}
if(rt==-1 || event_rt.rlist[rt]==NULL)
return;
if(msg==NULL)
fmsg = faked_msg_next();
else
fmsg = msg;
if (exec_pre_script_cb(fmsg, LOCAL_CB_TYPE)>0)
{
dlg_ref(dlg, 1);
dlg_set_ctx_iuid(dlg);
LM_DBG("executing event_route %d on state %d\n", rt, nstate);
bkroute = get_route_type();
set_route_type(LOCAL_ROUTE);
run_top_route(event_rt.rlist[rt], fmsg, 0);
dlg_reset_ctx_iuid();
exec_post_script_cb(fmsg, LOCAL_CB_TYPE);
dlg_unref(dlg, 1);
set_route_type(bkroute);
}
}
void stm_timer_exec(unsigned int ticks, void *param)
{
stm_timer_t *it;
stm_route_t *rt;
sip_msg_t *fmsg;
if(param==NULL)
return;
it = (stm_timer_t*)param;
if(it->rt==NULL)
return;
for(rt=it->rt; rt; rt=rt->next)
{
fmsg = faked_msg_next();
if (exec_pre_script_cb(fmsg, REQUEST_CB_TYPE)==0 )
continue; /* drop the request */
set_route_type(REQUEST_ROUTE);
run_top_route(main_rt.rlist[rt->route], fmsg, 0);
exec_post_script_cb(fmsg, REQUEST_CB_TYPE);
}
}
/* WARNING: buf must be 0 terminated (buf[len]=0) or some things might
* break (e.g.: modules/textops)
*/
int receive_msg(char* buf, unsigned int len, struct receive_info* rcv_info)
{
struct sip_msg* msg;
struct run_act_ctx ctx;
int ret;
#ifdef STATS
int skipped = 1;
struct timeval tvb, tve;
struct timezone tz;
unsigned int diff;
#endif
str inb;
inb.s = buf;
inb.len = len;
sr_event_exec(SREV_NET_DATA_IN, (void*)&inb);
len = inb.len;
msg=pkg_malloc(sizeof(struct sip_msg));
if (msg==0) {
LOG(L_ERR, "ERROR: receive_msg: no mem for sip_msg\n");
goto error00;
}
msg_no++;
/* number of vias parsed -- good for diagnostic info in replies */
via_cnt=0;
memset(msg,0, sizeof(struct sip_msg)); /* init everything to 0 */
/* fill in msg */
msg->buf=buf;
msg->len=len;
/* zero termination (termination of orig message bellow not that
useful as most of the work is done with scratch-pad; -jiri */
/* buf[len]=0; */ /* WARNING: zero term removed! */
msg->rcv=*rcv_info;
msg->id=msg_no;
msg->pid=my_pid();
msg->set_global_address=default_global_address;
msg->set_global_port=default_global_port;
if(likely(sr_msg_time==1)) msg_set_time(msg);
if (parse_msg(buf,len, msg)!=0){
if(sr_event_exec(SREV_RCV_NOSIP, (void*)msg)!=0) {
LOG(cfg_get(core, core_cfg, corelog),
"core parsing of SIP message failed (%s:%d/%d)\n",
ip_addr2a(&msg->rcv.src_ip), (int)msg->rcv.src_port,
(int)msg->rcv.proto);
sr_core_ert_run(msg, SR_CORE_ERT_RECEIVE_PARSE_ERROR);
}
goto error02;
}
DBG("After parse_msg...\n");
/* ... clear branches from previous message */
clear_branches();
if (msg->first_line.type==SIP_REQUEST){
ruri_mark_new(); /* ruri is usable for forking (not consumed yet) */
if (!IS_SIP(msg)){
if ((ret=nonsip_msg_run_hooks(msg))!=NONSIP_MSG_ACCEPT){
if (unlikely(ret==NONSIP_MSG_ERROR))
goto error03;
goto end; /* drop the message */
}
}
/* sanity checks */
if ((msg->via1==0) || (msg->via1->error!=PARSE_OK)){
/* no via, send back error ? */
LOG(L_ERR, "ERROR: receive_msg: no via found in request\n");
STATS_BAD_MSG();
goto error02;
}
/* check if necessary to add receive?->moved to forward_req */
/* check for the alias stuff */
#ifdef USE_TCP
if (msg->via1->alias && cfg_get(tcp, tcp_cfg, accept_aliases) &&
(((rcv_info->proto==PROTO_TCP) && !tcp_disable)
#ifdef USE_TLS
|| ((rcv_info->proto==PROTO_TLS) && !tls_disable)
#endif
)
){
if (tcpconn_add_alias(rcv_info->proto_reserved1, msg->via1->port,
rcv_info->proto)!=0){
LOG(L_ERR, " ERROR: receive_msg: tcp alias failed\n");
/* continue */
}
}
#endif
/* skip: */
DBG("preparing to run routing scripts...\n");
#ifdef STATS
gettimeofday( & tvb, &tz );
#endif
/* execute pre-script callbacks, if any; -jiri */
/* if some of the callbacks said not to continue with
script processing, don't do so
if we are here basic sanity checks are already done
(like presence of at least one via), so you can count
on via1 being parsed in a pre-script callback --andrei
*/
if (exec_pre_script_cb(msg, REQUEST_CB_TYPE)==0 )
{
STATS_REQ_FWD_DROP();
goto end; /* drop the request */
}
set_route_type(REQUEST_ROUTE);
/* exec the routing script */
if (run_top_route(main_rt.rlist[DEFAULT_RT], msg, 0)<0){
LOG(L_WARN, "WARNING: receive_msg: "
"error while trying script\n");
goto error_req;
}
#ifdef STATS
gettimeofday( & tve, &tz );
diff = (tve.tv_sec-tvb.tv_sec)*1000000+(tve.tv_usec-tvb.tv_usec);
stats->processed_requests++;
stats->acc_req_time += diff;
DBG("successfully ran routing scripts...(%d usec)\n", diff);
STATS_RX_REQUEST( msg->first_line.u.request.method_value );
#endif
/* execute post request-script callbacks */
exec_post_script_cb(msg, REQUEST_CB_TYPE);
}else if (msg->first_line.type==SIP_REPLY){
/* sanity checks */
if ((msg->via1==0) || (msg->via1->error!=PARSE_OK)){
/* no via, send back error ? */
LOG(L_ERR, "ERROR: receive_msg: no via found in reply\n");
STATS_BAD_RPL();
goto error02;
}
#ifdef STATS
gettimeofday( & tvb, &tz );
STATS_RX_RESPONSE ( msg->first_line.u.reply.statuscode / 100 );
#endif
/* execute pre-script callbacks, if any; -jiri */
/* if some of the callbacks said not to continue with
script processing, don't do so
if we are here basic sanity checks are already done
(like presence of at least one via), so you can count
on via1 being parsed in a pre-script callback --andrei
*/
if (exec_pre_script_cb(msg, ONREPLY_CB_TYPE)==0 )
{
STATS_RPL_FWD_DROP();
goto end; /* drop the reply */
}
/* exec the onreply routing script */
if (onreply_rt.rlist[DEFAULT_RT]){
set_route_type(CORE_ONREPLY_ROUTE);
ret=run_top_route(onreply_rt.rlist[DEFAULT_RT], msg, &ctx);
#ifndef NO_ONREPLY_ROUTE_ERROR
if (unlikely(ret<0)){
LOG(L_WARN, "WARNING: receive_msg: "
"error while trying onreply script\n");
goto error_rpl;
}else
#endif /* NO_ONREPLY_ROUTE_ERROR */
if (unlikely(ret==0 || (ctx.run_flags&DROP_R_F))){
STATS_RPL_FWD_DROP();
goto skip_send_reply; /* drop the message, no error */
}
}
/* send the msg */
forward_reply(msg);
skip_send_reply:
#ifdef STATS
gettimeofday( & tve, &tz );
diff = (tve.tv_sec-tvb.tv_sec)*1000000+(tve.tv_usec-tvb.tv_usec);
stats->processed_responses++;
stats->acc_res_time+=diff;
DBG("successfully ran reply processing...(%d usec)\n", diff);
#endif
/* execute post reply-script callbacks */
exec_post_script_cb(msg, ONREPLY_CB_TYPE);
}
end:
#ifdef STATS
skipped = 0;
#endif
/* free possible loaded avps -bogdan */
reset_avps();
#ifdef WITH_XAVP
xavp_reset_list();
#endif
DBG("receive_msg: cleaning up\n");
free_sip_msg(msg);
pkg_free(msg);
#ifdef STATS
if (skipped) STATS_RX_DROPS;
#endif
return 0;
#ifndef NO_ONREPLY_ROUTE_ERROR
error_rpl:
/* execute post reply-script callbacks */
exec_post_script_cb(msg, ONREPLY_CB_TYPE);
reset_avps();
#ifdef WITH_XAVP
xavp_reset_list();
#endif
goto error02;
#endif /* NO_ONREPLY_ROUTE_ERROR */
error_req:
DBG("receive_msg: error:...\n");
/* execute post request-script callbacks */
exec_post_script_cb(msg, REQUEST_CB_TYPE);
error03:
/* free possible loaded avps -bogdan */
reset_avps();
#ifdef WITH_XAVP
xavp_reset_list();
#endif
error02:
free_sip_msg(msg);
pkg_free(msg);
error00:
STATS_RX_DROPS;
return -1;
}
/*!
* \brief Timer function that removes expired dialogs, run timeout route
* \param tl dialog timer list
*/
void dlg_ontimeout(struct dlg_tl *tl)
{
dlg_cell_t *dlg;
int new_state, old_state, unref;
sip_msg_t *fmsg;
void* timeout_cb = 0;
/* get the dialog tl payload */
dlg = ((struct dlg_cell*)((char *)(tl) -
(unsigned long)(&((struct dlg_cell*)0)->tl)));
/* mark dialog as expired */
dlg->dflags |= DLG_FLAG_EXPIRED;
if(dlg->state==DLG_STATE_CONFIRMED_NA
|| dlg->state==DLG_STATE_CONFIRMED)
{
if(dlg->toroute>0 && dlg->toroute<main_rt.entries
&& main_rt.rlist[dlg->toroute]!=NULL)
{
fmsg = faked_msg_next();
if (exec_pre_script_cb(fmsg, REQUEST_CB_TYPE)>0)
{
dlg_ref(dlg, 1);
dlg_set_ctx_iuid(dlg);
LM_DBG("executing route %d on timeout\n", dlg->toroute);
set_route_type(REQUEST_ROUTE);
run_top_route(main_rt.rlist[dlg->toroute], fmsg, 0);
dlg_reset_ctx_iuid();
exec_post_script_cb(fmsg, REQUEST_CB_TYPE);
dlg_unref(dlg, 1);
}
}
if(dlg->iflags&DLG_IFLAG_TIMEOUTBYE)
{
/* set the dialog context so that it's available in
* tm:local-request event route */
dlg_set_ctx_iuid(dlg);
if(dlg_bye_all(dlg, NULL)<0)
dlg_unref(dlg, 1);
dlg_reset_ctx_iuid();
dlg_unref(dlg, 1);
if_update_stat(dlg_enable_stats, expired_dlgs, 1);
return;
}
}
next_state_dlg( dlg, DLG_EVENT_REQBYE, &old_state, &new_state, &unref);
/* used for computing duration for timed out acknowledged dialog */
if (DLG_STATE_CONFIRMED == old_state) {
timeout_cb = (void *)CONFIRMED_DIALOG_STATE;
}
dlg_run_event_route(dlg, NULL, old_state, new_state);
if (new_state==DLG_STATE_DELETED && old_state!=DLG_STATE_DELETED) {
LM_WARN("timeout for dlg with CallID '%.*s' and tags '%.*s' '%.*s'\n",
dlg->callid.len, dlg->callid.s,
dlg->tag[DLG_CALLER_LEG].len, dlg->tag[DLG_CALLER_LEG].s,
dlg->tag[DLG_CALLEE_LEG].len, dlg->tag[DLG_CALLEE_LEG].s);
/* dialog timeout */
run_dlg_callbacks( DLGCB_EXPIRED, dlg, NULL, NULL, DLG_DIR_NONE, timeout_cb);
dlg_unref(dlg, unref+1);
if_update_stat( dlg_enable_stats, expired_dlgs, 1);
if_update_stat( dlg_enable_stats, active_dlgs, -1);
} else {
dlg_unref(dlg, 1);
}
return;
}
/* Continues the SIP request processing previously saved by
* t_suspend(). The script does not continue from the same
* point, but a separate route block is executed instead.
*
* Return value:
* 0 - success
* <0 - failure
*/
int t_continue(unsigned int hash_index, unsigned int label,
struct action *route)
{
struct cell *t;
struct sip_msg faked_req;
struct cancel_info cancel_data;
int branch;
struct ua_client *uac =NULL;
int ret;
int cb_type;
int msg_status;
int last_uac_status;
int reply_status;
int do_put_on_wait;
struct hdr_field *hdr, *prev = 0, *tmp = 0;
if (t_lookup_ident(&t, hash_index, label) < 0) {
LM_ERR("transaction not found\n");
return -1;
}
if (!(t->flags & T_ASYNC_SUSPENDED)) {
LM_WARN("transaction is not suspended [%u:%u]\n", hash_index, label);
return -2;
}
if (t->flags & T_CANCELED) {
t->flags &= ~T_ASYNC_SUSPENDED;
/* The transaction has already been canceled,
* needless to continue */
UNREF(t); /* t_unref would kill the transaction */
/* reset T as we have no working T anymore */
set_t(T_UNDEFINED, T_BR_UNDEFINED);
return 1;
}
/* The transaction has to be locked to protect it
* form calling t_continue() multiple times simultaneously */
LOCK_ASYNC_CONTINUE(t);
t->flags |= T_ASYNC_CONTINUE; /* we can now know anywhere in kamailio
* that we are executing post a suspend */
/* which route block type were we in when we were suspended */
cb_type = FAILURE_CB_TYPE;;
switch (t->async_backup.backup_route) {
case REQUEST_ROUTE:
cb_type = FAILURE_CB_TYPE;
break;
case FAILURE_ROUTE:
cb_type = FAILURE_CB_TYPE;
break;
case TM_ONREPLY_ROUTE:
cb_type = ONREPLY_CB_TYPE;
break;
case BRANCH_ROUTE:
cb_type = FAILURE_CB_TYPE;
break;
}
if(t->async_backup.backup_route != TM_ONREPLY_ROUTE){
branch = t->async_backup.blind_uac; /* get the branch of the blind UAC setup
* during suspend */
if (branch >= 0) {
stop_rb_timers(&t->uac[branch].request);
if (t->uac[branch].last_received != 0) {
/* Either t_continue() has already been
* called or the branch has already timed out.
* Needless to continue. */
t->flags &= ~T_ASYNC_SUSPENDED;
UNLOCK_ASYNC_CONTINUE(t);
UNREF(t); /* t_unref would kill the transaction */
return 1;
}
/* Set last_received to something >= 200,
* the actual value does not matter, the branch
* will never be picked up for response forwarding.
* If last_received is lower than 200,
* then the branch may tried to be cancelled later,
* for example when t_reply() is called from
* a failure route => deadlock, because both
* of them need the reply lock to be held. */
t->uac[branch].last_received=500;
uac = &t->uac[branch];
}
/* else
Not a huge problem, fr timer will fire, but CANCEL
will not be sent. last_received will be set to 408. */
/* We should not reset kr here to 0 as it's quite possible before continuing the dev. has correctly set the
* kr by, for example, sending a transactional reply in code - resetting here will cause a dirty log message
* "WARNING: script writer didn't release transaction" to appear in log files. TODO: maybe we need to add
* a special kr for async?
* reset_kr();
*/
/* fake the request and the environment, like in failure_route */
if (!fake_req(&faked_req, t->uas.request, 0 /* extra flags */, uac)) {
LM_ERR("building fake_req failed\n");
ret = -1;
goto kill_trans;
}
faked_env( t, &faked_req, 1);
/* execute the pre/post -script callbacks based on original route block */
if (exec_pre_script_cb(&faked_req, cb_type)>0) {
if (run_top_route(route, &faked_req, 0)<0)
LM_ERR("failure inside run_top_route\n");
exec_post_script_cb(&faked_req, cb_type);
}
/* TODO: save_msg_lumps should clone the lumps to shm mem */
/* restore original environment and free the fake msg */
faked_env( t, 0, 1);
free_faked_req(&faked_req, t);
/* update the flags */
t->uas.request->flags = faked_req.flags;
if (t->uas.status < 200) {
/* No final reply has been sent yet.
* Check whether or not there is any pending branch.
*/
for ( branch = 0;
branch < t->nr_of_outgoings;
branch++
) {
if (t->uac[branch].last_received < 200)
break;
}
if (branch == t->nr_of_outgoings) {
/* There is not any open branch so there is
* no chance that a final response will be received. */
ret = 0;
goto kill_trans;
}
}
} else {
branch = t->async_backup.backup_branch;
init_cancel_info(&cancel_data);
LM_DBG("continuing from a suspended reply"
" - resetting the suspend branch flag\n");
if (t->uac[branch].reply) {
t->uac[branch].reply->msg_flags &= ~FL_RPL_SUSPENDED;
} else {
LM_WARN("no reply in t_continue for branch. not much we can do\n");
return 0;
}
if (t->uas.request) t->uas.request->msg_flags&= ~FL_RPL_SUSPENDED;
faked_env( t, t->uac[branch].reply, 1);
if (exec_pre_script_cb(t->uac[branch].reply, cb_type)>0) {
if (run_top_route(route, t->uac[branch].reply, 0)<0){
LOG(L_ERR, "ERROR: t_continue_reply: Error in run_top_route\n");
}
exec_post_script_cb(t->uac[branch].reply, cb_type);
}
LM_DBG("restoring previous environment");
faked_env( t, 0, 1);
/*lock transaction replies - will be unlocked when reply is relayed*/
LOCK_REPLIES( t );
if ( is_local(t) ) {
LM_DBG("t is local - sending reply with status code: [%d]\n",
t->uac[branch].reply->first_line.u.reply.statuscode);
reply_status = local_reply( t, t->uac[branch].reply, branch,
t->uac[branch].reply->first_line.u.reply.statuscode,
&cancel_data );
if (reply_status == RPS_COMPLETED) {
/* no more UAC FR/RETR (if I received a 2xx, there may
* be still pending branches ...
*/
cleanup_uac_timers( t );
if (is_invite(t)) cancel_uacs(t, &cancel_data, F_CANCEL_B_KILL);
/* There is no need to call set_final_timer because we know
* that the transaction is local */
put_on_wait(t);
}else if (unlikely(cancel_data.cancel_bitmap)){
/* cancel everything, even non-INVITEs (e.g in case of 6xx), use
* cancel_b_method for canceling unreplied branches */
cancel_uacs(t, &cancel_data, cfg_get(tm,tm_cfg, cancel_b_flags));
}
} else {
LM_DBG("t is not local - relaying reply with status code: [%d]\n",
t->uac[branch].reply->first_line.u.reply.statuscode);
do_put_on_wait = 0;
if(t->uac[branch].reply->first_line.u.reply.statuscode>=200){
do_put_on_wait = 1;
}
reply_status=relay_reply( t, t->uac[branch].reply, branch,
t->uac[branch].reply->first_line.u.reply.statuscode,
&cancel_data, do_put_on_wait );
if (reply_status == RPS_COMPLETED) {
/* no more UAC FR/RETR (if I received a 2xx, there may
be still pending branches ...
*/
cleanup_uac_timers( t );
/* 2xx is a special case: we can have a COMPLETED request
* with branches still open => we have to cancel them */
if (is_invite(t) && cancel_data.cancel_bitmap)
cancel_uacs( t, &cancel_data, F_CANCEL_B_KILL);
/* FR for negative INVITES, WAIT anything else */
/* Call to set_final_timer is embedded in relay_reply to avoid
* race conditions when reply is sent out and an ACK to stop
* retransmissions comes before retransmission timer is set.*/
}else if (unlikely(cancel_data.cancel_bitmap)){
/* cancel everything, even non-INVITEs (e.g in case of 6xx), use
* cancel_b_method for canceling unreplied branches */
cancel_uacs(t, &cancel_data, cfg_get(tm,tm_cfg, cancel_b_flags));
}
}
t->uac[branch].request.flags|=F_RB_REPLIED;
if (reply_status==RPS_ERROR){
goto done;
}
/* update FR/RETR timers on provisional replies */
msg_status=t->uac[branch].reply->REPLY_STATUS;
last_uac_status=t->uac[branch].last_received;
if (is_invite(t) && msg_status<200 &&
( cfg_get(tm, tm_cfg, restart_fr_on_each_reply) ||
( (last_uac_status<msg_status) &&
((msg_status>=180) || (last_uac_status==0)) )
) ) { /* provisional now */
restart_rb_fr(& t->uac[branch].request, t->fr_inv_timeout);
t->uac[branch].request.flags|=F_RB_FR_INV; /* mark fr_inv */
}
}
done:
UNLOCK_ASYNC_CONTINUE(t);
if(t->async_backup.backup_route != TM_ONREPLY_ROUTE){
/* unref the transaction */
t_unref(t->uas.request);
} else {
tm_ctx_set_branch_index(T_BR_UNDEFINED);
/* unref the transaction */
t_unref(t->uac[branch].reply);
LOG(L_DBG,"DEBUG: t_continue_reply: Freeing earlier cloned reply\n");
/* free lumps that were added during reply processing */
del_nonshm_lump( &(t->uac[branch].reply->add_rm) );
del_nonshm_lump( &(t->uac[branch].reply->body_lumps) );
del_nonshm_lump_rpl( &(t->uac[branch].reply->reply_lump) );
/* free header's parsed structures that were added */
for( hdr=t->uac[branch].reply->headers ; hdr ; hdr=hdr->next ) {
if ( hdr->parsed && hdr_allocs_parse(hdr) &&
(hdr->parsed<(void*)t->uac[branch].reply ||
hdr->parsed>=(void*)t->uac[branch].end_reply)) {
clean_hdr_field(hdr);
hdr->parsed = 0;
}
}
/* now go through hdr_fields themselves and remove the pkg allocated space */
hdr = t->uac[branch].reply->headers;
while (hdr) {
if ( hdr && ((void*)hdr<(void*)t->uac[branch].reply ||
(void*)hdr>=(void*)t->uac[branch].end_reply)) {
//this header needs to be freed and removed form the list.
if (!prev) {
t->uac[branch].reply->headers = hdr->next;
} else {
prev->next = hdr->next;
}
tmp = hdr;
hdr = hdr->next;
pkg_free(tmp);
} else {
prev = hdr;
hdr = hdr->next;
}
}
sip_msg_free(t->uac[branch].reply);
t->uac[branch].reply = 0;
}
/*This transaction is no longer suspended so unsetting the SUSPEND flag*/
t->flags &= ~T_ASYNC_SUSPENDED;
return 0;
kill_trans:
t->flags &= ~T_ASYNC_SUSPENDED;
/* The script has hopefully set the error code. If not,
* let us reply with a default error. */
if ((kill_transaction_unsafe(t,
tm_error ? tm_error : E_UNSPEC)) <=0
) {
LOG(L_ERR, "ERROR: t_continue: "
"reply generation failed\n");
/* The transaction must be explicitely released,
* no more timer is running */
UNLOCK_ASYNC_CONTINUE(t);
t_release_transaction(t);
} else {
UNLOCK_ASYNC_CONTINUE(t);
}
if(t->async_backup.backup_route != TM_ONREPLY_ROUTE){
t_unref(t->uas.request);
} else {
/* unref the transaction */
t_unref(t->uac[branch].reply);
}
return ret;
}
/** Receive message
* WARNING: buf must be 0 terminated (buf[len]=0) or some things might
* break (e.g.: modules/textops)
*/
int receive_msg(char* buf, unsigned int len, struct receive_info* rcv_info)
{
struct sip_msg* msg;
struct run_act_ctx ctx;
struct run_act_ctx *bctx;
int ret;
#ifdef STATS
int skipped = 1;
int stats_on = 1;
#else
int stats_on = 0;
#endif
struct timeval tvb, tve;
struct timezone tz;
unsigned int diff = 0;
str inb;
sr_net_info_t netinfo;
sr_kemi_eng_t *keng = NULL;
if(sr_event_enabled(SREV_NET_DATA_RECV)) {
if(sip_check_fline(buf, len)==0) {
memset(&netinfo, 0, sizeof(sr_net_info_t));
netinfo.data.s = buf;
netinfo.data.len = len;
netinfo.rcv = rcv_info;
sr_event_exec(SREV_NET_DATA_RECV, (void*)&netinfo);
}
}
inb.s = buf;
inb.len = len;
sr_event_exec(SREV_NET_DATA_IN, (void*)&inb);
len = inb.len;
msg=pkg_malloc(sizeof(struct sip_msg));
if (msg==0) {
LM_ERR("no mem for sip_msg\n");
goto error00;
}
msg_no++;
/* number of vias parsed -- good for diagnostic info in replies */
via_cnt=0;
memset(msg,0, sizeof(struct sip_msg)); /* init everything to 0 */
/* fill in msg */
msg->buf=buf;
msg->len=len;
/* zero termination (termination of orig message bellow not that
* useful as most of the work is done with scratch-pad; -jiri */
/* buf[len]=0; */ /* WARNING: zero term removed! */
msg->rcv=*rcv_info;
msg->id=msg_no;
msg->pid=my_pid();
msg->set_global_address=default_global_address;
msg->set_global_port=default_global_port;
if(likely(sr_msg_time==1)) msg_set_time(msg);
if (parse_msg(buf,len, msg)!=0){
if((ret=sr_event_exec(SREV_RCV_NOSIP, (void*)msg))<NONSIP_MSG_DROP) {
LOG(cfg_get(core, core_cfg, corelog),
"core parsing of SIP message failed (%s:%d/%d)\n",
ip_addr2a(&msg->rcv.src_ip), (int)msg->rcv.src_port,
(int)msg->rcv.proto);
sr_core_ert_run(msg, SR_CORE_ERT_RECEIVE_PARSE_ERROR);
}
else if(ret == NONSIP_MSG_DROP) goto error02;
}
parse_headers(msg, HDR_FROM_F|HDR_TO_F|HDR_CALLID_F|HDR_CSEQ_F, 0);
LM_DBG("--- received sip message - %s - call-id: [%.*s] - cseq: [%.*s]\n",
(msg->first_line.type==SIP_REQUEST)?"request":"reply",
(msg->callid && msg->callid->body.s)?msg->callid->body.len:0,
(msg->callid && msg->callid->body.s)?msg->callid->body.s:"",
(msg->cseq && msg->cseq->body.s)?msg->cseq->body.len:0,
(msg->cseq && msg->cseq->body.s)?msg->cseq->body.s:"");
/* set log prefix */
log_prefix_set(msg);
/* ... clear branches from previous message */
clear_branches();
if (msg->first_line.type==SIP_REQUEST){
ruri_mark_new(); /* ruri is usable for forking (not consumed yet) */
if (!IS_SIP(msg)){
if ((ret=nonsip_msg_run_hooks(msg))!=NONSIP_MSG_ACCEPT){
if (unlikely(ret==NONSIP_MSG_ERROR))
goto error03;
goto end; /* drop the message */
}
}
/* sanity checks */
if ((msg->via1==0) || (msg->via1->error!=PARSE_OK)){
/* no via, send back error ? */
LM_ERR("no via found in request\n");
STATS_BAD_MSG();
goto error02;
}
/* check if necessary to add receive?->moved to forward_req */
/* check for the alias stuff */
#ifdef USE_TCP
if (msg->via1->alias && cfg_get(tcp, tcp_cfg, accept_aliases) &&
(((rcv_info->proto==PROTO_TCP) && !tcp_disable)
#ifdef USE_TLS
|| ((rcv_info->proto==PROTO_TLS) && !tls_disable)
#endif
)
){
if (tcpconn_add_alias(rcv_info->proto_reserved1, msg->via1->port,
rcv_info->proto)!=0){
LM_ERR("tcp alias failed\n");
/* continue */
}
}
#endif
/* skip: */
LM_DBG("preparing to run routing scripts...\n");
if(is_printable(cfg_get(core, core_cfg, latency_cfg_log))
|| stats_on==1) {
gettimeofday( & tvb, &tz );
}
/* execute pre-script callbacks, if any; -jiri */
/* if some of the callbacks said not to continue with
* script processing, don't do so
* if we are here basic sanity checks are already done
* (like presence of at least one via), so you can count
* on via1 being parsed in a pre-script callback --andrei
*/
if (exec_pre_script_cb(msg, REQUEST_CB_TYPE)==0 )
{
STATS_REQ_FWD_DROP();
goto end; /* drop the request */
}
set_route_type(REQUEST_ROUTE);
/* exec the routing script */
if(unlikely(main_rt.rlist[DEFAULT_RT]==NULL)) {
keng = sr_kemi_eng_get();
if(keng==NULL) {
LM_ERR("no config routing engine registered\n");
goto error_req;
}
if(keng->froute(msg, REQUEST_ROUTE, NULL, NULL)<0) {
LM_NOTICE("negative return code from engine function\n");
}
} else {
if (run_top_route(main_rt.rlist[DEFAULT_RT], msg, 0)<0){
LM_WARN("error while trying script\n");
goto error_req;
}
}
if(is_printable(cfg_get(core, core_cfg, latency_cfg_log))
|| stats_on==1) {
gettimeofday( & tve, &tz );
diff = (tve.tv_sec-tvb.tv_sec)*1000000+(tve.tv_usec-tvb.tv_usec);
LOG(cfg_get(core, core_cfg, latency_cfg_log),
"request-route executed in: %d usec\n", diff);
#ifdef STATS
stats->processed_requests++;
stats->acc_req_time += diff;
STATS_RX_REQUEST( msg->first_line.u.request.method_value );
#endif
}
/* execute post request-script callbacks */
exec_post_script_cb(msg, REQUEST_CB_TYPE);
}else if (msg->first_line.type==SIP_REPLY){
/* sanity checks */
if ((msg->via1==0) || (msg->via1->error!=PARSE_OK)){
/* no via, send back error ? */
LM_ERR("no via found in reply\n");
STATS_BAD_RPL();
goto error02;
}
if(is_printable(cfg_get(core, core_cfg, latency_cfg_log))
|| stats_on==1) {
gettimeofday( & tvb, &tz );
}
#ifdef STATS
STATS_RX_RESPONSE ( msg->first_line.u.reply.statuscode / 100 );
#endif
/* execute pre-script callbacks, if any; -jiri */
/* if some of the callbacks said not to continue with
* script processing, don't do so
* if we are here basic sanity checks are already done
* (like presence of at least one via), so you can count
* on via1 being parsed in a pre-script callback --andrei
*/
if (exec_pre_script_cb(msg, ONREPLY_CB_TYPE)==0 )
{
STATS_RPL_FWD_DROP();
goto end; /* drop the reply */
}
/* exec the onreply routing script */
keng = sr_kemi_eng_get();
if (onreply_rt.rlist[DEFAULT_RT]!=NULL || keng!=NULL){
set_route_type(CORE_ONREPLY_ROUTE);
ret = 1;
if(unlikely(keng!=NULL)) {
bctx = sr_kemi_act_ctx_get();
init_run_actions_ctx(&ctx);
sr_kemi_act_ctx_set(&ctx);
ret = keng->froute(msg, CORE_ONREPLY_ROUTE, NULL, NULL);
sr_kemi_act_ctx_set(bctx);
} else {
ret=run_top_route(onreply_rt.rlist[DEFAULT_RT], msg, &ctx);
}
#ifndef NO_ONREPLY_ROUTE_ERROR
if (unlikely(ret<0)){
LM_WARN("error while trying onreply script\n");
goto error_rpl;
}else
#endif /* NO_ONREPLY_ROUTE_ERROR */
if (unlikely(ret==0 || (ctx.run_flags&DROP_R_F))){
STATS_RPL_FWD_DROP();
goto skip_send_reply; /* drop the message, no error */
}
}
/* send the msg */
forward_reply(msg);
skip_send_reply:
if(is_printable(cfg_get(core, core_cfg, latency_cfg_log))
|| stats_on==1) {
gettimeofday( & tve, &tz );
diff = (tve.tv_sec-tvb.tv_sec)*1000000+(tve.tv_usec-tvb.tv_usec);
LOG(cfg_get(core, core_cfg, latency_cfg_log),
"reply-route executed in: %d usec\n", diff);
#ifdef STATS
stats->processed_responses++;
stats->acc_res_time+=diff;
#endif
}
/* execute post reply-script callbacks */
exec_post_script_cb(msg, ONREPLY_CB_TYPE);
}
end:
#ifdef STATS
skipped = 0;
#endif
/* free possible loaded avps -bogdan */
reset_avps();
#ifdef WITH_XAVP
xavp_reset_list();
#endif
LM_DBG("cleaning up\n");
free_sip_msg(msg);
pkg_free(msg);
#ifdef STATS
if (skipped) STATS_RX_DROPS;
#endif
/* reset log prefix */
log_prefix_set(NULL);
return 0;
#ifndef NO_ONREPLY_ROUTE_ERROR
error_rpl:
/* execute post reply-script callbacks */
exec_post_script_cb(msg, ONREPLY_CB_TYPE);
reset_avps();
#ifdef WITH_XAVP
xavp_reset_list();
#endif
goto error02;
#endif /* NO_ONREPLY_ROUTE_ERROR */
error_req:
LM_DBG("error:...\n");
/* execute post request-script callbacks */
exec_post_script_cb(msg, REQUEST_CB_TYPE);
error03:
/* free possible loaded avps -bogdan */
reset_avps();
#ifdef WITH_XAVP
xavp_reset_list();
#endif
error02:
free_sip_msg(msg);
pkg_free(msg);
error00:
STATS_RX_DROPS;
/* reset log prefix */
log_prefix_set(NULL);
return -1;
}
/*!
* \brief Timer function that removes expired dialogs, run timeout route
* \param tl dialog timer list
*/
void dlg_ontimeout(struct dlg_tl *tl)
{
dlg_cell_t *dlg;
int new_state, old_state, unref;
sip_msg_t *fmsg;
/* get the dialog tl payload */
dlg = ((struct dlg_cell*)((char *)(tl) -
(unsigned long)(&((struct dlg_cell*)0)->tl)));
if(dlg->state==DLG_STATE_CONFIRMED_NA
|| dlg->state==DLG_STATE_CONFIRMED)
{
if(dlg->toroute>0 && dlg->toroute<main_rt.entries
&& main_rt.rlist[dlg->toroute]!=NULL)
{
fmsg = faked_msg_next();
if (exec_pre_script_cb(fmsg, REQUEST_CB_TYPE)>0)
{
dlg_ref(dlg, 1);
dlg_set_ctx_iuid(dlg);
LM_DBG("executing route %d on timeout\n", dlg->toroute);
set_route_type(REQUEST_ROUTE);
run_top_route(main_rt.rlist[dlg->toroute], fmsg, 0);
dlg_reset_ctx_iuid();
exec_post_script_cb(fmsg, REQUEST_CB_TYPE);
dlg_unref(dlg, 1);
}
}
if(dlg->iflags&DLG_IFLAG_TIMEOUTBYE)
{
dlg_bye_all(dlg, NULL);
/* run event route for end of dlg */
dlg_run_event_route(dlg, NULL, dlg->state, DLG_STATE_DELETED);
dlg_unref(dlg, 1);
if_update_stat(dlg_enable_stats, expired_dlgs, 1);
return;
}
}
next_state_dlg( dlg, DLG_EVENT_REQBYE, &old_state, &new_state, &unref);
dlg_run_event_route(dlg, NULL, old_state, new_state);
if (new_state==DLG_STATE_DELETED && old_state!=DLG_STATE_DELETED) {
LM_WARN("timeout for dlg with CallID '%.*s' and tags '%.*s' '%.*s'\n",
dlg->callid.len, dlg->callid.s,
dlg->tag[DLG_CALLER_LEG].len, dlg->tag[DLG_CALLER_LEG].s,
dlg->tag[DLG_CALLEE_LEG].len, dlg->tag[DLG_CALLEE_LEG].s);
/* dialog timeout */
run_dlg_callbacks( DLGCB_EXPIRED, dlg, NULL, NULL, DLG_DIR_NONE, 0);
dlg_unref(dlg, unref+1);
if_update_stat( dlg_enable_stats, expired_dlgs, 1);
if_update_stat( dlg_enable_stats, active_dlgs, -1);
} else {
dlg_unref(dlg, 1);
}
return;
}
static ticks_t timer_handler(ticks_t ticks, struct timer_ln* tl, void* data) {
/*?min length of first line of message is 16 char!?*/
#define MSG "GET /timer HTTP/0.9\n\n"
struct sip_msg* msg;
struct timer_action *a;
struct run_act_ctx ra_ctx;
a = data;
if (!a->disable_itself) {
DEBUG(MODULE_NAME": handler: called at %d ticks, timer: '%s', pid:%d\n", ticks, a->timer_name, getpid());
if (a->route_no >= main_rt.idx) {
BUG(MODULE_NAME": invalid routing table number #%d of %d\n", a->route_no, main_rt.idx);
goto err2;
}
if (!main_rt.rlist[a->route_no]) {
WARN(MODULE_NAME": route not declared (hash:%d)\n", a->route_no);
goto err2;
}
msg=pkg_malloc(sizeof(struct sip_msg));
if (msg==0) {
ERR(MODULE_NAME": handler: no mem for sip_msg\n");
goto err2;
}
timer_msg_no++;
memset(msg, 0, sizeof(struct sip_msg)); /* init everything to 0 */
msg->buf=MSG;
msg->len=sizeof(MSG)-1;
msg->rcv= rcv_info;
msg->id=timer_msg_no;
msg->set_global_address=default_global_address;
msg->set_global_port=default_global_port;
if (parse_msg(msg->buf, msg->len, msg)!=0){
ERR(MODULE_NAME": handler: parse_msg failed\n");
goto err;
}
/* ... clear branches from previous message */
clear_branches();
reset_static_buffer();
if (exec_pre_script_cb(msg, REQUEST_CB_TYPE)==0 )
goto end; /* drop the request */
/* exec the routing script */
timer_executed = a;
init_run_actions_ctx(&ra_ctx);
run_actions(&ra_ctx, main_rt.rlist[a->route_no], msg);
timer_executed = 0;
/* execute post request-script callbacks */
exec_post_script_cb(msg, REQUEST_CB_TYPE);
end:
reset_avps();
DEBUG(MODULE_NAME": handler: cleaning up\n");
err:
free_sip_msg(msg);
pkg_free(msg);
err2: ;
}
/* begin critical section */
if (a->disable_itself) {
timer_allow_del();
timer_del(a->link);
timer_reinit(a->link);
a->disable_itself = 0;
/* end critical section */
return 0; /* do no call more */
}
else
return (ticks_t)(-1); /* periodical */
}
