int dst_is_blacklisted(struct dest_info* si, struct sip_msg* msg)
{
int ires;
struct ip_addr ip;
#ifdef DST_BLACKLIST_HOOKS
unsigned char err_flags;
int action;
#endif
su2ip_addr(&ip, &si->to);
#ifdef DST_BLACKLIST_HOOKS
err_flags=0;
if (unlikely((action=(blacklist_run_hooks(&blst_search_cb, si, &err_flags, msg))
) != DST_BLACKLIST_CONTINUE)){
if (action==DST_BLACKLIST_DENY)
return 0;
else /* if (action==DST_BLACKLIST_ACCEPT) */
return err_flags;
}
#endif
ires=dst_is_blacklisted_ip(si->proto, &ip, su_getport(&si->to));
#ifdef USE_DST_BLACKLIST_STATS
if (ires)
dst_blacklist_stats[process_no].bkl_hit_cnt++;
#endif
return ires;
}
/*
* process_stun_msg():
* buf - incoming message
* len - length of incoming message
* ri - information about socket that received a message and
* also information about sender (its IP, port, protocol)
*
* This function ensures processing of incoming message. It's common for both
* TCP and UDP protocol. There is no other function as an interface.
*
* Return value: 0 if there is no environment error
* -1 if there is some enviroment error such as insufficiency
* of memory
*
*/
int process_stun_msg(char* buf, unsigned len, struct receive_info* ri)
{
struct stun_msg msg_req;
struct stun_msg msg_res;
struct dest_info dst;
struct stun_unknown_att* unknown;
USHORT_T error_code;
memset(&msg_req, 0, sizeof(msg_req));
memset(&msg_res, 0, sizeof(msg_res));
msg_req.msg.buf.s = buf;
msg_req.msg.buf.len = len;
unknown = NULL;
error_code = RESPONSE_OK;
if (stun_parse_header(&msg_req, &error_code) != 0) {
goto error;
}
if (error_code == RESPONSE_OK) {
if (stun_parse_body(&msg_req, &unknown, &error_code) != 0) {
goto error;
}
}
if (stun_create_response(&msg_req, &msg_res, ri,
unknown, error_code) != 0) {
goto error;
}
init_dst_from_rcv(&dst, ri);
#ifdef EXTRA_DEBUG
struct ip_addr ip;
su2ip_addr(&ip, &dst.to);
LOG(L_DBG, "DEBUG: process_stun_msg: decoded request from (%s:%d)\n", ip_addr2a(&ip),
su_getport(&dst.to));
#endif
/* send STUN response */
if (msg_send(&dst, msg_res.msg.buf.s, msg_res.msg.buf.len) != 0) {
goto error;
}
#ifdef EXTRA_DEBUG
LOG(L_DBG, "DEBUG: process_stun_msg: send response\n");
#endif
clean_memory(&msg_req, &msg_res, unknown);
return 0;
error:
#ifdef EXTRA_DEBUG
LOG(L_DBG, "DEBUG: process_stun_msg: failed to decode request\n");
#endif
clean_memory(&msg_req, &msg_res, unknown);
return FATAL_ERROR;
}
int proto_sctp_read(struct socket_info *si, int* bytes_read)
{
struct receive_info ri;
int len;
#ifdef DYN_BUF
char* buf;
#else
static char buf [BUF_SIZE+1];
#endif
char *tmp;
unsigned int fromlen;
struct sctp_sndrcvinfo sinfo;
#ifdef DYN_BUF
buf=pkg_malloc(BUF_SIZE+1);
if (buf==0) {
LM_ERR(" could not allocate receive buffer in pkg memory\n");
goto error;
}
#endif
fromlen=sockaddru_len(si->su);
len = sctp_recvmsg(si->socket, buf, BUF_SIZE, &ri.src_su.s, &fromlen,
&sinfo, 0);
if (len==-1) {
if (errno==EAGAIN) {
LM_DBG("packet with bad checksum received\n");
return 0;
}
if ((errno==EINTR)||(errno==EWOULDBLOCK)|| (errno==ECONNREFUSED))
return -1;
LM_ERR("sctp_recvmsg:[%d] %s\n", errno, strerror(errno));
return -2;
}
/* we must 0-term the messages, receive_msg expects it */
buf[len]=0; /* no need to save the previous char */
ri.bind_address = si;
ri.dst_port = si->port_no;
ri.dst_ip = si->address;
ri.proto = si->proto;
ri.proto_reserved1 = ri.proto_reserved2 = 0;
su2ip_addr(&ri.src_ip, &ri.src_su);
ri.src_port=su_getport(&ri.src_su);
if (ri.src_port==0) {
tmp=ip_addr2a(&ri.src_ip);
LM_INFO("dropping 0 port packet from %s\n", tmp);
return 0;
}
/* receive_msg must free buf too!*/
receive_msg(buf, len, &ri);
return 0;
}
struct tcp_connection* tcpconn_new(int sock, union sockaddr_union* su,
struct socket_info* ba, int type,
int state)
{
struct tcp_connection *c;
c=(struct tcp_connection*)shm_malloc(sizeof(struct tcp_connection));
if (c==0){
LM_ERR("shared memory allocation failure\n");
goto error;
}
memset(c, 0, sizeof(struct tcp_connection)); /* zero init */
c->s=sock;
c->fd=-1; /* not initialized */
if (lock_init(&c->write_lock)==0){
LM_ERR("init lock failed\n");
goto error;
}
c->rcv.src_su=*su;
c->refcnt=0;
su2ip_addr(&c->rcv.src_ip, su);
c->rcv.src_port=su_getport(su);
c->rcv.bind_address=ba;
if (ba){
c->rcv.dst_ip=ba->address;
c->rcv.dst_port=ba->port_no;
}
print_ip("tcpconn_new: new tcp connection to: ", &c->rcv.src_ip, "\n");
LM_DBG("on port %d, type %d\n", c->rcv.src_port, type);
init_tcp_req(&c->req);
c->id=(*connection_id)++;
c->rcv.proto_reserved1=0; /* this will be filled before receive_message*/
c->rcv.proto_reserved2=0;
c->state=state;
c->extra_data=0;
#ifdef USE_TLS
if (type==PROTO_TLS){
if (tls_tcpconn_init(c, sock)==-1) goto error;
}else
#endif /* USE_TLS*/
{
c->type=PROTO_TCP;
c->rcv.proto=PROTO_TCP;
c->timeout=get_ticks()+tcp_con_lifetime;
}
c->flags|=F_CONN_REMOVED;
tcp_connections_no++;
return c;
error:
if (c) shm_free(c);
return 0;
}
static struct tcp_connection* tcpconn_new(int sock, union sockaddr_union* su,
struct socket_info* si, int state, int flags)
{
struct tcp_connection *c;
c=(struct tcp_connection*)shm_malloc(sizeof(struct tcp_connection));
if (c==0){
LM_ERR("shared memory allocation failure\n");
return 0;
}
memset(c, 0, sizeof(struct tcp_connection)); /* zero init */
c->s=sock;
c->fd=-1; /* not initialized */
if (lock_init(&c->write_lock)==0){
LM_ERR("init lock failed\n");
goto error0;
}
c->rcv.src_su=*su;
c->refcnt=0;
su2ip_addr(&c->rcv.src_ip, su);
c->rcv.src_port=su_getport(su);
c->rcv.bind_address = si;
c->rcv.dst_ip = si->address;
c->rcv.dst_port = si->port_no;
print_ip("tcpconn_new: new tcp connection to: ", &c->rcv.src_ip, "\n");
LM_DBG("on port %d, proto %d\n", c->rcv.src_port, si->proto);
c->id=(*connection_id)++;
c->rcv.proto_reserved1=0; /* this will be filled before receive_message*/
c->rcv.proto_reserved2=0;
c->state=state;
c->extra_data=0;
c->type = si->proto;
c->rcv.proto = si->proto;
/* start with the default conn lifetime */
c->lifetime = get_ticks()+tcp_con_lifetime;
c->flags|=F_CONN_REMOVED|flags;
if (protos[si->proto].net.conn_init &&
protos[si->proto].net.conn_init(c)<0) {
LM_ERR("failed to do proto %d specific init for conn %p\n",
si->proto,c);
goto error1;
}
tcp_connections_no++;
return c;
error1:
lock_destroy(&c->write_lock);
error0:
shm_free(c);
return 0;
}
struct tcp_conn *search_tcp_conn(unsigned int id, union sockaddr_union *to)
{
struct tcp_conn *conn;
struct ip_addr ip;
unsigned short port;
unsigned int hash;
port = su_getport(to);
su2ip_addr( &ip, to);
/* if an ID is available, search for it */
if (id!=0) {
hash = tcp_hash( id, 0);
lock_get( &hash_id_lock );
for( conn=hash_id_conns[hash] ; conn ; conn=conn->id_next ) {
if (conn->id == id) {
if (conn->state==TCP_CONN_TERM)
break;
/* validate the connection with ip and port! */
if ( ip_addr_cmp(&ip,&conn->rcv.src_ip) &&
(port==conn->rcv.src_port || port==conn->port_alias) ) {
conn->ref++;
lock_release( &hash_id_lock );
return conn;
}
/* conn id failed to match */
break;
}
}
lock_release( &hash_id_lock );
/* conn id not found */
}
/* search based on destination information (ip and port) */
hash = tcp_hash(ip.u.addr32[0],port);
lock_get( &hash_ip_lock );
for( conn=hash_ip_conns[hash] ; conn ; conn=conn->ip_next ) {
if ( conn->state!=TCP_CONN_TERM && ip_addr_cmp(&ip,&conn->rcv.src_ip)
&& (port==conn->rcv.src_port || port==conn->port_alias) ) {
/* WARNING - take care, this is the only place where both
* locks are taken in the same time - be aware of dead-locks! */
lock_get( &hash_id_lock );
conn->ref++;
lock_release( &hash_id_lock );
lock_release( &hash_ip_lock );
return conn;
}
}
lock_release( &hash_ip_lock );
return NULL;
}
/** add dst to the blacklist, specifying the timeout.
* @param err_flags - reason (bitmap)
* @param si - destination (protocol, ip and port)
* @param msg - sip message that triggered the blacklisting (can be 0 if
* not known)
* @param timeout - timeout in ticks
* @return 0 on success, -1 on error
*/
int dst_blacklist_add_to(unsigned char err_flags, struct dest_info* si,
struct sip_msg* msg, ticks_t timeout)
{
struct ip_addr ip;
#ifdef DST_BLACKLIST_HOOKS
if (unlikely (blacklist_run_hooks(&blst_add_cb, si, &err_flags, msg) ==
DST_BLACKLIST_DENY))
return 0;
#endif
su2ip_addr(&ip, &si->to);
return dst_blacklist_add_ip(err_flags, si->proto, &ip,
su_getport(&si->to), timeout);
}
int pv_get_sndto(struct sip_msg *msg, pv_param_t *param,
pv_value_t *res)
{
struct onsend_info* snd_inf;
struct ip_addr ip;
str s;
snd_inf=get_onsend_info();
if (! likely(snd_inf && snd_inf->send_sock))
return pv_get_null(msg, param, res);
switch(param->pvn.u.isname.name.n)
{
case 1: /* af */
return pv_get_uintval(msg, param, res,
(int)snd_inf->send_sock->address.af);
case 2: /* port */
return pv_get_uintval(msg, param, res,
(int)su_getport(snd_inf->to));
case 3: /* proto */
return pv_get_uintval(msg, param, res,
(int)snd_inf->send_sock->proto);
case 4: /* buf */
s.s = snd_inf->buf;
s.len = snd_inf->len;
return pv_get_strval(msg, param, res, &s);
case 5: /* len */
return pv_get_uintval(msg, param, res,
(int)snd_inf->len);
case 6: /* sproto */
if(get_valid_proto_string((int)snd_inf->send_sock->proto,
0, 0, &s)<0)
return pv_get_null(msg, param, res);
return pv_get_strval(msg, param, res, &s);
default:
/* 0 - ip */
su2ip_addr(&ip, snd_inf->to);
s.s = ip_addr2a(&ip);
s.len = strlen(s.s);
return pv_get_strval(msg, param, res, &s);
}
return 0;
}
int siptrace_net_data_send(void *data)
{
sr_net_info_t *nd;
struct dest_info new_dst;
struct _siptrace_data sto;
if(data==0)
return -1;
nd = (sr_net_info_t*)data;
if(nd->dst==NULL || nd->data.s==NULL || nd->data.len<=0)
return -1;
new_dst=*nd->dst;
new_dst.send_sock=get_send_socket(0, &nd->dst->to, nd->dst->proto);
memset(&sto, 0, sizeof(struct _siptrace_data));
sto.body.s = nd->data.s;
sto.body.len = nd->data.len;
if (unlikely(new_dst.send_sock==0)) {
LM_WARN("no sending socket found\n");
strcpy(sto.fromip_buff, "any:255.255.255.255:5060");
} else {
strncpy(sto.fromip_buff, new_dst.send_sock->sock_str.s,
new_dst.send_sock->sock_str.len);
}
sto.fromip.s = sto.fromip_buff;
sto.fromip.len = strlen(sto.fromip_buff);
siptrace_copy_proto(new_dst.send_sock->proto, sto.toip_buff);
strcat(sto.toip_buff, suip2a(&new_dst.to, sizeof(new_dst.to)));
strcat(sto.toip_buff,":");
strcat(sto.toip_buff, int2str((int)su_getport(&new_dst.to), NULL));
sto.toip.s = sto.toip_buff;
sto.toip.len = strlen(sto.toip_buff);
sto.dir = "out";
trace_send_hep_duplicate(&sto.body, &sto.fromip, &sto.toip, NULL);
return 0;
}
/** add dst to the blacklist, specifying the timeout.
* (like @function dst_blacklist_add_to)= above, but uses
* (proto, sockaddr_union) instead of struct dest_info)
*/
int dst_blacklist_su_to(unsigned char err_flags, unsigned char proto,
union sockaddr_union* dst,
struct sip_msg* msg, ticks_t timeout)
{
struct ip_addr ip;
#ifdef DST_BLACKLIST_HOOKS
struct dest_info si;
init_dest_info(&si);
si.to=*dst;
si.proto=proto;
if (unlikely (blacklist_run_hooks(&blst_add_cb, &si, &err_flags, msg) ==
DST_BLACKLIST_DENY))
return 0;
#endif
su2ip_addr(&ip, dst);
return dst_blacklist_add_ip(err_flags, proto, &ip,
su_getport(dst), timeout);
}
/* returns 1 if the entry was deleted, 0 if not found */
int dst_blacklist_del(struct dest_info* si, struct sip_msg* msg)
{
unsigned short hash;
struct ip_addr ip;
ticks_t now;
int ret;
unsigned short port;
ret=0;
su2ip_addr(&ip, &si->to);
port=su_getport(&si->to);
now=get_ticks_raw();
hash=dst_blst_hash_no(si->proto, &ip, port);
if (unlikely(dst_blst_hash[hash].first)){
LOCK_BLST(hash);
ret=_dst_blacklist_del(hash, &ip, si->proto, port, now);
UNLOCK_BLST(hash);
}
return ret;
}
static void trace_sl_onreply_out( unsigned int types, struct sip_msg* req,
struct sl_cb_param *sl_param)
{
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+12];
struct sip_msg* msg;
int_str avp_value;
struct usr_avp *avp;
struct ip_addr to_ip;
int len;
char statusbuf[5];
if(req==NULL || sl_param==NULL)
{
LM_ERR("bad parameters\n");
goto error;
}
if( trace_is_off() )
{
LM_DBG("trace off...\n");
return;
}
LM_DBG("trace slonreply out \n");
avp = NULL;
if(traced_user_avp >= 0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
if((avp==NULL) && !flag_trace_is_set(req))
{
LM_DBG("nothing to trace...\n");
return;
}
msg = req;
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0)
{
LM_ERR("cannot parse call-id\n");
return;
}
db_vals[0].val.blob_val.s = (sl_param->buffer)?sl_param->buffer->s:"";
db_vals[0].val.blob_val.len = (sl_param->buffer)?sl_param->buffer->len:0;
/* check Call-ID header */
if(msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot find Call-ID header!\n");
goto error;
}
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
db_vals[2].val.str_val.s = msg->first_line.u.request.method.s;
db_vals[2].val.str_val.len = msg->first_line.u.request.method.len;
if(trace_local_ip.s && trace_local_ip.len > 0){
set_columns_to_trace_local_ip( db_vals[4], db_vals[5], db_vals[6]);
}
else {
set_sock_columns( db_vals[4], db_vals[5], db_vals[6], fromip_buff,
&msg->rcv.dst_ip, msg->rcv.dst_port, msg->rcv.proto);
}
strcpy(statusbuf, int2str(sl_param->code, &len));
db_vals[3].val.str_val.s = statusbuf;
db_vals[3].val.str_val.len = len;
memset(&to_ip, 0, sizeof(struct ip_addr));
if(sl_param->dst==0)
{
set_columns_to_any(db_vals[7], db_vals[8], db_vals[9]);
} else {
su2ip_addr(&to_ip, sl_param->dst);
set_sock_columns( db_vals[7], db_vals[8],db_vals[9], toip_buff, &to_ip,
(unsigned short)su_getport(sl_param->dst), req->rcv.proto);
}
db_vals[10].val.time_val = time(NULL);
db_vals[11].val.string_val = "out";
db_vals[12].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[12].val.str_val.len = get_from(msg)->tag_value.len;
if (save_siptrace(msg,avp,&avp_value,db_keys,db_vals) < 0) {
LM_ERR("failed to save siptrace\n");
goto error;
}
#ifdef STATISTICS
update_stat(siptrace_rpl, 1);
#endif
return;
error:
return;
}
static void trace_onreply_out(struct cell* t, int type, struct tmcb_params *ps)
{
int faked = 0;
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+12];
struct sip_msg* msg;
struct sip_msg* req;
int_str avp_value;
struct usr_avp *avp;
struct ip_addr to_ip;
int len;
char statusbuf[8];
str *sbuf;
struct dest_info *dst;
if (t==NULL || t->uas.request==0 || ps==NULL)
{
LM_DBG("no uas request, local transaction\n");
return;
}
LM_DBG("trace onreply out \n");
avp = NULL;
if(traced_user_avp>=0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
req = ps->req;
msg = ps->rpl;
if(msg==NULL || msg==FAKED_REPLY)
{
msg = t->uas.request;
faked = 1;
}
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0)
{
LM_ERR("cannot parse call-id\n");
return;
}
sbuf = (str*)ps->extra1;
if(faked==0)
{
if(sbuf!=0 && sbuf->len>0) {
db_vals[0].val.blob_val.s = sbuf->s;
db_vals[0].val.blob_val.len = sbuf->len;
} else if(t->uas.response.buffer.s!=NULL) {
db_vals[0].val.blob_val.s = t->uas.response.buffer.s;
db_vals[0].val.blob_val.len = t->uas.response.buffer.len;
} else if(msg->len>0) {
db_vals[0].val.blob_val.s = msg->buf;
db_vals[0].val.blob_val.len = msg->len;
} else {
db_vals[0].val.blob_val.s = "No reply buffer";
db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1;
}
} else {
if(sbuf!=0 && sbuf->len>0) {
db_vals[0].val.blob_val.s = sbuf->s;
db_vals[0].val.blob_val.len = sbuf->len;
} else if(t->uas.response.buffer.s==NULL) {
db_vals[0].val.blob_val.s = "No reply buffer";
db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1;
} else {
db_vals[0].val.blob_val.s = t->uas.response.buffer.s;
db_vals[0].val.blob_val.len = t->uas.response.buffer.len;
}
}
/* check Call-ID header */
if(msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot find Call-ID header!\n");
goto error;
}
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
db_vals[2].val.str_val.s = t->method.s;
db_vals[2].val.str_val.len = t->method.len;
if(trace_local_ip.s && trace_local_ip.len > 0){
set_columns_to_trace_local_ip(db_vals[4], db_vals[5], db_vals[6]);
}
else {
set_sock_columns( db_vals[4], db_vals[5], db_vals[6], fromip_buff,
&msg->rcv.dst_ip, msg->rcv.dst_port, msg->rcv.proto);
}
strcpy(statusbuf, int2str(ps->code, &len));
db_vals[3].val.str_val.s = statusbuf;
db_vals[3].val.str_val.len = len;
memset(&to_ip, 0, sizeof(struct ip_addr));
dst = (struct dest_info*)ps->extra2;
if(dst==0)
{
set_columns_to_any( db_vals[7], db_vals[8], db_vals[9]);
} else {
su2ip_addr(&to_ip, &dst->to);
set_sock_columns( db_vals[7], db_vals[8], db_vals[9], toip_buff,
&to_ip, (unsigned long)su_getport(&dst->to), dst->proto);
}
db_vals[10].val.time_val = time(NULL);
db_vals[11].val.string_val = "out";
db_vals[12].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[12].val.str_val.len = get_from(msg)->tag_value.len;
if (save_siptrace(req,avp,&avp_value,db_keys,db_vals) < 0) {
LM_ERR("failed to save siptrace\n");
goto error;
}
#ifdef STATISTICS
update_stat(siptrace_rpl, 1);
#endif
return;
error:
return;
}
static void trace_msg_out(struct sip_msg* msg, str *sbuf,
struct socket_info* send_sock, int proto, union sockaddr_union *to)
{
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+12];
int_str avp_value;
struct usr_avp *avp;
struct ip_addr to_ip;
avp = NULL;
if(traced_user_avp>=0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
if ( (avp==NULL) && !flag_trace_is_set(msg) )
{
LM_DBG("trace off...\n");
return;
}
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0)
{
LM_ERR("cannot parse call-id\n");
return;
}
LM_DBG("trace msg out \n");
if(sbuf!=NULL && sbuf->len>0)
{
db_vals[0].val.blob_val.s = sbuf->s;
db_vals[0].val.blob_val.len = sbuf->len;
} else {
db_vals[0].val.blob_val.s = "No request buffer";
db_vals[0].val.blob_val.len = sizeof("No request buffer")-1;
}
/* check Call-ID header */
if(msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot find Call-ID header!\n");
goto error;
}
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
if(sbuf!=NULL && sbuf->len > 7 && !strncasecmp(sbuf->s, "CANCEL ", 7))
{
db_vals[2].val.str_val.s = "CANCEL";
db_vals[2].val.str_val.len = 6;
} else {
db_vals[2].val.str_val= REQ_LINE(msg).method;
}
db_vals[3].val.str_val.s = "";
db_vals[3].val.str_val.len = 0;
memset(&to_ip, 0, sizeof(struct ip_addr));
if (trace_local_ip.s && trace_local_ip.len > 0){
set_columns_to_trace_local_ip( db_vals[4], db_vals[5], db_vals[6]);
}
else {
if(send_sock==0 || send_sock->sock_str.s==0)
{
set_sock_columns( db_vals[4], db_vals[5], db_vals[6], fromip_buff,
&msg->rcv.dst_ip, msg->rcv.dst_port, msg->rcv.proto);
} else {
char *nbuff = proto2str(send_sock->proto,fromip_buff);
db_vals[4].val.str_val.s = fromip_buff;
db_vals[4].val.str_val.len = nbuff - fromip_buff;
db_vals[5].val.str_val = send_sock->address_str;
db_vals[6].val.int_val = send_sock->port_no;
}
}
if(to==0)
{
set_columns_to_any(db_vals[7], db_vals[8], db_vals[9]);
} else {
su2ip_addr(&to_ip, to);
set_sock_columns( db_vals[7], db_vals[8], db_vals[9], toip_buff,
&to_ip, (unsigned short)su_getport(to), proto);
}
db_vals[10].val.time_val = time(NULL);
db_vals[11].val.string_val = "out";
db_vals[12].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[12].val.str_val.len = get_from(msg)->tag_value.len;
if (save_siptrace(msg,avp,&avp_value,db_keys,db_vals) < 0) {
LM_ERR("failed to save siptrace\n");
goto error;
}
#ifdef STATISTICS
update_stat(siptrace_req, 1);
#endif
return;
error:
return;
}
/*! \brief Finds a tcpconn & sends on it */
static int proto_ws_send(struct socket_info* send_sock,
char* buf, unsigned int len,
union sockaddr_union* to, int id)
{
struct tcp_connection *c;
struct timeval get;
struct ip_addr ip;
int port = 0;
int fd, n;
reset_tcp_vars(tcpthreshold);
start_expire_timer(get,tcpthreshold);
if (to){
su2ip_addr(&ip, to);
port=su_getport(to);
n = tcp_conn_get(id, &ip, port, &c, &fd);
}else if (id){
n = tcp_conn_get(id, 0, 0, &c, &fd);
}else{
LM_CRIT("prot_tls_send called with null id & to\n");
get_time_difference(get,tcpthreshold,tcp_timeout_con_get);
return -1;
}
if (n<0) {
/* error during conn get, return with error too */
LM_ERR("failed to aquire connection\n");
get_time_difference(get,tcpthreshold,tcp_timeout_con_get);
return -1;
}
/* was connection found ?? */
if (c==0) {
if (tcp_no_new_conn) {
return -1;
}
LM_DBG("no open tcp connection found, opening new one\n");
/* create tcp connection */
if ((c=ws_connect(send_sock, to, &fd))==0) {
LM_ERR("connect failed\n");
return -1;
}
goto send_it;
}
get_time_difference(get, tcpthreshold, tcp_timeout_con_get);
/* now we have a connection, let's what we can do with it */
/* BE CAREFUL now as we need to release the conn before exiting !!! */
if (fd==-1) {
/* connection is not writable because of its state */
/* return error, nothing to do about it */
tcp_conn_release(c, 0);
return -1;
}
send_it:
LM_DBG("sending via fd %d...\n",fd);
n = ws_req_write(c, fd, buf, len);
stop_expire_timer(get, tcpthreshold, "WS ops",buf,(int)len,1);
tcp_conn_set_lifetime( c, tcp_con_lifetime);
LM_DBG("after write: c= %p n=%d fd=%d\n",c, n, fd);
if (n<0){
LM_ERR("failed to send\n");
c->state=S_CONN_BAD;
if (c->proc_id != process_no)
close(fd);
tcp_conn_release(c, 0);
return -1;
}
/* only close the FD if not already in the context of our process
either we just connected, or main sent us the FD */
if (c->proc_id != process_no)
close(fd);
tcp_conn_release(c, 0);
return n;
}
static int sip_trace(struct sip_msg *msg, struct dest_info * dst, char *dir)
{
struct _siptrace_data sto;
struct onsend_info *snd_inf = NULL;
if (dst){
if (dst->send_sock == 0){
dst->send_sock=get_send_socket(0, &dst->to, dst->proto);
if (dst->send_sock==0){
LM_ERR("can't forward to af %d, proto %d no corresponding"
" listening socket\n", dst->to.s.sa_family, dst->proto);
return -1;
}
}
}
if(msg==NULL) {
LM_DBG("nothing to trace\n");
return -1;
}
memset(&sto, 0, sizeof(struct _siptrace_data));
if(traced_user_avp.n!=0)
sto.avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&sto.avp_value, &sto.state);
if((sto.avp==NULL) && (trace_on_flag==NULL || *trace_on_flag==0)) {
LM_DBG("trace off...\n");
return -1;
}
if(sip_trace_prepare(msg)<0)
return -1;
sto.callid = msg->callid->body;
if(msg->first_line.type==SIP_REQUEST) {
sto.method = msg->first_line.u.request.method;
} else {
if(parse_headers(msg, HDR_CSEQ_F, 0) != 0 || msg->cseq==NULL
|| msg->cseq->parsed==NULL) {
LM_ERR("cannot parse cseq header\n");
return -1;
}
sto.method = get_cseq(msg)->method;
}
if(msg->first_line.type==SIP_REPLY) {
sto.status = msg->first_line.u.reply.status;
} else {
sto.status.s = "";
sto.status.len = 0;
}
snd_inf=get_onsend_info();
if(snd_inf==NULL) {
sto.body.s = msg->buf;
sto.body.len = msg->len;
siptrace_copy_proto(msg->rcv.proto, sto.fromip_buff);
strcat(sto.fromip_buff, ip_addr2a(&msg->rcv.src_ip));
strcat(sto.fromip_buff,":");
strcat(sto.fromip_buff, int2str(msg->rcv.src_port, NULL));
sto.fromip.s = sto.fromip_buff;
sto.fromip.len = strlen(sto.fromip_buff);
siptrace_copy_proto(msg->rcv.proto, sto.toip_buff);
strcat(sto.toip_buff, ip_addr2a(&msg->rcv.dst_ip));
strcat(sto.toip_buff,":");
strcat(sto.toip_buff, int2str(msg->rcv.dst_port, NULL));
sto.toip.s = sto.toip_buff;
sto.toip.len = strlen(sto.toip_buff);
sto.dir = (dir)?dir:"in";
} else {
sto.body.s = snd_inf->buf;
sto.body.len = snd_inf->len;
strncpy(sto.fromip_buff, snd_inf->send_sock->sock_str.s,
snd_inf->send_sock->sock_str.len);
sto.fromip.s = sto.fromip_buff;
sto.fromip.len = strlen(sto.fromip_buff);
siptrace_copy_proto(snd_inf->send_sock->proto, sto.toip_buff);
strcat(sto.toip_buff, suip2a(snd_inf->to, sizeof(*snd_inf->to)));
strcat(sto.toip_buff,":");
strcat(sto.toip_buff, int2str((int)su_getport(snd_inf->to), NULL));
sto.toip.s = sto.toip_buff;
sto.toip.len = strlen(sto.toip_buff);
sto.dir = "out";
}
sto.fromtag = get_from(msg)->tag_value;
sto.totag = get_to(msg)->tag_value;
#ifdef STATISTICS
if(msg->first_line.type==SIP_REPLY) {
sto.stat = siptrace_rpl;
} else {
sto.stat = siptrace_req;
}
#endif
return sip_trace_store(&sto, dst);
}
static int proto_tls_send(struct socket_info* send_sock,
char* buf, unsigned int len, union sockaddr_union* to, int id)
{
struct tcp_connection *c;
struct ip_addr ip;
int port;
int fd, n;
struct tls_data* data;
if (to){
su2ip_addr(&ip, to);
port=su_getport(to);
n = tcp_conn_get(id, &ip, port, PROTO_TLS, &c, &fd);
}else if (id){
n = tcp_conn_get(id, 0, 0, PROTO_NONE, &c, &fd);
}else{
LM_CRIT("prot_tls_send called with null id & to\n");
return -1;
}
if (n<0) {
/* error during conn get, return with error too */
LM_ERR("failed to acquire connection\n");
return -1;
}
/* was connection found ?? */
if (c==0) {
if (tcp_no_new_conn) {
return -1;
}
LM_DBG("no open tcp connection found, opening new one\n");
/* create tcp connection */
if ((c=tls_sync_connect(send_sock, to, &fd))==0) {
LM_ERR("connect failed\n");
return -1;
}
goto send_it;
}
/* now we have a connection, let's what we can do with it */
/* BE CAREFUL now as we need to release the conn before exiting !!! */
if (fd==-1) {
/* connection is not writable because of its state */
/* return error, nothing to do about it */
tcp_conn_release(c, 0);
return -1;
}
send_it:
/* if there is pending tracing data on a connection startet by us
* (connected) -> flush it
* As this is a write op, we look only for connected conns, not to conflict
* with accepted conns (flushed on read op) */
if ( (c->flags&F_CONN_ACCEPTED)==0 && c->proto_flags & F_TLS_TRACE_READY ) {
data = c->proto_data;
/* send the message if set from tls_mgm */
if ( data->message ) {
send_trace_message( data->message, t_dst);
data->message = NULL;
}
/* don't allow future traces for this connection */
data->tprot = 0;
data->dest = 0;
c->proto_flags &= ~( F_TLS_TRACE_READY );
}
LM_DBG("sending via fd %d...\n",fd);
lock_get(&c->write_lock);
n = tls_blocking_write(c, fd, buf, len, &tls_mgm_api);
lock_release(&c->write_lock);
tcp_conn_set_lifetime( c, tcp_con_lifetime);
LM_DBG("after write: c= %p n=%d fd=%d\n",c, n, fd);
LM_DBG("buf=\n%.*s\n", (int)len, buf);
if (n<0){
LM_ERR("failed to send\n");
c->state=S_CONN_BAD;
if (c->proc_id != process_no)
close(fd);
tcp_conn_release(c, 0);
return -1;
}
/* only close the FD if not already in the context of our process
either we just connected, or main sent us the FD */
if (c->proc_id != process_no)
close(fd);
/* mark the ID of the used connection (tracing purposes) */
last_outgoing_tcp_id = c->id;
tcp_conn_release(c, 0);
return n;
}
/**
* Evaluate if next hop is a strict or loose router, by looking at the
* retr. buffer of the original INVITE.
* Assumes:
* orig_inv is a parsed SIP message;
* rtset is not NULL.
* @return:
* F_RB_NH_LOOSE : next hop was loose router;
* F_RB_NH_STRICT: nh is strict;
* 0 on error.
*/
static unsigned long nhop_type(sip_msg_t *orig_inv, rte_t *rtset,
const struct dest_info *dst_inv, str *contact)
{
struct sip_uri puri, topr_uri, lastr_uri, inv_ruri, cont_uri;
struct ip_addr *uri_ia;
union sockaddr_union uri_sau;
unsigned int uri_port, dst_port, inv_port, cont_port, lastr_port;
rte_t *last_r;
#ifdef TM_LOC_ACK_DO_REV_DNS
struct ip_addr ia;
struct hostent *he;
char **alias;
#endif
#define PARSE_URI(_str_, _uri_) \
do { \
/* parse_uri() 0z the puri */ \
if (parse_uri((_str_)->s, \
(_str_)->len, _uri_) < 0) { \
LM_ERR("failed to parse route body '%.*s'.\n", STR_FMT(_str_)); \
return 0; \
} \
} while (0)
#define HAS_LR(_rte_) \
({ \
PARSE_URI(&(_rte_)->ptr->nameaddr.uri, &puri); \
puri.lr.s; \
})
#define URI_PORT(_puri_, _port) \
do { \
if (! (_port = uri2port(_puri_))) \
return 0; \
} while (0)
/* examine the easy/fast & positive cases foremost */
/* [1] check if 1st route lacks ;lr */
LM_DBG("checking lack of ';lr' in 1st route.\n");
if (! HAS_LR(rtset))
return F_RB_NH_STRICT;
topr_uri = puri; /* save 1st route's URI */
/* [2] check if last route shows ;lr */
LM_DBG("checking presence of ';lr' in last route.\n");
for (last_r = rtset; last_r->next; last_r = last_r->next)
/* scroll down to last route */
;
if (HAS_LR(last_r))
return F_RB_NH_LOOSE;
/* [3] 1st route has ;lr -> check if the destination of original INV
* equals the address provided by this route; if does -> loose */
LM_DBG("checking INVITE's destination against its first route.\n");
URI_PORT(&topr_uri, uri_port);
if (! (dst_port = su_getport(&dst_inv->to)))
return 0; /* not really expected */
if (dst_port != uri_port)
return F_RB_NH_STRICT;
/* if 1st route contains an IP address, comparing it against .dst */
if ((uri_ia = str2ip(&topr_uri.host))
|| (uri_ia = str2ip6(&topr_uri.host))
) {
/* we have an IP address in route -> comparison can go swiftly */
if (init_su(&uri_sau, uri_ia, uri_port) < 0)
return 0; /* not really expected */
if (su_cmp(&uri_sau, &dst_inv->to))
/* ;lr and sent there */
return F_RB_NH_LOOSE;
else
/* ;lr and NOT sent there (probably sent to RURI address) */
return F_RB_NH_STRICT;
} else {
/*if 1st route contains a name, rev resolve the .dst and compare*/
LM_INFO("Failed to decode string '%.*s' in route set element as IP"
" address. Trying name resolution.\n",STR_FMT(&topr_uri.host));
/* TODO: alternatively, rev name and compare against dest. IP. */
#ifdef TM_LOC_ACK_DO_REV_DNS
ia.af = 0;
su2ip_addr(&ia, (void *)&dst_inv->to);
if (! ia.af)
return 0; /* not really expected */
if ((he = rev_resolvehost(&ia))) {
if ((strlen(he->h_name) == topr_uri.host.len) &&
(memcmp(he->h_name, topr_uri.host.s,
topr_uri.host.len) == 0))
return F_RB_NH_LOOSE;
for (alias = he->h_aliases; *alias; alias ++)
if ((strlen(*alias) == topr_uri.host.len) &&
(memcmp(*alias, topr_uri.host.s,
topr_uri.host.len) == 0))
return F_RB_NH_LOOSE;
return F_RB_NH_STRICT;
} else {
LM_INFO("failed to resolve address '%s' to a name.\n",
ip_addr2a(&ia));
}
#endif
}
LM_WARN("failed to establish with certainty the type of next hop;"
" trying an educated guess.\n");
/* [4] compare (possibly updated) remote target to original RURI; if
* equal, a strict router's address wasn't filled in as RURI -> loose */
LM_DBG("checking remote target against INVITE's RURI.\n");
PARSE_URI(contact, &cont_uri);
PARSE_URI(GET_RURI(orig_inv), &inv_ruri);
URI_PORT(&cont_uri, cont_port);
URI_PORT(&inv_ruri, inv_port);
if ((cont_port == inv_port) && (cont_uri.host.len == inv_ruri.host.len) &&
(memcmp(cont_uri.host.s, inv_ruri.host.s, cont_uri.host.len) == 0))
return F_RB_NH_LOOSE;
/* [5] compare (possibly updated) remote target to last route; if equal,
* strict router's address might have been filled as RURI and remote
* target appended to route set -> strict */
LM_DBG("checking remote target against INVITE's last route.\n");
PARSE_URI(&last_r->ptr->nameaddr.uri, &lastr_uri);
URI_PORT(&lastr_uri, lastr_port);
if ((cont_port == lastr_port) &&
(cont_uri.host.len == lastr_uri.host.len) &&
(memcmp(cont_uri.host.s, lastr_uri.host.s,
lastr_uri.host.len) == 0))
return F_RB_NH_STRICT;
LM_WARN("failed to establish the type of next hop;"
" assuming loose router.\n");
return F_RB_NH_LOOSE;
#undef PARSE_URI
#undef HAS_LR
#undef URI_PORT
}
static void trace_onreply_out(struct cell* t, int type, struct tmcb_params *ps)
{
db_key_t db_keys[NR_KEYS];
db_val_t db_vals[NR_KEYS];
int faked = 0;
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+12];
struct sip_msg* msg;
struct sip_msg* req;
int_str avp_value;
struct usr_avp *avp;
struct ip_addr to_ip;
int len;
char statusbuf[8];
str *sbuf;
struct dest_info *dst;
if (t==NULL || t->uas.request==0 || ps==NULL)
{
LM_DBG("no uas request, local transaction\n");
return;
}
avp = NULL;
if(traced_user_avp.n!=0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
if((avp==NULL) && trace_is_off(t->uas.request))
{
LM_DBG("trace off...\n");
return;
}
req = ps->req;
msg = ps->rpl;
if(msg==NULL || msg==FAKED_REPLY)
{
msg = t->uas.request;
faked = 1;
}
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0)
{
LM_ERR("cannot parse call-id\n");
return;
}
db_keys[0] = msg_column;
db_vals[0].type = DB_BLOB;
db_vals[0].nul = 0;
sbuf = (str*)ps->extra1;
if(faked==0)
{
if(sbuf!=0 && sbuf->len>0) {
db_vals[0].val.blob_val.s = sbuf->s;
db_vals[0].val.blob_val.len = sbuf->len;
} else if(t->uas.response.buffer.s!=NULL) {
db_vals[0].val.blob_val.s = t->uas.response.buffer.s;
db_vals[0].val.blob_val.len = t->uas.response.buffer.len;
} else if(msg->len>0) {
db_vals[0].val.blob_val.s = msg->buf;
db_vals[0].val.blob_val.len = msg->len;
} else {
db_vals[0].val.blob_val.s = "No reply buffer";
db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1;
}
} else {
if(sbuf!=0 && sbuf->len>0) {
db_vals[0].val.blob_val.s = sbuf->s;
db_vals[0].val.blob_val.len = sbuf->len;
} else if(t->uas.response.buffer.s==NULL) {
db_vals[0].val.blob_val.s = "No reply buffer";
db_vals[0].val.blob_val.len = sizeof("No reply buffer")-1;
} else {
db_vals[0].val.blob_val.s = t->uas.response.buffer.s;
db_vals[0].val.blob_val.len = t->uas.response.buffer.len;
}
}
/* check Call-ID header */
if(msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot find Call-ID header!\n");
goto error;
}
db_keys[1] = callid_column;
db_vals[1].type = DB_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
db_keys[2] = method_column;
db_vals[2].type = DB_STR;
db_vals[2].nul = 0;
db_vals[2].val.str_val.s = t->method.s;
db_vals[2].val.str_val.len = t->method.len;
db_keys[4] = fromip_column;
db_vals[4].type = DB_STRING;
db_vals[4].nul = 0;
if(trace_local_ip)
db_vals[4].val.string_val = trace_local_ip;
else {
siptrace_copy_proto(msg->rcv.proto, fromip_buff);
strcat(fromip_buff, ip_addr2a(&req->rcv.dst_ip));
strcat(fromip_buff,":");
strcat(fromip_buff, int2str(req->rcv.dst_port, NULL));
db_vals[4].val.string_val = fromip_buff;
}
db_keys[3] = status_column;
db_vals[3].type = DB_STRING;
db_vals[3].nul = 0;
strcpy(statusbuf, int2str(ps->code, NULL));
db_vals[3].val.string_val = statusbuf;
db_keys[5] = toip_column;
db_vals[5].type = DB_STRING;
db_vals[5].nul = 0;
memset(&to_ip, 0, sizeof(struct ip_addr));
dst = (struct dest_info*)ps->extra2;
if(dst==0)
{
db_vals[5].val.string_val = "any:255.255.255.255";
} else {
su2ip_addr(&to_ip, &dst->to);
siptrace_copy_proto(dst->proto, toip_buff);
strcat(toip_buff, ip_addr2a(&to_ip));
strcat(toip_buff, ":");
strcat(toip_buff,
int2str((unsigned long)su_getport(&dst->to), &len));
LM_DBG("dest [%s]\n", toip_buff);
db_vals[5].val.string_val = toip_buff;
}
db_keys[6] = date_column;
db_vals[6].type = DB_DATETIME;
db_vals[6].nul = 0;
db_vals[6].val.time_val = time(NULL);
db_keys[7] = direction_column;
db_vals[7].type = DB_STRING;
db_vals[7].nul = 0;
db_vals[7].val.string_val = "out";
db_keys[8] = fromtag_column;
db_vals[8].type = DB_STR;
db_vals[8].nul = 0;
db_vals[8].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[8].val.str_val.len = get_from(msg)->tag_value.len;
db_funcs.use_table(db_con, siptrace_get_table());
db_keys[9] = traced_user_column;
db_vals[9].type = DB_STR;
db_vals[9].nul = 0;
if( !trace_is_off(req) ) {
db_vals[9].val.str_val.s = "";
db_vals[9].val.str_val.len = 0;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
#ifdef STATISTICS
update_stat(siptrace_rpl, 1);
#endif
}
if(avp==NULL)
goto done;
trace_send_duplicate(db_vals[0].val.blob_val.s,
db_vals[0].val.blob_val.len);
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
while(avp!=NULL)
{
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("### - storing info (%d) ...\n", faked);
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
}
done:
return;
error:
return;
}
/* forwards a request to dst
* parameters:
* msg - sip msg
* dst - destination name, if non-null it will be resolved and
* send_info updated with the ip/port. Even if dst is non
* null send_info must contain the protocol and if a non
* default port or non srv. lookup is desired, the port must
* be !=0
* port - used only if dst!=0 (else the port in send_info->to is used)
* send_info - value/result partially filled dest_info structure:
* - send_info->proto and comp are used
* - send_info->to will be filled (dns)
* - send_info->send_flags is filled from the message
* - if the send_socket member is null, a send_socket will be
* chosen automatically
* WARNING: don't forget to zero-fill all the unused members (a non-zero
* random id along with proto==PROTO_TCP can have bad consequences, same for
* a bogus send_socket value)
*/
int forward_request(struct sip_msg* msg, str* dst, unsigned short port,
struct dest_info* send_info)
{
unsigned int len;
char* buf;
char md5[MD5_LEN];
struct socket_info* orig_send_sock; /* initial send_sock */
int ret;
struct ip_addr ip; /* debugging only */
char proto;
#ifdef USE_DNS_FAILOVER
struct socket_info* prev_send_sock;
int err;
struct dns_srv_handle dns_srv_h;
prev_send_sock=0;
err=0;
#endif
buf=0;
orig_send_sock=send_info->send_sock;
proto=send_info->proto;
ret=0;
if(dst){
#ifdef USE_DNS_FAILOVER
if (cfg_get(core, core_cfg, use_dns_failover)){
dns_srv_handle_init(&dns_srv_h);
err=dns_sip_resolve2su(&dns_srv_h, &send_info->to, dst, port,
&proto, dns_flags);
if (err!=0){
LOG(L_ERR, "ERROR: forward_request: resolving \"%.*s\""
" failed: %s [%d]\n", dst->len, ZSW(dst->s),
dns_strerror(err), err);
ret=E_BAD_ADDRESS;
goto error;
}
}else
#endif
if (sip_hostport2su(&send_info->to, dst, port, &proto)<0){
LOG(L_ERR, "ERROR: forward_request: bad host name %.*s,"
" dropping packet\n", dst->len, ZSW(dst->s));
ret=E_BAD_ADDRESS;
goto error;
}
}/* dst */
send_info->send_flags=msg->fwd_send_flags;
/* calculate branch for outbound request; if syn_branch is turned off,
calculate is from transaction key, i.e., as an md5 of From/To/CallID/
CSeq exactly the same way as TM does; good for reboot -- than messages
belonging to transaction lost due to reboot will still be forwarded
with the same branch parameter and will be match-able downstream
if it is turned on, we don't care about reboot; we simply put a simple
value in there; better for performance
*/
if (syn_branch ) {
memcpy(msg->add_to_branch_s, "z9hG4bKcydzigwkX", 16);
msg->add_to_branch_len=16;
} else {
if (!char_msg_val( msg, md5 )) { /* parses transaction key */
LOG(L_ERR, "ERROR: forward_request: char_msg_val failed\n");
ret=E_UNSPEC;
goto error;
}
msg->hash_index=hash( msg->callid->body, get_cseq(msg)->number);
if (!branch_builder( msg->hash_index, 0, md5, 0 /* 0-th branch */,
msg->add_to_branch_s, &msg->add_to_branch_len )) {
LOG(L_ERR, "ERROR: forward_request: branch_builder failed\n");
ret=E_UNSPEC;
goto error;
}
}
/* try to send the message until success or all the ips are exhausted
* (if dns lookup is performed && the dns cache used ) */
#ifdef USE_DNS_FAILOVER
do{
#endif
if (orig_send_sock==0) /* no forced send_sock => find it **/
send_info->send_sock=get_send_socket(msg, &send_info->to, proto);
if (send_info->send_sock==0){
LOG(L_ERR, "forward_req: ERROR: cannot forward to af %d, proto %d "
"no corresponding listening socket\n",
send_info->to.s.sa_family, proto);
ret=ser_error=E_NO_SOCKET;
#ifdef USE_DNS_FAILOVER
/* continue, maybe we find a socket for some other ip */
continue;
#else
goto error;
#endif
}
#ifdef USE_DNS_FAILOVER
if (prev_send_sock!=send_info->send_sock){
/* rebuild the message only if the send_sock changed */
prev_send_sock=send_info->send_sock;
#endif
if (buf) pkg_free(buf);
send_info->proto=proto;
buf = build_req_buf_from_sip_req(msg, &len, send_info, 0);
if (!buf){
LOG(L_ERR, "ERROR: forward_request: building failed\n");
ret=E_OUT_OF_MEM; /* most probable */
goto error;
}
#ifdef USE_DNS_FAILOVER
}
#endif
/* send it! */
DBG("Sending:\n%.*s.\n", (int)len, buf);
DBG("orig. len=%d, new_len=%d, proto=%d\n",
msg->len, len, send_info->proto );
if (run_onsend(msg, send_info, buf, len)==0){
su2ip_addr(&ip, &send_info->to);
LOG(L_INFO, "forward_request: request to %s:%d(%d) dropped"
" (onsend_route)\n", ip_addr2a(&ip),
su_getport(&send_info->to), send_info->proto);
ser_error=E_OK; /* no error */
ret=E_ADM_PROHIBITED;
#ifdef USE_DNS_FAILOVER
continue; /* try another ip */
#else
goto error; /* error ? */
#endif
}
#ifdef USE_DST_BLACKLIST
if (cfg_get(core, core_cfg, use_dst_blacklist)){
if (dst_is_blacklisted(send_info, msg)){
su2ip_addr(&ip, &send_info->to);
LOG(L_DBG, "DEBUG: blacklisted destination:%s:%d (%d)\n",
ip_addr2a(&ip), su_getport(&send_info->to),
send_info->proto);
ret=ser_error=E_SEND;
#ifdef USE_DNS_FAILOVER
continue; /* try another ip */
#else
goto error;
#endif
}
}
#endif
if (msg_send(send_info, buf, len)<0){
ret=ser_error=E_SEND;
#ifdef USE_DST_BLACKLIST
(void)dst_blacklist_add(BLST_ERR_SEND, send_info, msg);
#endif
#ifdef USE_DNS_FAILOVER
continue; /* try another ip */
#else
goto error;
#endif
}else{
ret=ser_error=E_OK;
/* sent requests stats */
STATS_TX_REQUEST( msg->first_line.u.request.method_value );
/* exit succcesfully */
goto end;
}
#ifdef USE_DNS_FAILOVER
}while(dst && cfg_get(core, core_cfg, use_dns_failover) &&
dns_srv_handle_next(&dns_srv_h, err) &&
((err=dns_sip_resolve2su(&dns_srv_h, &send_info->to, dst, port,
&proto, dns_flags))==0));
if ((err!=0) && (err!=-E_DNS_EOR)){
LOG(L_ERR, "ERROR: resolving %.*s host name in uri"
" failed: %s [%d] (dropping packet)\n",
dst->len, ZSW(dst->s),
dns_strerror(err), err);
ret=ser_error=E_BAD_ADDRESS;
goto error;
}
#endif
error:
STATS_TX_DROPS;
end:
#ifdef USE_DNS_FAILOVER
if (dst && cfg_get(core, core_cfg, use_dns_failover)){
dns_srv_handle_put(&dns_srv_h);
}
#endif
if (buf) pkg_free(buf);
/* received_buf & line_buf will be freed in receive_msg by free_lump_list*/
#if defined STATS_REQ_FWD_OK || defined STATS_REQ_FWD_DROP
if(ret==0)
STATS_REQ_FWD_OK();
else
STATS_REQ_FWD_DROP();
#endif /* STATS_REQ_FWD_* */
return ret;
}
/*! \brief Finds a tcpconn & sends on it */
int tcp_send(struct socket_info* send_sock, int type, char* buf, unsigned len,
union sockaddr_union* to, int id)
{
struct tcp_connection *c;
struct tcp_connection *tmp;
struct ip_addr ip;
int port;
int fd;
long response[2];
int n;
struct timeval get,rcv,snd;
port=0;
reset_tcp_vars(tcpthreshold);
start_expire_timer(get,tcpthreshold);
if (to){
su2ip_addr(&ip, to);
port=su_getport(to);
c=tcpconn_get(id, &ip, port, tcp_con_lifetime);
}else if (id){
c=tcpconn_get(id, 0, 0, tcp_con_lifetime);
}else{
LM_CRIT("tcp_send called with null id & to\n");
get_time_difference(get,tcpthreshold,tcp_timeout_con_get);
return -1;
}
if (id){
if (c==0) {
if (to){
/* try again w/o id */
c=tcpconn_get(0, &ip, port, tcp_con_lifetime);
goto no_id;
}else{
LM_ERR("id %d not found, dropping\n", id);
get_time_difference(get,tcpthreshold,tcp_timeout_con_get);
return -1;
}
}else goto get_fd;
}
no_id:
if (c==0){
if (tcp_no_new_conn) {
return -1;
}
LM_DBG("no open tcp connection found, opening new one\n");
/* create tcp connection */
if ((c=tcpconn_connect(send_sock, to, type))==0){
LM_ERR("connect failed\n");
get_time_difference(get,tcpthreshold,tcp_timeout_con_get);
return -1;
}
c->refcnt++; /* safe to do it w/o locking, it's not yet
available to the rest of the world */
fd=c->s;
/* send the new tcpconn to "tcp main" */
response[0]=(long)c;
response[1]=CONN_NEW;
n=send_fd(unix_tcp_sock, response, sizeof(response), c->s);
get_time_difference(get,tcpthreshold,tcp_timeout_con_get);
if (n<=0){
LM_ERR("failed send_fd: %s (%d)\n", strerror(errno), errno);
n=-1;
goto end;
}
goto send_it;
}
get_fd:
get_time_difference(get,tcpthreshold,tcp_timeout_con_get);
/* todo: see if this is not the same process holding
* c and if so send directly on c->fd */
LM_DBG("tcp connection found (%p), acquiring fd\n", c);
/* get the fd */
response[0]=(long)c;
response[1]=CONN_GET_FD;
start_expire_timer(rcv,tcpthreshold);
n=send_all(unix_tcp_sock, response, sizeof(response));
if (n<=0){
LM_ERR("failed to get fd(write):%s (%d)\n",
strerror(errno), errno);
n=-1;
get_time_difference(rcv,tcpthreshold,tcp_timeout_receive_fd);
goto release_c;
}
LM_DBG("c= %p, n=%d\n", c, n);
tmp=c;
n=receive_fd(unix_tcp_sock, &c, sizeof(c), &fd, MSG_WAITALL);
get_time_difference(rcv,tcpthreshold,tcp_timeout_receive_fd);
if (n<=0){
LM_ERR("failed to get fd(receive_fd):"
" %s (%d)\n", strerror(errno), errno);
n=-1;
goto release_c;
}
if (c!=tmp){
LM_CRIT("got different connection:"
" %p (id= %d, refcnt=%d state=%d != "
" %p (id= %d, refcnt=%d state=%d (n=%d)\n",
c, c->id, c->refcnt, c->state,
tmp, tmp->id, tmp->refcnt, tmp->state, n
);
n=-1; /* fail */
goto end;
}
LM_DBG("after receive_fd: c= %p n=%d fd=%d\n",c, n, fd);
send_it:
LM_DBG("sending...\n");
lock_get(&c->write_lock);
#ifdef USE_TLS
if (c->type==PROTO_TLS)
n=tls_blocking_write(c, fd, buf, len);
else
#endif
/* n=tcp_blocking_write(c, fd, buf, len); */
start_expire_timer(snd,tcpthreshold);
n=tsend_stream(fd, buf, len, tcp_send_timeout*1000);
get_time_difference(snd,tcpthreshold,tcp_timeout_send);
stop_expire_timer(get,tcpthreshold,0,buf,(int)len,1);
lock_release(&c->write_lock);
LM_DBG("after write: c= %p n=%d fd=%d\n",c, n, fd);
LM_DBG("buf=\n%.*s\n", (int)len, buf);
if (n<0){
LM_ERR("failed to send\n");
/* error on the connection , mark it as bad and set 0 timeout */
c->state=S_CONN_BAD;
c->timeout=0;
/* tell "main" it should drop this (optional it will t/o anyway?)*/
response[0]=(long)c;
response[1]=CONN_ERROR;
n=send_all(unix_tcp_sock, response, sizeof(response));
/* CONN_ERROR will auto-dec refcnt => we must not call tcpconn_put !!*/
if (n<=0){
LM_ERR("return failed (write):%s (%d)\n",
strerror(errno), errno);
}
close(fd);
return -1; /* error return, no tcpconn_put */
}
end:
close(fd);
release_c:
tcpconn_put(c); /* release c (lock; dec refcnt; unlock) */
return n;
}
/* WARNING: - dst_cell contains the created cell, but it is un-referenced
* (before using it make sure you REF() it first)
* - if ACK (method==ACK), a cell will be created but it will not
* be added in the hash table (should be either deleted by the
* caller)
*/
static inline int t_uac_prepare(uac_req_t *uac_r,
struct retr_buf **dst_req,
struct cell **dst_cell)
{
struct dest_info dst;
struct cell *new_cell;
struct retr_buf *request;
char* buf;
int buf_len, ret;
unsigned int hi;
int is_ack;
ticks_t lifetime;
#ifdef USE_DNS_FAILOVER
struct dns_srv_handle dns_h;
#endif
long nhtype;
#ifdef WITH_EVENT_LOCAL_REQUEST
struct cell *backup_t;
int backup_branch;
unsigned int backup_msgid;
static struct sip_msg lreq;
char *buf1;
int buf_len1;
int sflag_bk;
int backup_route_type;
#endif
snd_flags_t snd_flags;
tm_xlinks_t backup_xd;
tm_xdata_t local_xd;
ret=-1;
hi=0; /* make gcc happy */
/*if (dst_req) *dst_req = NULL;*/
is_ack = (((uac_r->method->len == 3) && (memcmp("ACK", uac_r->method->s, 3)==0)) ? 1 : 0);
/*** added by dcm
* - needed by external ua to send a request within a dlg
*/
if ((nhtype = w_calculate_hooks(uac_r->dialog)) < 0)
/* if err's returned, the message is incorrect */
goto error2;
if (!uac_r->dialog->loc_seq.is_set) {
/* this is the first request in the dialog,
set cseq to default value now - Miklos */
uac_r->dialog->loc_seq.value = DEFAULT_CSEQ;
uac_r->dialog->loc_seq.is_set = 1;
}
DBG("DEBUG:tm:t_uac: next_hop=<%.*s>\n",uac_r->dialog->hooks.next_hop->len,
uac_r->dialog->hooks.next_hop->s);
/* new message => take the dialog send_socket if set, or the default
send_socket if not*/
SND_FLAGS_INIT(&snd_flags);
#ifdef USE_DNS_FAILOVER
if (cfg_get(core, core_cfg, use_dns_failover)){
dns_srv_handle_init(&dns_h);
if ((uri2dst2(&dns_h, &dst, uac_r->dialog->send_sock, snd_flags,
uac_r->dialog->hooks.next_hop, PROTO_NONE)==0)
|| (dst.send_sock==0)){
dns_srv_handle_put(&dns_h);
ser_error = E_NO_SOCKET;
ret=ser_error;
LOG(L_ERR, "t_uac: no socket found\n");
goto error2;
}
dns_srv_handle_put(&dns_h); /* not needed anymore */
}else{
if ((uri2dst2(0, &dst, uac_r->dialog->send_sock, snd_flags,
uac_r->dialog->hooks.next_hop, PROTO_NONE)==0) ||
(dst.send_sock==0)){
ser_error = E_NO_SOCKET;
ret=ser_error;
LOG(L_ERR, "t_uac: no socket found\n");
goto error2;
}
}
#else /* USE_DNS_FAILOVER */
if ((uri2dst2(&dst, uac_r->dialog->send_sock, snd_flags,
uac_r->dialog->hooks.next_hop, PROTO_NONE)==0) ||
(dst.send_sock==0)){
ser_error = E_NO_SOCKET;
ret=ser_error;
LOG(L_ERR, "t_uac: no socket found\n");
goto error2;
}
#endif /* USE_DNS_FAILOVER */
/* build cell sets X/AVP lists to new transaction structure
* => bakup in a tmp struct and restore afterwards */
memset(&local_xd, 0, sizeof(tm_xdata_t));
tm_xdata_replace(&local_xd, &backup_xd);
new_cell = build_cell(0);
tm_xdata_replace(0, &backup_xd);
if (!new_cell) {
ret=E_OUT_OF_MEM;
LOG(L_ERR, "t_uac: short of cell shmem\n");
goto error2;
}
if (uac_r->method->len==INVITE_LEN && memcmp(uac_r->method->s, INVITE, INVITE_LEN)==0){
new_cell->flags |= T_IS_INVITE_FLAG;
new_cell->flags|=T_AUTO_INV_100 &
(!cfg_get(tm, tm_cfg, tm_auto_inv_100) -1);
#ifdef WITH_AS_SUPPORT
if (uac_r->cb_flags & TMCB_DONT_ACK)
new_cell->flags |= T_NO_AUTO_ACK;
#endif
lifetime=cfg_get(tm, tm_cfg, tm_max_inv_lifetime);
}else
lifetime=cfg_get(tm, tm_cfg, tm_max_noninv_lifetime);
new_cell->flags |= T_IS_LOCAL_FLAG;
/* init timers hack, new_cell->fr_timer and new_cell->fr_inv_timer
* must be set, or else the fr will happen immediately
* we can't call init_new_t() because we don't have a sip msg
* => we'll ignore t_set_fr() or avp timer value and will use directly the
* module params fr_inv_timer and fr_timer -- andrei */
new_cell->fr_timeout=cfg_get(tm, tm_cfg, fr_timeout);
new_cell->fr_inv_timeout=cfg_get(tm, tm_cfg, fr_inv_timeout);
new_cell->end_of_life=get_ticks_raw()+lifetime;
#ifdef TM_DIFF_RT_TIMEOUT
/* same as above for retransmission intervals */
new_cell->rt_t1_timeout_ms = cfg_get(tm, tm_cfg, rt_t1_timeout_ms);
new_cell->rt_t2_timeout_ms = cfg_get(tm, tm_cfg, rt_t2_timeout_ms);
#endif
set_kr(REQ_FWDED);
request = &new_cell->uac[0].request;
request->dst = dst;
request->flags |= nhtype;
if (!is_ack) {
#ifdef TM_DEL_UNREF
INIT_REF(new_cell, 1); /* ref'ed only from the hash */
#endif
hi=dlg2hash(uac_r->dialog);
LOCK_HASH(hi);
insert_into_hash_table_unsafe(new_cell, hi);
UNLOCK_HASH(hi);
}
buf = build_uac_req(uac_r->method, uac_r->headers, uac_r->body, uac_r->dialog, 0, new_cell,
&buf_len, &dst);
if (!buf) {
LOG(L_ERR, "t_uac: Error while building message\n");
ret=E_OUT_OF_MEM;
goto error1;
}
#ifdef WITH_EVENT_LOCAL_REQUEST
if (unlikely(goto_on_local_req>=0)) {
DBG("executing event_route[tm:local-request]\n");
if(likely(build_sip_msg_from_buf(&lreq, buf, buf_len, inc_msg_no())
== 0)) {
/* fill some field in sip_msg */
if (unlikely(set_dst_uri(&lreq, uac_r->dialog->hooks.next_hop))) {
LM_ERR("failed to set dst_uri");
free_sip_msg(&lreq);
} else {
struct onsend_info onsnd_info;
lreq.force_send_socket = uac_r->dialog->send_sock;
lreq.rcv.proto = dst.send_sock->proto;
lreq.rcv.src_ip = dst.send_sock->address;
lreq.rcv.src_port = dst.send_sock->port_no;
lreq.rcv.dst_port = su_getport(&dst.to);
su2ip_addr(&lreq.rcv.dst_ip, &dst.to);
lreq.rcv.src_su=dst.send_sock->su;
lreq.rcv.bind_address=dst.send_sock;
#ifdef USE_COMP
lreq.rcv.comp=dst.comp;
#endif /* USE_COMP */
sflag_bk = getsflags();
tm_xdata_swap(new_cell, &backup_xd, 0);
onsnd_info.to=&dst.to;
onsnd_info.send_sock=dst.send_sock;
onsnd_info.buf=buf;
onsnd_info.len=buf_len;
p_onsend=&onsnd_info;
/* run the route */
backup_route_type = get_route_type();
set_route_type(LOCAL_ROUTE);
/* set T to the current transaction */
backup_t=get_t();
backup_branch=get_t_branch();
backup_msgid=global_msg_id;
/* fake transaction and message id */
global_msg_id=lreq.id;
set_t(new_cell, T_BR_UNDEFINED);
run_top_route(event_rt.rlist[goto_on_local_req], &lreq, 0);
/* restore original environment */
set_t(backup_t, backup_branch);
global_msg_id=backup_msgid;
set_route_type( backup_route_type );
p_onsend=0;
/* restore original environment */
tm_xdata_swap(new_cell, &backup_xd, 1);
setsflagsval(sflag_bk);
if (unlikely(lreq.new_uri.s))
{
pkg_free(lreq.new_uri.s);
lreq.new_uri.s=0;
lreq.new_uri.len=0;
}
if (unlikely(lreq.dst_uri.s))
{
pkg_free(lreq.dst_uri.s);
lreq.dst_uri.s=0;
lreq.dst_uri.len=0;
}
if (unlikely(lreq.add_rm || lreq.body_lumps)) {
LM_DBG("apply new updates to sip msg\n");
buf1 = build_req_buf_from_sip_req(&lreq,
(unsigned int*)&buf_len1,
&dst, BUILD_NO_LOCAL_VIA|BUILD_NO_VIA1_UPDATE|
BUILD_IN_SHM);
if (likely(buf1)){
shm_free(buf);
buf = buf1;
buf_len = buf_len1;
/* a possible change of the method is not handled! */
}
}
lreq.buf=0; /* covers the obsolete DYN_BUF */
free_sip_msg(&lreq);
}
}
}
#endif
new_cell->method.s = buf;
new_cell->method.len = uac_r->method->len;
request->buffer = buf;
request->buffer_len = buf_len;
new_cell->nr_of_outgoings++;
/* Register the callbacks after everything is successful and nothing can fail.
Otherwise the callback parameter would be freed twise, once from TMCB_DESTROY,
and again because of the negative return code. */
if(uac_r->cb && insert_tmcb(&(new_cell->tmcb_hl), uac_r->cb_flags,
*(uac_r->cb), uac_r->cbp, NULL)!=1){
ret=E_OUT_OF_MEM;
LOG(L_ERR, "t_uac: short of tmcb shmem\n");
goto error1;
}
if (has_local_reqin_tmcbs())
run_local_reqin_callbacks(new_cell, 0, 0);
#ifdef DIALOG_CALLBACKS
run_trans_dlg_callbacks(uac_r->dialog, new_cell, request);
#endif /* DIALOG_CALLBACKS */
if (dst_req) *dst_req = request;
if (dst_cell) *dst_cell = new_cell;
else if(is_ack && dst_req==0){
free_cell(new_cell);
}
return 1;
error1:
if (!is_ack) {
LOCK_HASH(hi);
remove_from_hash_table_unsafe(new_cell);
UNLOCK_HASH(hi);
#ifdef TM_DEL_UNREF
UNREF_FREE(new_cell);
}else
#else
}
#endif
free_cell(new_cell);
error2:
return ret;
}
static int udp_read_req(struct socket_info *si, int* bytes_read)
{
struct receive_info ri;
int len;
#ifdef DYN_BUF
char* buf;
#else
static char buf [BUF_SIZE+1];
#endif
char *tmp;
unsigned int fromlen;
callback_list* p;
str msg;
#ifdef DYN_BUF
buf=pkg_malloc(BUF_SIZE+1);
if (buf==0){
LM_ERR("could not allocate receive buffer\n");
goto error;
}
#endif
fromlen=sockaddru_len(si->su);
len=recvfrom(bind_address->socket, buf, BUF_SIZE,0,&ri.src_su.s,&fromlen);
if (len==-1){
if (errno==EAGAIN)
return 0;
if ((errno==EINTR)||(errno==EWOULDBLOCK)|| (errno==ECONNREFUSED))
return -1;
LM_ERR("recvfrom:[%d] %s\n", errno, strerror(errno));
return -2;
}
if (len<MIN_UDP_PACKET) {
LM_DBG("probing packet received len = %d\n", len);
return 0;
}
/* we must 0-term the messages, receive_msg expects it */
buf[len]=0; /* no need to save the previous char */
ri.bind_address = si;
ri.dst_port = si->port_no;
ri.dst_ip = si->address;
ri.proto = si->proto;
ri.proto_reserved1 = ri.proto_reserved2 = 0;
su2ip_addr(&ri.src_ip, &ri.src_su);
ri.src_port=su_getport(&ri.src_su);
msg.s = buf;
msg.len = len;
/* run callbacks if looks like non-SIP message*/
if( !isalpha(msg.s[0]) ){ /* not-SIP related */
for(p = cb_list; p; p = p->next){
if(p->b == msg.s[1]){
if (p->func(bind_address->socket, &ri, &msg, p->param)==0){
/* buffer consumed by callback */
break;
}
}
}
if (p) return 0;
}
if (ri.src_port==0){
tmp=ip_addr2a(&ri.src_ip);
LM_INFO("dropping 0 port packet from %s\n", tmp);
return 0;
}
/* receive_msg must free buf too!*/
receive_msg( msg.s, msg.len, &ri);
return 0;
}
static int hep_udp_read_req(struct socket_info *si, int* bytes_read)
{
struct receive_info ri;
int len;
#ifdef DYN_BUF
char* buf;
#else
static char buf [BUF_SIZE+1];
#endif
char *tmp;
unsigned int fromlen;
str msg;
struct hep_desc h;
int ret = 0;
#ifdef DYN_BUF
buf=pkg_malloc(BUF_SIZE+1);
if (buf==0){
LM_ERR("could not allocate receive buffer\n");
goto error;
}
#endif
fromlen=sockaddru_len(si->su);
len=recvfrom(bind_address->socket, buf, BUF_SIZE,0,&ri.src_su.s,&fromlen);
if (len==-1){
if (errno==EAGAIN)
return 0;
if ((errno==EINTR)||(errno==EWOULDBLOCK)|| (errno==ECONNREFUSED))
return -1;
LM_ERR("recvfrom:[%d] %s\n", errno, strerror(errno));
return -2;
}
if (len<MIN_UDP_PACKET) {
LM_DBG("probing packet received len = %d\n", len);
return 0;
}
/* we must 0-term the messages, receive_msg expects it */
buf[len]=0; /* no need to save the previous char */
ri.bind_address = si;
ri.dst_port = si->port_no;
ri.dst_ip = si->address;
ri.proto = si->proto;
ri.proto_reserved1 = ri.proto_reserved2 = 0;
su2ip_addr(&ri.src_ip, &ri.src_su);
ri.src_port=su_getport(&ri.src_su);
msg.s = buf;
msg.len = len;
/* if udp we are sure that version 1 or 2 of the
* protocol is used */
if (unpack_hepv2(buf, len, &h)) {
LM_ERR("hep unpacking failed\n");
return -1;
}
/* run hep callbacks if looks like non-SIP message*/
if( !isalpha(msg.s[0]) ) { /* not-SIP related */
ret=run_hep_cbs(&h, &ri);
if (ret < 0) {
LM_ERR("failed to run hep callbacks\n");
return -1;
}
/* remove the hep header; leave only the payload */
memmove(buf, h.u.hepv12.payload,
/* also copy '\0' character */
strlen(h.u.hepv12.payload)+1);
msg.s = buf;
msg.len = strlen(buf);
}
if (ri.src_port==0){
tmp=ip_addr2a(&ri.src_ip);
LM_INFO("dropping 0 port packet for %s\n", tmp);
return 0;
}
if (ret != HEP_SCRIPT_SKIP) {
/* receive_msg must free buf too!*/
receive_msg( msg.s, msg.len, &ri);
}
return 0;
}
static int hep_tcp_send (struct socket_info* send_sock,
char *buf, unsigned int len, union sockaddr_union *to, int id)
{
struct tcp_connection *c;
int port=0;
struct ip_addr ip;
int fd, n;
if (to) {
su2ip_addr(&ip, to);
port=su_getport(to);
n = tcp_conn_get(id,&ip, port, &c, &fd);
} else if (id) {
n = tcp_conn_get(id, 0, 0, &c, &fd);
} else {
LM_CRIT("tcp_send called with null id & to\n");
return -1;
}
if (n < 0) {
/* error during conn get, return with error too */
LM_ERR("failed to aquire connection\n");
return -1;
}
/* was connection found ?? */
if (c==0) {
if (tcp_no_new_conn) {
return -1;
}
if (!to) {
LM_ERR("Unknown destination - cannot open new tcp connection\n");
return -1;
}
LM_DBG("no open tcp connection found, opening new one, async = %d\n",hep_async);
/* create tcp connection */
if (hep_async) {
n = tcpconn_async_connect(send_sock, to, buf, len, &c, &fd);
if ( n<0 ) {
LM_ERR("async TCP connect failed\n");
return -1;
}
/* connect succeded, we have a connection */
if (n==0) {
/* connect is still in progress, break the sending
* flow now (the actual write will be done when
* connect will be completed */
LM_DBG("Succesfully started async connection \n");
tcp_conn_release(c, 0);
return len;
}
/* our first connect attempt succeeded - go ahead as normal */
} else if ((c=hep_sync_connect(send_sock, to, &fd))==0) {
LM_ERR("connect failed\n");
return -1;
}
goto send_it;
}
/* now we have a connection, let's see what we can do with it */
/* BE CAREFUL now as we need to release the conn before exiting !!! */
if (fd==-1) {
/* connection is not writable because of its state - can we append
* data to it for later writting (async writting)? */
if (c->state==S_CONN_CONNECTING) {
/* the connection is currently in the process of getting
* connected - let's append our send chunk as well - just in
* case we ever manage to get through */
LM_DBG("We have acquired a TCP connection which is still "
"pending to connect - delaying write \n");
n = add_write_chunk(c,buf,len,1);
if (n < 0) {
LM_ERR("Failed to add another write chunk to %p\n",c);
/* we failed due to internal errors - put the
* connection back */
tcp_conn_release(c, 0);
return -1;
}
/* we succesfully added our write chunk - success */
tcp_conn_release(c, 0);
return len;
} else {
/* return error, nothing to do about it */
tcp_conn_release(c, 0);
return -1;
}
}
send_it:
LM_DBG("sending via fd %d...\n",fd);
n = _hep_write_on_socket(c, fd, buf, len);
tcp_conn_set_lifetime( c, tcp_con_lifetime);
LM_DBG("after write: c= %p n=%d fd=%d\n",c, n, fd);
/* LM_DBG("buf=\n%.*s\n", (int)len, buf); */
if (n<0){
LM_ERR("failed to send\n");
c->state=S_CONN_BAD;
if (c->proc_id != process_no)
close(fd);
tcp_conn_release(c, 0);
return -1;
}
/* only close the FD if not already in the context of our process
either we just connected, or main sent us the FD */
if (c->proc_id != process_no)
close(fd);
tcp_conn_release(c, (n<len)?1:0/*pending data in async mode?*/ );
return n;
}
static int hep_udp_read_req(struct socket_info *si, int* bytes_read)
{
struct receive_info ri;
int len;
#ifdef DYN_BUF
char* buf;
#else
static char buf [BUF_SIZE+1];
#endif
char *tmp;
unsigned int fromlen;
str msg;
struct hep_context *hep_ctx;
int ret = 0;
context_p ctx=NULL;
#ifdef DYN_BUF
buf=pkg_malloc(BUF_SIZE+1);
if (buf==0){
LM_ERR("could not allocate receive buffer\n");
goto error;
}
#endif
fromlen=sockaddru_len(si->su);
len=recvfrom(bind_address->socket, buf, BUF_SIZE,0,&ri.src_su.s,&fromlen);
if (len==-1){
if (errno==EAGAIN)
return 0;
if ((errno==EINTR)||(errno==EWOULDBLOCK)|| (errno==ECONNREFUSED))
return -1;
LM_ERR("recvfrom:[%d] %s\n", errno, strerror(errno));
return -2;
}
if (len<MIN_UDP_PACKET) {
LM_DBG("probing packet received len = %d\n", len);
return 0;
}
/* we must 0-term the messages, receive_msg expects it */
buf[len]=0; /* no need to save the previous char */
ri.bind_address = si;
ri.dst_port = si->port_no;
ri.dst_ip = si->address;
ri.proto = si->proto;
ri.proto_reserved1 = ri.proto_reserved2 = 0;
su2ip_addr(&ri.src_ip, &ri.src_su);
ri.src_port=su_getport(&ri.src_su);
/* if udp we are sure that version 1 or 2 of the
* protocol is used */
if ((hep_ctx = shm_malloc(sizeof(struct hep_context))) == NULL) {
LM_ERR("no more shared memory!\n");
return -1;
}
memset(hep_ctx, 0, sizeof(struct hep_context));
memcpy(&hep_ctx->ri, &ri, sizeof(struct receive_info));
if (len < 4) {
LM_ERR("invalid message! too short!\n");
return -1;
}
if (!memcmp(buf, HEP_HEADER_ID, HEP_HEADER_ID_LEN)) {
/* HEPv3 */
if (unpack_hepv3(buf, len, &hep_ctx->h)) {
LM_ERR("hepv3 unpacking failed\n");
return -1;
}
} else {
/* HEPv2 */
if (unpack_hepv12(buf, len, &hep_ctx->h)) {
LM_ERR("hepv12 unpacking failed\n");
return -1;
}
}
/* set context for receive_msg */
if ((ctx=context_alloc(CONTEXT_GLOBAL)) == NULL) {
LM_ERR("failed to allocate new context! skipping...\n");
goto error_free_hep;
}
memset(ctx, 0, context_size(CONTEXT_GLOBAL));
context_put_ptr(CONTEXT_GLOBAL, ctx, hep_ctx_idx, hep_ctx);
update_recv_info(&ri, &hep_ctx->h);
/* run hep callbacks; set the current processing context
* to hep context; this way callbacks will have all the data
* needed */
current_processing_ctx = ctx;
ret=run_hep_cbs();
if (ret < 0) {
LM_ERR("failed to run hep callbacks\n");
return -1;
}
current_processing_ctx = NULL;
if (hep_ctx->h.version == 3) {
/* HEPv3 */
msg.len =
hep_ctx->h.u.hepv3.payload_chunk.chunk.length- sizeof(hep_chunk_t);
msg.s = hep_ctx->h.u.hepv3.payload_chunk.data;
} else {
/* HEPv12 */
msg.len = len - hep_ctx->h.u.hepv12.hdr.hp_l;
msg.s = buf + hep_ctx->h.u.hepv12.hdr.hp_l;
if (hep_ctx->h.u.hepv12.hdr.hp_v == 2) {
msg.s += sizeof(struct hep_timehdr);
msg.len -= sizeof(struct hep_timehdr);
}
}
if (ri.src_port==0){
tmp=ip_addr2a(&ri.src_ip);
LM_INFO("dropping 0 port packet for %s\n", tmp);
return 0;
}
if (ret != HEP_SCRIPT_SKIP) {
/* receive_msg must free buf too!*/
receive_msg( msg.s, msg.len, &ri, ctx);
}
return 0;
error_free_hep:
shm_free(hep_ctx);
return -1;
}
/** removes first via & sends msg to the second
* - mode param controls if modules sip response callbacks are executed */
static int do_forward_reply(struct sip_msg* msg, int mode)
{
char* new_buf;
struct dest_info dst;
unsigned int new_len;
int r;
struct ip_addr ip;
#ifdef USE_TCP
char* s;
int len;
#endif
init_dest_info(&dst);
new_buf=0;
/*check if first via host = us */
if (check_via){
if (check_self(&msg->via1->host,
msg->via1->port?msg->via1->port:SIP_PORT,
msg->via1->proto)!=1){
LM_ERR("host in first via!=me : %.*s:%d\n",
msg->via1->host.len, msg->via1->host.s, msg->via1->port);
/* send error msg back? */
goto error;
}
}
/* check modules response_f functions */
if(likely(mode==0)) {
for (r=0; r<mod_response_cbk_no; r++)
if (mod_response_cbks[r](msg)==0) goto skip;
}
/* we have to forward the reply stateless, so we need second via -bogdan*/
if (parse_headers( msg, HDR_VIA2_F, 0 )==-1
|| (msg->via2==0) || (msg->via2->error!=PARSE_OK))
{
/* no second via => error */
LM_DBG("reply cannot be forwarded - no 2nd via\n");
goto error;
}
new_buf = build_res_buf_from_sip_res( msg, &new_len);
if (!new_buf){
LM_ERR("building failed\n");
goto error;
}
dst.proto=msg->via2->proto;
SND_FLAGS_OR(&dst.send_flags, &msg->fwd_send_flags, &msg->rpl_send_flags);
if (update_sock_struct_from_via( &dst.to, msg, msg->via2 )==-1) goto error;
#ifdef USE_COMP
dst.comp=msg->via2->comp_no;
#endif
#if defined USE_TCP || defined USE_SCTP
if (
#ifdef USE_TCP
dst.proto==PROTO_TCP
|| dst.proto==PROTO_WS
#ifdef USE_TLS
|| dst.proto==PROTO_TLS
|| dst.proto==PROTO_WSS
#endif
#ifdef USE_SCTP
||
#endif /* USE_SCTP */
#endif /* USE_TCP */
#ifdef USE_SCTP
dst.proto==PROTO_SCTP
#endif /* USE_SCTP */
){
/* find id in i param if it exists */
if (msg->via1->i && msg->via1->i->value.s){
s=msg->via1->i->value.s;
len=msg->via1->i->value.len;
LM_DBG("i=%.*s\n",len, ZSW(s));
if (reverse_hex2int(s, len, (unsigned int*)&dst.id)<0){
LM_ERR("bad via i param \"%.*s\"\n", len, ZSW(s));
dst.id=0;
}
}
}
#endif
apply_force_send_socket(&dst, msg);
/* call onsend_route */
if(dst.send_sock == NULL) {
dst.send_sock=get_send_socket(msg, &dst.to, dst.proto);
if (dst.send_sock==0){
LM_ERR("cannot forward reply\n");
goto done;
}
}
if (onsend_route_enabled(SIP_REPLY)){
if (run_onsend(msg, &dst, new_buf, new_len)==0){
su2ip_addr(&ip, &(dst.to));
LM_ERR("reply to %s:%d(%d) dropped (onsend_route)\n",
ip_addr2a(&ip), su_getport(&(dst.to)), dst.proto);
goto error; /* error ? */
}
}
if (msg_send(&dst, new_buf, new_len)<0)
{
STATS_RPL_FWD_DROP();
goto error;
}
done:
#ifdef STATS
STATS_TX_RESPONSE( (msg->first_line.u.reply.statuscode/100) );
#endif
LM_DBG("reply forwarded to %.*s:%d\n",
msg->via2->host.len, msg->via2->host.s,
(unsigned short) msg->via2->port);
STATS_RPL_FWD_OK();
pkg_free(new_buf);
skip:
return 0;
error:
if (new_buf) pkg_free(new_buf);
return -1;
}
struct tcp_conn* create_tcp_conn( int s, union sockaddr_union *src_su,
struct socket_info *dst_si, tcp_conn_state init_state)
{
struct tcp_conn *conn;
int h;
if (tcp_connections_no>=tcp_max_connections) {
LM_ERR("maximum number of connections exceeded: %d/%d\n",
tcp_connections_no, tcp_max_connections);
close(s);
return NULL;
}
tcp_connections_no++; //make it atomic - FIXME
/* allocate structure */
conn = (struct tcp_conn*)shm_malloc(sizeof(struct tcp_conn));
if (conn==NULL){
LM_ERR("no more pkg memory\n");
return NULL;
}
memset(conn, 0, sizeof(struct tcp_conn));
/* init lock */
if (lock_init(&conn->state_lock)==0){
LM_ERR("init lock failed\n");
goto error;
}
conn->state = init_state;
conn->timeout = get_ticks() + tcp_lifetime;
/* src info */
conn->rcv.src_su = *src_su;
su2ip_addr(&conn->rcv.src_ip, src_su);
conn->rcv.src_port=su_getport(src_su);
/* dst info */
conn->rcv.bind_address = dst_si;
conn->rcv.dst_ip = dst_si->address;
conn->rcv.dst_port = dst_si->port;
conn->rcv.proto = PROTO_TCP;
conn->socket = s;
LM_DBG("new tcp connection with: %s:%d\n",
ip_addr2a(&conn->rcv.src_ip),conn->rcv.src_port);
/* add to the hashes */
lock_get( &hash_id_lock );
/* refed by the hash */
conn->ref = 1;
conn->id = last_tcp_id;
h = tcp_hash(conn->id,0);
tcp_hash_add_unsafe(conn,id,h);
lock_release( &hash_id_lock );
lock_get( &hash_ip_lock );
h = tcp_hash(conn->rcv.src_ip.u.addr32[0],conn->rcv.src_port);
tcp_hash_add_unsafe(conn,ip,h);
lock_release( &hash_ip_lock );
return conn;
error:
shm_free(conn);
return NULL;
}
/* finds a tcpconn & sends on it */
int tcp_send(int type, char* buf, unsigned len, union sockaddr_union* to,
int id)
{
struct tcp_connection *c;
struct tcp_connection *tmp;
struct ip_addr ip;
int port;
int fd;
long response[2];
int n;
port=0;
if (to){
su2ip_addr(&ip, to);
port=su_getport(to);
c=tcpconn_get(id, &ip, port, TCP_CON_SEND_TIMEOUT);
}else if (id){
c=tcpconn_get(id, 0, 0, TCP_CON_SEND_TIMEOUT);
}else{
LOG(L_CRIT, "BUG: tcp_send called with null id & to\n");
return -1;
}
if (id){
if (c==0) {
if (to){
/* try again w/o id */
c=tcpconn_get(0, &ip, port, TCP_CON_SEND_TIMEOUT);
goto no_id;
}else{
LOG(L_ERR, "ERROR: tcp_send: id %d not found, dropping\n",
id);
return -1;
}
}else goto get_fd;
}
no_id:
if (c==0){
DBG("tcp_send: no open tcp connection found, opening new one\n");
/* create tcp connection */
if ((c=tcpconn_connect(to, type))==0){
LOG(L_ERR, "ERROR: tcp_send: connect failed\n");
return -1;
}
c->refcnt++; /* safe to do it w/o locking, it's not yet
available to the rest of the world */
fd=c->s;
/* send the new tcpconn to "tcp main" */
response[0]=(long)c;
response[1]=CONN_NEW;
n=send_all(unix_tcp_sock, response, sizeof(response));
if (n<=0){
LOG(L_ERR, "BUG: tcp_send: failed write: %s (%d)\n",
strerror(errno), errno);
n=-1;
goto end;
}
n=send_fd(unix_tcp_sock, &c, sizeof(c), c->s);
if (n<=0){
LOG(L_ERR, "BUG: tcp_send: failed send_fd: %s (%d)\n",
strerror(errno), errno);
n=-1;
goto end;
}
goto send_it;
}
get_fd:
/* todo: see if this is not the same process holding
* c and if so send directly on c->fd */
DBG("tcp_send: tcp connection found (%p), acquiring fd\n", c);
/* get the fd */
response[0]=(long)c;
response[1]=CONN_GET_FD;
n=send_all(unix_tcp_sock, response, sizeof(response));
if (n<=0){
LOG(L_ERR, "BUG: tcp_send: failed to get fd(write):%s (%d)\n",
strerror(errno), errno);
n=-1;
goto release_c;
}
DBG("tcp_send, c= %p, n=%d\n", c, n);
tmp=c;
n=receive_fd(unix_tcp_sock, &c, sizeof(c), &fd);
if (n<=0){
LOG(L_ERR, "BUG: tcp_send: failed to get fd(receive_fd):"
" %s (%d)\n", strerror(errno), errno);
n=-1;
goto release_c;
}
if (c!=tmp){
LOG(L_CRIT, "BUG: tcp_send: get_fd: got different connection:"
" %p (id= %d, refcnt=%d state=%d != "
" %p (id= %d, refcnt=%d state=%d (n=%d)\n",
c, c->id, c->refcnt, c->state,
tmp, tmp->id, tmp->refcnt, tmp->state, n
);
n=-1; /* fail */
goto end;
}
DBG("tcp_send: after receive_fd: c= %p n=%d fd=%d\n",c, n, fd);
send_it:
DBG("tcp_send: sending...\n");
lock_get(&c->write_lock);
#ifdef USE_TLS
if (c->type==PROTO_TLS)
n=tls_blocking_write(c, fd, buf, len);
else
#endif
n=tcp_blocking_write(c, fd, buf, len);
lock_release(&c->write_lock);
DBG("tcp_send: after write: c= %p n=%d fd=%d\n",c, n, fd);
DBG("tcp_send: buf=\n%.*s\n", (int)len, buf);
if (n<0){
LOG(L_ERR, "ERROR: tcp_send: failed to send\n");
/* error on the connection , mark it as bad and set 0 timeout */
c->state=S_CONN_BAD;
c->timeout=0;
/* tell "main" it should drop this (optional it will t/o anyway?)*/
response[0]=(long)c;
response[1]=CONN_ERROR;
n=send_all(unix_tcp_sock, response, sizeof(response));
/* CONN_ERROR will auto-dec refcnt => we must not call tcpconn_put !!*/
if (n<=0){
LOG(L_ERR, "BUG: tcp_send: error return failed (write):%s (%d)\n",
strerror(errno), errno);
n=-1;
}
close(fd);
return n; /* error return, no tcpconn_put */
}
end:
close(fd);
release_c:
tcpconn_put(c); /* release c (lock; dec refcnt; unlock) */
return n;
}
static void trace_sl_onreply_out( unsigned int types, struct sip_msg* req,
struct sl_cb_param *sl_param)
{
db_key_t db_keys[NR_KEYS];
db_val_t db_vals[NR_KEYS];
static char fromip_buff[IP_ADDR_MAX_STR_SIZE+12];
static char toip_buff[IP_ADDR_MAX_STR_SIZE+12];
int faked = 0;
struct sip_msg* msg;
int_str avp_value;
struct usr_avp *avp;
struct ip_addr to_ip;
int len;
char statusbuf[5];
if(req==NULL || sl_param==NULL)
{
LM_ERR("bad parameters\n");
goto error;
}
avp = NULL;
if(traced_user_avp.n!=0)
avp=search_first_avp(traced_user_avp_type, traced_user_avp,
&avp_value, 0);
if((avp==NULL) && trace_is_off(req))
{
LM_DBG("trace off...\n");
return;
}
msg = req;
faked = 1;
if(parse_from_header(msg)==-1 || msg->from==NULL || get_from(msg)==NULL)
{
LM_ERR("cannot parse FROM header\n");
goto error;
}
if(parse_headers(msg, HDR_CALLID_F, 0)!=0)
{
LM_ERR("cannot parse call-id\n");
return;
}
db_keys[0] = msg_column;
db_vals[0].type = DB_BLOB;
db_vals[0].nul = 0;
db_vals[0].val.blob_val.s = (sl_param->buffer)?sl_param->buffer->s:"";
db_vals[0].val.blob_val.len = (sl_param->buffer)?sl_param->buffer->len:0;
/* check Call-ID header */
if(msg->callid==NULL || msg->callid->body.s==NULL)
{
LM_ERR("cannot find Call-ID header!\n");
goto error;
}
db_keys[1] = callid_column;
db_vals[1].type = DB_STR;
db_vals[1].nul = 0;
db_vals[1].val.str_val.s = msg->callid->body.s;
db_vals[1].val.str_val.len = msg->callid->body.len;
db_keys[2] = method_column;
db_vals[2].type = DB_STR;
db_vals[2].nul = 0;
db_vals[2].val.str_val.s = msg->first_line.u.request.method.s;
db_vals[2].val.str_val.len = msg->first_line.u.request.method.len;
db_keys[4] = fromip_column;
db_vals[4].type = DB_STRING;
db_vals[4].nul = 0;
if(trace_local_ip)
db_vals[4].val.string_val = trace_local_ip;
else {
siptrace_copy_proto(msg->rcv.proto, fromip_buff);
strcat(fromip_buff, ip_addr2a(&req->rcv.dst_ip));
strcat(fromip_buff,":");
strcat(fromip_buff, int2str(req->rcv.dst_port, NULL));
db_vals[4].val.string_val = fromip_buff;
}
db_keys[3] = status_column;
db_vals[3].type = DB_STRING;
db_vals[3].nul = 0;
strcpy(statusbuf, int2str(sl_param->code, NULL));
db_vals[3].val.string_val = statusbuf;
db_keys[5] = toip_column;
db_vals[5].type = DB_STRING;
db_vals[5].nul = 0;
memset(&to_ip, 0, sizeof(struct ip_addr));
if(sl_param->dst==0)
{
db_vals[5].val.string_val = "any:255.255.255.255";
} else {
su2ip_addr(&to_ip, sl_param->dst);
siptrace_copy_proto(req->rcv.proto, toip_buff);
strcat(toip_buff, ip_addr2a(&to_ip));
strcat(toip_buff, ":");
strcat(toip_buff,
int2str((unsigned long)su_getport(sl_param->dst), &len));
LM_DBG("dest [%s]\n", toip_buff);
db_vals[5].val.string_val = toip_buff;
}
db_keys[6] = date_column;
db_vals[6].type = DB_DATETIME;
db_vals[6].nul = 0;
db_vals[6].val.time_val = time(NULL);
db_keys[7] = direction_column;
db_vals[7].type = DB_STRING;
db_vals[7].nul = 0;
db_vals[7].val.string_val = "out";
db_keys[8] = fromtag_column;
db_vals[8].type = DB_STR;
db_vals[8].nul = 0;
db_vals[8].val.str_val.s = get_from(msg)->tag_value.s;
db_vals[8].val.str_val.len = get_from(msg)->tag_value.len;
db_funcs.use_table(db_con, siptrace_get_table());
db_keys[9] = traced_user_column;
db_vals[9].type = DB_STR;
db_vals[9].nul = 0;
if( !trace_is_off(msg) ) {
db_vals[9].val.str_val.s = "";
db_vals[9].val.str_val.len = 0;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
#ifdef STATISTICS
update_stat(siptrace_rpl, 1);
#endif
}
if(avp==NULL)
goto done;
trace_send_duplicate(db_vals[0].val.blob_val.s,
db_vals[0].val.blob_val.len);
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("storing info...\n");
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
while(avp!=NULL)
{
db_vals[9].val.str_val.s = avp_value.s.s;
db_vals[9].val.str_val.len = avp_value.s.len;
LM_DBG("### - storing info (%d) ...\n", faked);
if(db_funcs.insert(db_con, db_keys, db_vals, NR_KEYS) < 0)
{
LM_ERR("error storing trace\n");
goto error;
}
avp = search_next_avp( avp, &avp_value);
}
done:
return;
error:
return;
}
