static void log_missed(struct cell* t, struct sip_msg* reply, unsigned int code, time_t req_time)
{
str* ouri;
if (t->relayed_reply_branch >= 0) {
ouri = &t->uac[t->relayed_reply_branch].uri;
} else {
ouri = GET_NEXT_HOP(t->uas.request);
}
log_request(t->uas.request, ouri, valid_to(t, reply), mc_table.s, code, req_time);
}
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int flags)
{
int ret;
int new_tran;
int reply_ret;
struct cell *t;
ret=0;
new_tran = t_newtran( p_msg, 1/*full UAS cloning*/ );
/* parsing error, memory alloc, whatever ... */
if (new_tran<0) {
ret = new_tran;
goto done;
}
/* if that was a retransmission, break from script */
if (new_tran==0) {
goto done;
}
/* new transaction */
/* ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
LM_DBG("forwarding ACK\n");
/* send it out */
if (proxy==0) {
proxy=uri2proxy(GET_NEXT_HOP(p_msg),
p_msg->force_send_socket ?
p_msg->force_send_socket->proto : PROTO_NONE );
if (proxy==0) {
ret=E_BAD_ADDRESS;
goto done;
}
ret=forward_request( p_msg , proxy);
if (ret>=0) ret=1;
free_proxy( proxy );
pkg_free( proxy );
} else {
ret=forward_request( p_msg , proxy);
if (ret>=0) ret=1;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relaied */
t=get_t();
if (flags&TM_T_RELAY_repl_FLAG) t->flags|=T_IS_LOCAL_FLAG;
if (flags&TM_T_RELAY_nodnsfo_FLAG) t->flags|=T_NO_DNS_FAILOVER_FLAG;
if (flags&TM_T_RELAY_reason_FLAG) t->flags|=T_CANCEL_REASON_FLAG;
if ((flags&TM_T_RELAY_do_cancel_dis_FLAG) &&
tm_has_request_disponsition_no_cancel(p_msg)==0 )
t->flags|=T_MULTI_200OK_FLAG;
/* now go ahead and forward ... */
ret=t_forward_nonack( t, p_msg, proxy, 0/*no reset*/, 0/*unlocked*/);
if (ret<=0) {
LM_DBG("t_forward_nonack returned error \n");
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (!(flags&(TM_T_RELAY_repl_FLAG|TM_T_RELAY_noerr_FLAG))) {
reply_ret = kill_transaction( t );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
LM_DBG("generation of a stateful reply on error succeeded\n");
ret=0;
} else {
LM_DBG("generation of a stateful reply on error failed\n");
}
}
} else {
LM_DBG("new transaction fwd'ed\n");
}
done:
return ret;
}
/* WARNING: doesn't work from failure route (deadlock, uses t_reply => tries
* to get the reply lock again */
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int proto,
int replicate)
{
int ret;
int new_tran;
/* struct hdr_field *hdr; */
struct cell *t;
struct dest_info dst;
unsigned short port;
str host;
short comp;
#ifndef TM_DELAYED_REPLY
int reply_ret;
#endif
ret=0;
/* special case for CANCEL */
if ( p_msg->REQ_METHOD==METHOD_CANCEL){
ret=t_forward_cancel(p_msg, proxy, proto, &t);
if (t) goto handle_ret;
goto done;
}
new_tran = t_newtran( p_msg );
/* parsing error, memory alloc, whatever ... if via is bad
and we are forced to reply there, return with 0 (->break),
pass error status otherwise
MMA: return value E_SCRIPT means that transaction was already started
from the script so continue with that transaction
*/
if (likely(new_tran!=E_SCRIPT)) {
if (new_tran<0) {
ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
goto done;
}
/* if that was a retransmission, return we are happily done */
if (new_tran==0) {
ret = 1;
goto done;
}
}else if (unlikely(p_msg->REQ_METHOD==METHOD_ACK)) {
/* transaction previously found (E_SCRIPT) and msg==ACK
=> ack to neg. reply or ack to local trans.
=> process it and exit */
/* FIXME: there's no way to distinguish here between acks to
local trans. and neg. acks */
/* in normal operation we should never reach this point, if we
do WARN(), it might hide some real bug (apart from possibly
hiding a bug the most harm done is calling the TMCB_ACK_NEG
callbacks twice) */
WARN("negative or local ACK caught, please report\n");
t=get_t();
if (unlikely(has_tran_tmcbs(t, TMCB_ACK_NEG_IN)))
run_trans_callbacks(TMCB_ACK_NEG_IN, t, p_msg, 0,
p_msg->REQ_METHOD);
t_release_transaction(t);
ret=1;
goto done;
}
/* new transaction */
/* at this point if the msg is an ACK it is an e2e ACK and
e2e ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
DBG( "SER: forwarding ACK statelessly \n");
if (proxy==0) {
init_dest_info(&dst);
dst.proto=proto;
if (get_uri_send_info(GET_NEXT_HOP(p_msg), &host, &port,
&dst.proto, &comp)!=0){
ret=E_BAD_ADDRESS;
goto done;
}
#ifdef USE_COMP
dst.comp=comp;
#endif
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request(p_msg, &host, port, &dst);
} else {
init_dest_info(&dst);
dst.proto=get_proto(proto, proxy->proto);
proxy2su(&dst.to, proxy);
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request( p_msg , 0, 0, &dst) ;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relayed */
t=get_t();
if (replicate) t->flags|=T_IS_LOCAL_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if (p_msg->REQ_METHOD==METHOD_INVITE && (t->flags&T_AUTO_INV_100)
&& (t->uas.status < 100)
) {
DBG( "SER: new INVITE\n");
if (!t_reply( t, p_msg , 100 ,
cfg_get(tm, tm_cfg, tm_auto_inv_100_r)))
DBG("SER: ERROR: t_reply (100)\n");
}
/* now go ahead and forward ... */
ret=t_forward_nonack(t, p_msg, proxy, proto);
handle_ret:
if (ret<=0) {
DBG( "t_forward_nonack returned error %d (%d)\n", ret, ser_error);
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (likely(!replicate)) {
if(t->flags&T_DISABLE_INTERNAL_REPLY) {
/* flag set to don't generate the internal negative reply
* - let the transaction live further, processing should
* continue in config */
DBG("not generating immediate reply for error %d\n", ser_error);
tm_error=ser_error;
ret = -4;
goto done;
}
#ifdef TM_DELAYED_REPLY
/* current error in tm_error */
tm_error=ser_error;
set_kr(REQ_ERR_DELAYED);
DBG("%d error reply generation delayed \n", ser_error);
#else
reply_ret=kill_transaction( t, ser_error );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
DBG("ERROR: generation of a stateful reply "
"on error succeeded\n");
/*ret=0; -- we don't want to stop the script */
} else {
DBG("ERROR: generation of a stateful reply "
"on error failed\n");
t_release_transaction(t);
}
#endif /* TM_DELAYED_REPLY */
}else{
t_release_transaction(t); /* kill it silently */
}
} else {
DBG( "SER: new transaction fwd'ed\n");
}
done:
return ret;
}
/* function returns:
* 1 - forward successful
* -1 - error during forward
*/
int t_forward_nonack( struct cell *t, struct sip_msg* p_msg ,
struct proxy_l * proxy, int proto)
{
str backup_uri;
int branch_ret, lowest_ret;
str current_uri;
branch_bm_t added_branches;
int first_branch;
int i, q;
struct cell *t_invite;
int success_branch;
int try_new;
str dst_uri;
/* make -Wall happy */
current_uri.s=0;
set_kr(REQ_FWDED);
if (p_msg->REQ_METHOD==METHOD_CANCEL) {
t_invite=t_lookupOriginalT( p_msg );
if (t_invite!=T_NULL_CELL) {
e2e_cancel( p_msg, t, t_invite );
UNREF(t_invite);
return 1;
}
}
/* backup current uri ... add_uac changes it */
backup_uri = p_msg->new_uri;
/* if no more specific error code is known, use this */
lowest_ret=E_BUG;
/* branches added */
added_branches=0;
/* branch to begin with */
first_branch=t->nr_of_outgoings;
/* on first-time forwarding, use current uri, later only what
is in additional branches (which may be continuously refilled
*/
if (first_branch==0) {
try_new=1;
branch_ret=add_uac( t, p_msg, GET_RURI(p_msg), GET_NEXT_HOP(p_msg), proxy, proto );
if (branch_ret>=0)
added_branches |= 1<<branch_ret;
else
lowest_ret=branch_ret;
} else try_new=0;
init_branch_iterator();
while((current_uri.s=next_branch( ¤t_uri.len, &q, &dst_uri.s, &dst_uri.len))) {
try_new++;
branch_ret=add_uac( t, p_msg, ¤t_uri,
(dst_uri.len) ? (&dst_uri) : ¤t_uri,
proxy, proto);
/* pick some of the errors in case things go wrong;
note that picking lowest error is just as good as
any other algorithm which picks any other negative
branch result */
if (branch_ret>=0)
added_branches |= 1<<branch_ret;
else
lowest_ret=branch_ret;
}
/* consume processed branches */
clear_branches();
/* restore original URI */
p_msg->new_uri=backup_uri;
/* don't forget to clear all branches processed so far */
/* things went wrong ... no new branch has been fwd-ed at all */
if (added_branches==0) {
if (try_new==0) {
LOG(L_ERR, "ERROR: t_forward_nonack: no branched for forwarding\n");
return -1;
}
LOG(L_ERR, "ERROR: t_forward_nonack: failure to add branches\n");
return lowest_ret;
}
/* send them out now */
success_branch=0;
for (i=first_branch; i<t->nr_of_outgoings; i++) {
if (added_branches & (1<<i)) {
if (SEND_BUFFER( &t->uac[i].request)==-1) {
LOG(L_ERR, "ERROR: t_forward_nonack: sending request failed\n");
if (proxy) {
proxy->errors++;
proxy->ok=0;
}
} else {
success_branch++;
}
start_retr( &t->uac[i].request );
}
}
if (success_branch<=0) {
ser_error=E_SEND;
return -1;
}
return 1;
}
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int flags)
{
int ret;
int new_tran;
int reply_ret;
struct cell *t;
context_p ctx_backup;
ret=0;
new_tran = t_newtran( p_msg, 1/*full UAS cloning*/ );
/* parsing error, memory alloc, whatever ... */
if (new_tran<0) {
ret = new_tran;
goto done;
}
/* if that was a retransmission, break from script */
if (new_tran==0) {
goto done;
}
/* new transaction */
/* ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
LM_DBG("forwarding ACK\n");
/* send it out */
if (proxy==0) {
proxy=uri2proxy(GET_NEXT_HOP(p_msg),
p_msg->force_send_socket ?
p_msg->force_send_socket->proto : PROTO_NONE );
if (proxy==0) {
ret=E_BAD_ADDRESS;
goto done;
}
ret=forward_request( p_msg , proxy);
if (ret>=0) ret=1;
free_proxy( proxy );
pkg_free( proxy );
} else {
ret=forward_request( p_msg , proxy);
if (ret>=0) ret=1;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relaied */
t=get_t();
if (flags&TM_T_REPLY_repl_FLAG) t->flags|=T_IS_LOCAL_FLAG;
if (flags&TM_T_REPLY_nodnsfo_FLAG) t->flags|=T_NO_DNS_FAILOVER_FLAG;
if (flags&TM_T_REPLY_reason_FLAG) t->flags|=T_CANCEL_REASON_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if ( p_msg->REQ_METHOD==METHOD_INVITE &&
!(flags&(TM_T_REPLY_no100_FLAG|TM_T_REPLY_repl_FLAG)) ) {
ctx_backup = current_processing_ctx;
current_processing_ctx = NULL;
t_reply( t, p_msg , 100 , &relay_reason_100);
current_processing_ctx = ctx_backup;
}
/* now go ahead and forward ... */
ret=t_forward_nonack( t, p_msg, proxy);
if (ret<=0) {
LM_DBG("t_forward_nonack returned error \n");
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (!(flags&(TM_T_REPLY_repl_FLAG|TM_T_REPLY_noerr_FLAG))) {
reply_ret = kill_transaction( t );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
LM_DBG("generation of a stateful reply on error succeeded\n");
ret=0;
} else {
LM_DBG("generation of a stateful reply on error failed\n");
}
}
} else {
LM_DBG("new transaction fwd'ed\n");
}
done:
return ret;
}
/* WARNING: doesn't work from failure route (deadlock, uses t_reply => tries
* to get the reply lock again */
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int proto,
int replicate)
{
int ret;
int new_tran;
int reply_ret;
/* struct hdr_field *hdr; */
struct cell *t;
struct dest_info dst;
unsigned short port;
str host;
short comp;
ret=0;
new_tran = t_newtran( p_msg );
/* parsing error, memory alloc, whatever ... if via is bad
and we are forced to reply there, return with 0 (->break),
pass error status otherwise
MMA: return value E_SCRIPT means that transaction was already started from the script
so continue with that transaction
*/
if (new_tran!=E_SCRIPT) {
if (new_tran<0) {
ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
goto done;
}
/* if that was a retransmission, return we are happily done */
if (new_tran==0) {
ret = 1;
goto done;
}
}
/* new transaction */
/* ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
DBG( "SER: forwarding ACK statelessly \n");
if (proxy==0) {
init_dest_info(&dst);
dst.proto=proto;
if (get_uri_send_info(GET_NEXT_HOP(p_msg), &host, &port,
&dst.proto, &comp)!=0){
ret=E_BAD_ADDRESS;
goto done;
}
#ifdef USE_COMP
dst.comp=comp;
#endif
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request(p_msg, &host, port, &dst);
} else {
init_dest_info(&dst);
dst.proto=get_proto(proto, proxy->proto);
proxy2su(&dst.to, proxy);
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request( p_msg , 0, 0, &dst) ;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relayed */
t=get_t();
if (replicate) t->flags|=T_IS_LOCAL_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if (p_msg->REQ_METHOD==METHOD_INVITE )
{
DBG( "SER: new INVITE\n");
if (!t_reply( t, p_msg , 100 ,
"trying -- your call is important to us"))
DBG("SER: ERROR: t_reply (100)\n");
}
/* now go ahead and forward ... */
ret=t_forward_nonack(t, p_msg, proxy, proto);
if (ret<=0) {
DBG( "ERROR:tm:t_relay_to: t_forward_nonack returned error \n");
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (!replicate) {
reply_ret=kill_transaction( t );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
DBG("ERROR: generation of a stateful reply "
"on error succeeded\n");
/*ret=0; -- we don't want to stop the script */
} else {
DBG("ERROR: generation of a stateful reply "
"on error failed\n");
t_release_transaction(t);
}
}else{
t_release_transaction(t); /* kill it silently */
}
} else {
DBG( "SER: new transaction fwd'ed\n");
}
done:
return ret;
}
static int xl_get_nexthop(struct sip_msg *msg, str *res, str *hp, int hi, int hf)
{
*res=*GET_NEXT_HOP(msg);
return 0;
}
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int proto,
int replicate)
{
int ret;
int new_tran;
str *uri;
int reply_ret;
/* struct hdr_field *hdr; */
struct cell *t;
ret=0;
new_tran = t_newtran( p_msg );
/* parsing error, memory alloc, whatever ... if via is bad
and we are forced to reply there, return with 0 (->break),
pass error status otherwise
*/
if (new_tran<0) {
ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
goto done;
}
/* if that was a retransmission, return we are happily done */
if (new_tran==0) {
ret = 1;
goto done;
}
/* new transaction */
/* ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
DBG("DEBUG:tm:t_relay: forwarding ACK statelessly \n");
if (proxy==0) {
uri = GET_RURI(p_msg);
proxy=uri2proxy(GET_NEXT_HOP(p_msg), proto);
if (proxy==0) {
ret=E_BAD_ADDRESS;
goto done;
}
proto=proxy->proto; /* uri2proxy set it correctly */
ret=forward_request( p_msg , proxy, proto) ;
free_proxy( proxy );
pkg_free( proxy );
} else {
proto=get_proto(proto, proxy->proto);
ret=forward_request( p_msg , proxy, proto ) ;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relaied */
t=get_t();
if (replicate) t->flags|=T_IS_LOCAL_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if (p_msg->REQ_METHOD==METHOD_INVITE )
{
DBG("DEBUG:tm:t_relay: new INVITE\n");
if (!t_reply( t, p_msg , 100 ,
"trying -- your call is important to us"))
DBG("SER: ERROR: t_reply (100)\n");
}
/* now go ahead and forward ... */
ret=t_forward_nonack(t, p_msg, proxy, proto);
if (ret<=0) {
DBG( "ERROR:tm:t_relay_to: t_forward_nonack returned error \n");
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (!replicate) {
reply_ret=kill_transaction( t );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
DBG("ERROR: generation of a stateful reply "
"on error succeeded\n");
ret=0;
} else {
DBG("ERROR: generation of a stateful reply "
"on error failed\n");
}
}
} else {
DBG( "SER: new transaction fwd'ed\n");
}
done:
return ret;
}
