int select_nameaddr_params(str* res, select_t* s, struct sip_msg* msg)
{
char *p;
p=find_not_quoted(res, '<');
if (!p) {
p=find_not_quoted(res, ';');
} else {
res->len=res->len - (p-res->s) -1;
res->s=p +1;
p=find_not_quoted(res, '>');
if (!p) {
LM_ERR("no > found, invalid nameaddr value\n");
return -1;
}
res->len=res->len - (p-res->s) -1;
res->s=p +1;
p=find_not_quoted(res, ';');
}
if (!p) return 1;
res->len=res->len - (p-res->s) -1;
res->s=p +1;
if (s->param_offset[select_level+1]-s->param_offset[select_level]==1)
return (res->len ? 0 : 1);
return select_any_params(res, s, msg);
}
/*
* Parse name-addr part, the given string can be longer,
* parsing will stop when closing > is found
*/
int parse_nameaddr(str* _s, name_addr_t* _a)
{
char* uri_end;
if (!_s || !_a) {
LM_ERR("invalid parameter value\n");
return -1;
}
_a->name.s = _s->s;
_a->uri.s = find_not_quoted(_s, '<');
if (_a->uri.s) {
_a->name.len = _a->uri.s - _a->name.s;
_a->uri.s++; /* We will skip < character */
} else {
LM_ERR("no < found\n");
return -3;
}
_a->uri.len = _s->len - _a->name.len - 1;
uri_end = find_not_quoted(&_a->uri, '>');
if (!uri_end) {
LM_ERR("no > found\n");
return -4;
}
/* Total length of the field including <> */
_a->len = uri_end - _a->name.s + 1;
_a->uri.len = uri_end - _a->uri.s;
return 0;
}
int select_nameaddr_uri(str* res, select_t* s, struct sip_msg* msg)
{
char *p;
p=find_not_quoted(res, '<');
if (!p) {
LM_DBG("no < found, string up to first semicolon is uri\n");
p = q_memchr(res->s, ';', res->len);
if (p)
res->len = p-res->s;
return 0;
}
res->len=res->len - (p-res->s) -1;
res->s=p +1;
p=find_not_quoted(res, '>');
if (!p) {
LM_ERR("no > found, invalid nameaddr value\n");
return -1;
}
res->len=p-res->s;
return 0;
}
static inline int contains_extension_support(struct hdr_field *h,
str *extension)
{
/* "parses" Supported header and looks for extension */
str s, val;
char *c;
if (!h) return 0;
s = h->body;
while (s.len > 0) {
c = find_not_quoted(&s, ',');
if (c) {
val.s = s.s;
val.len = c - val.s;
trim(&val);
if (str_case_equals(&val, extension) == 0) return 1;
s.len = s.len - (c - s.s) - 1;
s.s = c + 1;
}
else {
trim(&s);
if (str_case_equals(&s, extension) == 0) return 1;
break;
}
}
return 0;
}
/*
* This function skips name part
* uri parsed by parse_contact must be used
* (the uri must not contain any leading or
* trailing part and if angle bracket were
* used, right angle bracket must be the
* last character in the string)
*
* _s will be modified so it should be a tmp
* copy
*/
void get_raw_uri(str* _s)
{
char* aq;
if (_s->s[_s->len - 1] == '>') {
aq = find_not_quoted(_s, '<');
_s->len -= aq - _s->s + 2;
_s->s = aq + 1;
}
}
int select_nameaddr_name(str* res, select_t* s, struct sip_msg* msg)
{
char *p;
p=find_not_quoted(res, '<');
if (!p) {
LM_DBG("no < found, whole string is uri\n");
res->len=0;
return 1;
}
res->len=p-res->s;
while (res->len && SP(res->s[res->len-1])) res->len--;
return 0;
}
/*
* Check if URI in RPID AVP contains an E164 user part
*/
int is_rpid_user_e164(struct sip_msg* _m, char* _s1, char* _s2)
{
struct usr_avp *avp;
name_addr_t parsed;
str tmp, rpid;
struct sip_uri uri;
int_str val;
if (rpid_avp_name==-1) {
LM_ERR("rpid avp not defined\n");
return -1;
}
if ( (avp=search_first_avp( rpid_avp_type , rpid_avp_name, &val, 0))==0 ) {
LM_DBG("no rpid AVP\n");
goto err;
}
if ( !(avp->flags&AVP_VAL_STR) || !val.s.s || !val.s.len) {
LM_DBG("empty or non-string rpid, nothing to append\n");
return -1;
}
rpid = val.s;
if (find_not_quoted(&rpid, '<')) {
if (parse_nameaddr(&rpid, &parsed) < 0) {
LM_ERR("failed to parse RPID\n");
goto err;
}
tmp = parsed.uri;
} else {
tmp = rpid;
}
if (parse_uri(tmp.s, tmp.len, &uri) < 0) {
LM_ERR("failed to parse RPID URI\n");
goto err;
}
return is_e164(&uri.user);
err:
return -1;
}
static int assemble_msg(struct sip_msg* msg, struct tw_info *twi)
{
static char id_buf[IDBUF_LEN];
static char route_buffer[ROUTE_BUFFER_MAX];
static char append_buf[APPEND_BUFFER_MAX];
static char cmd_buf[CMD_BUFFER_MAX];
static str empty_param = {".",1};
unsigned int hash_index, label;
contact_body_t* cb=0;
contact_t* c=0;
name_addr_t na;
rr_t* record_route;
struct hdr_field* p_hdr;
param_hooks_t hooks;
int l;
char* s, fproxy_lr;
str route, next_hop, append, tmp_s, body, str_uri;
if(msg->first_line.type != SIP_REQUEST){
LM_ERR("called for something else then a SIP request\n");
goto error;
}
/* parse all -- we will need every header field for a UAS */
if ( parse_headers(msg, HDR_EOH_F, 0)==-1) {
LM_ERR("parse_headers failed\n");
goto error;
}
/* find index and hash; (the transaction can be safely used due
* to refcounting till script completes) */
if( t_get_trans_ident(msg,&hash_index,&label) == -1 ) {
LM_ERR("t_get_trans_ident failed\n");
goto error;
}
/* parse from header */
if (msg->from->parsed==0 && parse_from_header(msg)<0 ) {
LM_ERR("failed to parse <From:> header\n");
goto error;
}
/* parse the RURI (doesn't make any malloc) */
msg->parsed_uri_ok = 0; /* force parsing */
if (parse_sip_msg_uri(msg)<0) {
LM_ERR("uri has not been parsed\n");
goto error;
}
/* parse contact header */
str_uri.s = 0;
str_uri.len = 0;
if(msg->contact) {
if (msg->contact->parsed==0 && parse_contact(msg->contact)<0) {
LM_ERR("failed to parse <Contact:> header\n");
goto error;
}
cb = (contact_body_t*)msg->contact->parsed;
if(cb && (c=cb->contacts)) {
str_uri = c->uri;
if (find_not_quoted(&str_uri,'<')) {
parse_nameaddr(&str_uri,&na);
str_uri = na.uri;
}
}
}
/* str_uri is taken from caller's contact or from header
* for backwards compatibility with pre-3261 (from is already parsed)*/
if(!str_uri.len || !str_uri.s)
str_uri = get_from(msg)->uri;
/* parse Record-Route headers */
route.s = s = route_buffer; route.len = 0;
fproxy_lr = 0;
next_hop = empty_param;
p_hdr = msg->record_route;
if(p_hdr) {
if (p_hdr->parsed==0 && parse_rr(p_hdr)!=0 ) {
LM_ERR("failed to parse 'Record-Route:' header\n");
goto error;
}
record_route = (rr_t*)p_hdr->parsed;
} else {
record_route = 0;
}
if( record_route ) {
if ( (tmp_s.s=find_not_quoted(&record_route->nameaddr.uri,';'))!=0 &&
tmp_s.s+1!=record_route->nameaddr.uri.s+
record_route->nameaddr.uri.len) {
/* Parse all parameters */
tmp_s.len = record_route->nameaddr.uri.len - (tmp_s.s-
record_route->nameaddr.uri.s);
if (parse_params( &tmp_s, CLASS_URI, &hooks,
&record_route->params) < 0) {
LM_ERR("failed to parse record route uri params\n");
goto error;
}
fproxy_lr = (hooks.uri.lr != 0);
LM_DBG("record_route->nameaddr.uri: %.*s\n",
record_route->nameaddr.uri.len,record_route->nameaddr.uri.s);
if(fproxy_lr){
LM_DBG("first proxy has loose routing\n");
copy_route(s,route.len,record_route->nameaddr.uri.s,
record_route->nameaddr.uri.len);
}
}
for(p_hdr = p_hdr->next;p_hdr;p_hdr = p_hdr->next) {
/* filter out non-RR hdr and empty hdrs */
if( (p_hdr->type!=HDR_RECORDROUTE_T) || p_hdr->body.len==0)
continue;
if(p_hdr->parsed==0 && parse_rr(p_hdr)!=0 ){
LM_ERR("failed to parse <Record-route:> header\n");
goto error;
}
for(record_route=p_hdr->parsed; record_route;
record_route=record_route->next){
LM_DBG("record_route->nameaddr.uri: <%.*s>\n",
record_route->nameaddr.uri.len,
record_route->nameaddr.uri.s);
copy_route(s,route.len,record_route->nameaddr.uri.s,
record_route->nameaddr.uri.len);
}
}
if(!fproxy_lr){
copy_route(s,route.len,str_uri.s,str_uri.len);
str_uri = ((rr_t*)msg->record_route->parsed)->nameaddr.uri;
} else {
next_hop = ((rr_t*)msg->record_route->parsed)->nameaddr.uri;
}
}
LM_DBG("calculated route: %.*s\n",route.len,route.len ? route.s : "");
LM_DBG("next r-uri: %.*s\n",str_uri.len,str_uri.len ? str_uri.s : "");
if ( REQ_LINE(msg).method_value==METHOD_INVITE ||
(twi->append && twi->append->add_body) ) {
/* get body */
if( (body.s = get_body(msg)) == 0 ){
LM_ERR("get_body failed\n");
goto error;
}
body.len = msg->len - (body.s - msg->buf);
} else {
body = empty_param;
}
/* flags & additional headers */
append.s = s = append_buf;
if (sizeof(flag_t)*2+12+1 >= APPEND_BUFFER_MAX) {
LM_ERR("buffer overflow while copying flags\n");
goto error;
}
append_str(s,"P-MsgFlags: ",12);
l = APPEND_BUFFER_MAX - (12+1); /* include trailing `\n'*/
if (int2reverse_hex(&s, &l, (int)msg->msg_flags) == -1) {
LM_ERR("buffer overflow while copying optional header\n");
goto error;
}
append_chr(s,'\n');
if ( twi->append && ((s=append2buf( s, APPEND_BUFFER_MAX-(s-append.s), msg,
twi->append->elems))==0) )
goto error;
/* body separator */
append_chr(s,'.');
append.len = s-append.s;
eol_line(1).s = s = cmd_buf;
if(twi->action.len+12 >= CMD_BUFFER_MAX){
LM_ERR("buffer overflow while copying command name\n");
goto error;
}
append_str(s,"sip_request.",12);
append_str(s,twi->action.s,twi->action.len);
eol_line(1).len = s-eol_line(1).s;
eol_line(2)=REQ_LINE(msg).method; /* method type */
eol_line(3)=msg->parsed_uri.user; /* user from r-uri */
eol_line(4)=msg->parsed_uri.host; /* domain */
eol_line(5)=msg->rcv.bind_address->address_str; /* dst ip */
eol_line(6)=msg->rcv.dst_port==SIP_PORT ?
empty_param : msg->rcv.bind_address->port_no_str; /* port */
/* r_uri ('Contact:' for next requests) */
eol_line(7)=*GET_RURI(msg);
/* r_uri for subsequent requests */
eol_line(8)=str_uri.len?str_uri:empty_param;
eol_line(9)=get_from(msg)->body; /* from */
eol_line(10)=msg->to->body; /* to */
eol_line(11)=msg->callid->body; /* callid */
eol_line(12)=get_from(msg)->tag_value; /* from tag */
eol_line(13)=get_to(msg)->tag_value; /* to tag */
eol_line(14)=get_cseq(msg)->number; /* cseq number */
eol_line(15).s=id_buf; /* hash:label */
s = int2str(hash_index, &l);
if (l+1>=IDBUF_LEN) {
LM_ERR("too big hash\n");
goto error;
}
memcpy(id_buf, s, l);
id_buf[l]=':';
eol_line(15).len=l+1;
s = int2str(label, &l);
if (l+1+eol_line(15).len>=IDBUF_LEN) {
LM_ERR("too big label\n");
goto error;
}
memcpy(id_buf+eol_line(15).len, s, l);
eol_line(15).len+=l;
eol_line(16) = route.len ? route : empty_param;
eol_line(17) = next_hop;
eol_line(18) = append;
eol_line(19) = body;
/* success */
return 1;
error:
/* 0 would lead to immediate script exit -- -1 returns
* with 'false' to script processing */
return -1;
}
