int
mail_resize(struct mail *m, size_t size)
{
if (SIZE_MAX - m->off < size)
fatalx("size too large");
while (m->space <= (m->off + size)) {
if ((m->base = shm_resize(&m->shm, 2, m->space)) == NULL)
return (-1);
m->space *= 2;
}
m->data = m->base + m->off;
return (0);
}
static int _reply_light( struct cell *trans, char* buf, unsigned int len,
unsigned int code, char *to_tag, unsigned int to_tag_len,
int lock, struct bookmark *bm)
{
struct retr_buf *rb;
unsigned int buf_len;
branch_bm_t cancel_bitmap;
str cb_s;
if (!buf)
{
LM_DBG("response building failed\n");
/* determine if there are some branches to be canceled */
if ( is_invite(trans) ) {
if (lock) LOCK_REPLIES( trans );
which_cancel(trans, &cancel_bitmap );
if (lock) UNLOCK_REPLIES( trans );
}
/* and clean-up, including cancellations, if needed */
goto error;
}
cancel_bitmap=0;
if (lock) LOCK_REPLIES( trans );
if ( is_invite(trans) ) which_cancel(trans, &cancel_bitmap );
if (trans->uas.status>=200) {
LM_ERR("failed to generate %d reply when a final %d was sent out\n",
code, trans->uas.status);
goto error2;
}
rb = & trans->uas.response;
rb->activ_type=code;
trans->uas.status = code;
buf_len = rb->buffer.s ? len : len + REPLY_OVERBUFFER_LEN;
rb->buffer.s = (char*)shm_resize( rb->buffer.s, buf_len );
/* puts the reply's buffer to uas.response */
if (! rb->buffer.s ) {
LM_ERR("failed to allocate shmem buffer\n");
goto error3;
}
update_local_tags(trans, bm, rb->buffer.s, buf);
rb->buffer.len = len ;
memcpy( rb->buffer.s , buf , len );
/* needs to be protected too because what timers are set depends
on current transactions status */
/* t_update_timers_after_sending_reply( rb ); */
trans->relaied_reply_branch=-2;
if (lock) UNLOCK_REPLIES( trans );
/* do UAC cleanup procedures in case we generated
a final answer whereas there are pending UACs */
if (code>=200) {
if ( is_local(trans) ) {
LM_DBG("local transaction completed\n");
if ( has_tran_tmcbs(trans, TMCB_LOCAL_COMPLETED) ) {
run_trans_callbacks( TMCB_LOCAL_COMPLETED, trans,
0, FAKED_REPLY, code);
}
} else {
/* run the PRE send callbacks */
if ( has_tran_tmcbs(trans, TMCB_RESPONSE_PRE_OUT) ) {
cb_s.s = buf;
cb_s.len = len;
set_extra_tmcb_params( &cb_s, &rb->dst);
if (lock)
run_trans_callbacks_locked( TMCB_RESPONSE_PRE_OUT, trans,
trans->uas.request, FAKED_REPLY, code);
else
run_trans_callbacks( TMCB_RESPONSE_PRE_OUT, trans,
trans->uas.request, FAKED_REPLY, code);
}
}
if (!is_hopbyhop_cancel(trans)) {
cleanup_uac_timers( trans );
if (is_invite(trans)) cancel_uacs( trans, cancel_bitmap );
/* for auth related replies, we do not do retransmission
(via set_final_timer()), but only wait for a final
reply (put_on_wait() ) - see RFC 3261 (26.3.2.4 DoS Protection) */
if ((code != 401) && (code != 407))
set_final_timer( trans );
else
put_on_wait(trans);
}
}
/* send it out : response.dst.send_sock is valid all the time now,
* as it's taken from original request -bogdan */
if (!trans->uas.response.dst.send_sock) {
LM_CRIT("send_sock is NULL\n");
}
SEND_PR_BUFFER( rb, buf, len );
LM_DBG("reply sent out. buf=%p: %.9s..., "
"shmem=%p: %.9s\n", buf, buf, rb->buffer.s, rb->buffer.s );
/* run the POST send callbacks */
if (code>=200&&!is_local(trans)&&has_tran_tmcbs(trans,TMCB_RESPONSE_OUT)) {
cb_s.s = buf;
cb_s.len = len;
set_extra_tmcb_params( &cb_s, &rb->dst);
if (lock)
run_trans_callbacks_locked( TMCB_RESPONSE_OUT, trans,
trans->uas.request, FAKED_REPLY, code);
else
run_trans_callbacks( TMCB_RESPONSE_OUT, trans,
trans->uas.request, FAKED_REPLY, code);
}
pkg_free( buf ) ;
stats_trans_rpl( code, 1 /*local*/ );
LM_DBG("finished\n");
return 1;
error3:
error2:
if (lock) UNLOCK_REPLIES( trans );
pkg_free ( buf );
error:
/* do UAC cleanup */
cleanup_uac_timers( trans );
if ( is_invite(trans) ) cancel_uacs( trans, cancel_bitmap );
/* we did not succeed -- put the transaction on wait */
put_on_wait(trans);
return -1;
}
/* this is the code which decides what and when shall be relayed
upstream; note well -- it assumes it is entered locked with
REPLY_LOCK and it returns unlocked!
*/
enum rps relay_reply( struct cell *t, struct sip_msg *p_msg, int branch,
unsigned int msg_status, branch_bm_t *cancel_bitmap )
{
int relay;
int save_clone;
char *buf;
/* length of outbound reply */
unsigned int res_len;
int relayed_code;
struct sip_msg *relayed_msg;
struct bookmark bm;
int totag_retr;
enum rps reply_status;
/* retransmission structure of outbound reply and request */
struct retr_buf *uas_rb;
str cb_s;
str text;
/* keep compiler warnings about use of uninit vars silent */
res_len=0;
buf=0;
relayed_msg=0;
relayed_code=0;
totag_retr=0;
/* remember, what was sent upstream to know whether we are
* forwarding a first final reply or not */
/* *** store and relay message as needed *** */
reply_status = t_should_relay_response(t, msg_status, branch,
&save_clone, &relay, cancel_bitmap, p_msg );
LM_DBG("branch=%d, save=%d, relay=%d\n",
branch, save_clone, relay );
/* store the message if needed */
if (save_clone) /* save for later use, typically branch picking */
{
if (!store_reply( t, branch, p_msg ))
goto error01;
}
uas_rb = & t->uas.response;
if (relay >= 0 ) {
/* initialize sockets for outbound reply */
uas_rb->activ_type=msg_status;
t->relaied_reply_branch = relay;
/* try building the outbound reply from either the current
* or a stored message */
relayed_msg = branch==relay ? p_msg : t->uac[relay].reply;
if (relayed_msg==FAKED_REPLY) {
relayed_code = branch==relay
? msg_status : t->uac[relay].last_received;
text.s = error_text(relayed_code);
text.len = strlen(text.s); /* FIXME - bogdan*/
if (relayed_code>=180 && t->uas.request->to
&& (get_to(t->uas.request)->tag_value.s==0
|| get_to(t->uas.request)->tag_value.len==0)) {
calc_crc_suffix( t->uas.request, tm_tag_suffix );
buf = build_res_buf_from_sip_req(
relayed_code,
&text,
&tm_tag,
t->uas.request, &res_len, &bm );
} else {
buf = build_res_buf_from_sip_req( relayed_code,
&text, 0/* no to-tag */,
t->uas.request, &res_len, &bm );
}
} else {
/* run callbacks for all types of responses -
* even if they are shmem-ed or not */
if (has_tran_tmcbs(t,TMCB_RESPONSE_FWDED) ) {
run_trans_callbacks( TMCB_RESPONSE_FWDED, t, t->uas.request,
relayed_msg, msg_status );
}
relayed_code=relayed_msg->REPLY_STATUS;
buf = build_res_buf_from_sip_res( relayed_msg, &res_len,
uas_rb->dst.send_sock);
/* remove all lumps which are not in shm
* added either by build_res_buf_from_sip_res, or by
* the callbacks that have been called with shmem-ed messages - vlad */
if (branch!=relay) {
del_notflaged_lumps( &(relayed_msg->add_rm), LUMPFLAG_SHMEM);
del_notflaged_lumps( &(relayed_msg->body_lumps), LUMPFLAG_SHMEM);
}
}
if (!buf) {
LM_ERR("no mem for outbound reply buffer\n");
goto error02;
}
/* attempt to copy the message to UAS's shmem:
- copy to-tag for ACK matching as well
- allocate little a bit more for provisional as
larger messages are likely to follow and we will be
able to reuse the memory frag
*/
uas_rb->buffer.s = (char*)shm_resize( uas_rb->buffer.s, res_len +
(msg_status<200 ? REPLY_OVERBUFFER_LEN : 0));
if (!uas_rb->buffer.s) {
LM_ERR("no more share memory\n");
goto error03;
}
uas_rb->buffer.len = res_len;
memcpy( uas_rb->buffer.s, buf, res_len );
if (relayed_msg==FAKED_REPLY) { /* to-tags for local replies */
update_local_tags(t, &bm, uas_rb->buffer.s, buf);
}
stats_trans_rpl( relayed_code, (relayed_msg==FAKED_REPLY)?1:0 );
/* update the status ... */
t->uas.status = relayed_code;
if (is_invite(t) && relayed_msg!=FAKED_REPLY
&& relayed_code>=200 && relayed_code < 300
&& has_tran_tmcbs( t,
TMCB_RESPONSE_OUT|TMCB_RESPONSE_PRE_OUT)) {
totag_retr=update_totag_set(t, relayed_msg);
}
}; /* if relay ... */
UNLOCK_REPLIES( t );
/* Setup retransmission timer _before_ the reply is sent
* to avoid race conditions
*/
if (reply_status == RPS_COMPLETED) {
/* for auth related replies, we do not do retransmission
(via set_final_timer()), but only wait for a final
reply (put_on_wait() ) - see RFC 3261 (26.3.2.4 DoS Protection) */
if ((relayed_code != 401) && (relayed_code != 407))
set_final_timer(t);
else
put_on_wait(t);
}
/* send it now (from the private buffer) */
if (relay >= 0) {
/* run the PRE sending out callback */
if (!totag_retr && has_tran_tmcbs(t, TMCB_RESPONSE_PRE_OUT) ) {
cb_s.s = buf;
cb_s.len = res_len;
set_extra_tmcb_params( &cb_s, &uas_rb->dst);
run_trans_callbacks_locked(TMCB_RESPONSE_PRE_OUT,t,t->uas.request,
relayed_msg, relayed_code);
}
SEND_PR_BUFFER( uas_rb, buf, res_len );
LM_DBG("sent buf=%p: %.9s..., shmem=%p: %.9s\n",
buf, buf, uas_rb->buffer.s, uas_rb->buffer.s );
/* run the POST sending out callback */
if (!totag_retr && has_tran_tmcbs(t, TMCB_RESPONSE_OUT) ) {
cb_s.s = buf;
cb_s.len = res_len;
set_extra_tmcb_params( &cb_s, &uas_rb->dst);
run_trans_callbacks_locked( TMCB_RESPONSE_OUT, t, t->uas.request,
relayed_msg, relayed_code);
}
pkg_free( buf );
}
/* success */
return reply_status;
error03:
pkg_free( buf );
error02:
if (save_clone) {
if (t->uac[branch].reply!=FAKED_REPLY)
sip_msg_free( t->uac[branch].reply );
t->uac[branch].reply = NULL;
}
error01:
text.s = "Reply processing error";
text.len = sizeof("Reply processing error")-1;
t_reply_unsafe( t, t->uas.request, 500, &text );
UNLOCK_REPLIES(t);
if (is_invite(t)) cancel_uacs( t, *cancel_bitmap );
/* a serious error occurred -- attempt to send an error reply;
it will take care of clean-ups */
/* failure */
return RPS_ERROR;
}
static inline int pre_print_uac_request( struct cell *t, int branch,
struct sip_msg *request)
{
int backup_route_type;
struct usr_avp **backup_list;
char *p;
/* ... we calculate branch ... */
if (!t_calc_branch(t, branch, request->add_to_branch_s,
&request->add_to_branch_len ))
{
LM_ERR("branch computation failed\n");
goto error;
}
/* from now on, flag all new lumps with LUMPFLAG_BRANCH flag in order to
* be able to remove them later --bogdan */
set_init_lump_flags(LUMPFLAG_BRANCH);
/* copy path vector into branch */
if (request->path_vec.len) {
t->uac[branch].path_vec.s =
shm_resize(t->uac[branch].path_vec.s, request->path_vec.len+1);
if (t->uac[branch].path_vec.s==NULL) {
LM_ERR("shm_resize failed\n");
goto error;
}
t->uac[branch].path_vec.len = request->path_vec.len;
memcpy( t->uac[branch].path_vec.s, request->path_vec.s,
request->path_vec.len+1);
}
/********** run route & callback ************/
/* run branch route, if any; run it before RURI's DNS lookup
* to allow to be changed --bogdan */
if (t->on_branch) {
/* need to pkg_malloc the dst_uri */
if ( request->dst_uri.s && request->dst_uri.len>0 ) {
if ( (p=pkg_malloc(request->dst_uri.len))==0 ) {
LM_ERR("no more pkg mem\n");
ser_error=E_OUT_OF_MEM;
goto error;
}
memcpy( p, request->dst_uri.s, request->dst_uri.len);
request->dst_uri.s = p;
}
/* need to pkg_malloc the new_uri */
if ( (p=pkg_malloc(request->new_uri.len))==0 ) {
LM_ERR("no more pkg mem\n");
ser_error=E_OUT_OF_MEM;
goto error;
}
memcpy( p, request->new_uri.s, request->new_uri.len);
request->new_uri.s = p;
request->parsed_uri_ok = 0;
/* make available the avp list from transaction */
backup_list = set_avp_list( &t->user_avps );
/* run branch route */
swap_route_type( backup_route_type, BRANCH_ROUTE);
_tm_branch_index = branch;
if (run_top_route(branch_rlist[t->on_branch].a, request)&ACT_FL_DROP) {
LM_DBG("dropping branch <%.*s>\n", request->new_uri.len,
request->new_uri.s);
_tm_branch_index = 0;
goto error;
}
_tm_branch_index = 0;
set_route_type( backup_route_type );
/* restore original avp list */
set_avp_list( backup_list );
}
/* run the specific callbacks for this transaction */
run_trans_callbacks( TMCB_REQUEST_FWDED, t, request, 0,
-request->REQ_METHOD);
/* copy dst_uri into branch (after branch route possible updated it) */
if (request->dst_uri.len) {
t->uac[branch].duri.s =
shm_resize(t->uac[branch].duri.s, request->dst_uri.len);
if (t->uac[branch].duri.s==NULL) {
LM_ERR("shm_resize failed\n");
goto error;
}
t->uac[branch].duri.len = request->dst_uri.len;
memcpy( t->uac[branch].duri.s,request->dst_uri.s,request->dst_uri.len);
}
return 0;
error:
return -1;
}
