int th_unmask_ruri(sip_msg_t *msg)
{
str eval;
struct lump* l;
str out;
if(th_get_uri_param_value(&REQ_LINE(msg).uri, &th_uparam_name, &eval)<0
|| eval.len<=0)
return -1;
out.s = th_mask_decode(eval.s, eval.len,
&th_uparam_prefix, 0, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot decode r-uri\n");
return -1;
}
LM_DBG("+decoded: %d: [%.*s]\n", out.len, out.len, out.s);
l=del_lump(msg, REQ_LINE(msg).uri.s-msg->buf, REQ_LINE(msg).uri.len, 0);
if (l==0)
{
LM_ERR("failed deleting r-uri\n");
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0)
{
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
return 0;
}
int th_unmask_refer_to(sip_msg_t *msg)
{
str eval;
str *uri;
int ulen;
struct lump* l;
str out;
if(!((get_cseq(msg)->method_id)&(METHOD_REFER)))
return 0;
if(parse_refer_to_header(msg)==-1)
{
LM_DBG("no Refer-To header\n");
return 0;
}
if(msg->refer_to==NULL || get_refer_to(msg)==NULL)
{
LM_DBG("Refer-To header not found\n");
return 0;
}
uri = &(get_refer_to(msg)->uri);
if(th_get_uri_param_value(uri, &th_uparam_name, &eval)<0
|| eval.len<=0)
return -1;
out.s = th_mask_decode(eval.s, eval.len,
&th_uparam_prefix, 0, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot decode r-uri\n");
return -1;
}
LM_DBG("+decoded: %d: [%.*s]\n", out.len, out.len, out.s);
for(ulen=0; ulen<uri->len; ulen++)
{
if(uri->s[ulen]=='?')
break;
}
l=del_lump(msg, uri->s-msg->buf, ulen, 0);
if (l==0)
{
LM_ERR("failed deleting r-uri\n");
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0)
{
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
return 0;
}
int th_unmask_ruri(sip_msg_t *msg)
{
str eval;
struct lump* l;
str out;
/* Do nothing if ruri is not encoded */
if (th_uri_prefix_checks && ((REQ_LINE(msg).uri.len<th_uri_prefix.len) ||
(strncasecmp(REQ_LINE(msg).uri.s, th_uri_prefix.s,
th_uri_prefix.len)!=0)))
{
LM_DBG("ruri [%.*s] is not encoded",REQ_LINE(msg).uri.len,REQ_LINE(msg).uri.s);
return 0;
}
if(th_get_uri_param_value(&REQ_LINE(msg).uri, &th_uparam_name, &eval)<0
|| eval.len<=0) {
LM_DBG("no uri param [%.*s] in [%.*s]\n",
th_uparam_name.len, th_uparam_name.s,
REQ_LINE(msg).uri.len,REQ_LINE(msg).uri.s);
return -1;
}
out.s = th_mask_decode(eval.s, eval.len,
&th_uparam_prefix, 0, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot decode r-uri [%.*s]\n",
REQ_LINE(msg).uri.len,REQ_LINE(msg).uri.s);
return -1;
}
LM_DBG("+decoded: %d: [%.*s]\n", out.len, out.len, out.s);
l=del_lump(msg, REQ_LINE(msg).uri.s-msg->buf, REQ_LINE(msg).uri.len, 0);
if (l==0)
{
LM_ERR("failed deleting r-uri\n");
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0)
{
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
return 0;
}
int th_unmask_callid(sip_msg_t *msg)
{
struct lump* l;
str out;
if(th_param_mask_callid==0)
return 0;
if(msg->callid==NULL)
{
LM_ERR("cannot get Call-Id header\n");
return -1;
}
/* Do nothing if call-id is not encoded */
if ((msg->callid->body.len<th_callid_prefix.len) ||
(strncasecmp(msg->callid->body.s,th_callid_prefix.s,th_callid_prefix.len)!=0))
{
LM_DBG("call-id [%.*s] not encoded",msg->callid->body.len,msg->callid->body.s);
return 0;
}
out.s = th_mask_decode(msg->callid->body.s, msg->callid->body.len,
&th_callid_prefix, 0, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot decode callid\n");
return -1;
}
l=del_lump(msg, msg->callid->body.s-msg->buf, msg->callid->body.len, 0);
if (l==0)
{
LM_ERR("failed deleting callid\n");
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0) {
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
return 0;
}
int th_unmask_callid_str(str *icallid, str *ocallid)
{
static char th_callid_buf[TH_CALLID_SIZE];
str out;
if(th_param_mask_callid==0)
return 0;
if(icallid->s==NULL) {
LM_ERR("invalid Call-Id value\n");
return -1;
}
if(th_callid_prefix.len>0) {
if(th_callid_prefix.len >= icallid->len) {
return 1;
}
if(strncmp(icallid->s, th_callid_prefix.s, th_callid_prefix.len)!=0) {
return 1;
}
}
out.s = th_mask_decode(icallid->s, icallid->len,
&th_callid_prefix, 0, &out.len);
if(out.s == NULL) {
LM_ERR("failed to decode call-id\n");
return -2;
}
if(out.len>=TH_CALLID_SIZE) {
pkg_free(out.s);
LM_ERR("not enough callid buf size (needed %d)\n", out.len);
return -2;
}
memcpy(th_callid_buf, out.s, out.len);
th_callid_buf[out.len] = '\0';
pkg_free(out.s);
ocallid->s = th_callid_buf;
ocallid->len = out.len;
return 0;
}
int th_unmask_callid(sip_msg_t *msg)
{
struct lump* l;
str out;
if(th_param_mask_callid==0)
return 0;
if(msg->callid==NULL)
{
LM_ERR("cannot get Call-Id header\n");
return -1;
}
out.s = th_mask_decode(msg->callid->body.s, msg->callid->body.len,
&th_callid_prefix, 0, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot decode callid\n");
return -1;
}
l=del_lump(msg, msg->callid->body.s-msg->buf, msg->callid->body.len, 0);
if (l==0)
{
LM_ERR("failed deleting callid\n");
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0) {
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
return 0;
}
int th_update_hdr_replaces(sip_msg_t *msg)
{
struct hdr_field *hf = NULL;
str replaces;
str rcallid;
struct lump* l;
str out;
LM_DBG("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
if(th_param_mask_callid==0)
return 0;
if(!((get_cseq(msg)->method_id)&(METHOD_INVITE)))
return 0;
for (hf=msg->headers; hf; hf=hf->next)
{
if (hf->name.len==8 && strncasecmp(hf->name.s, "Replaces", 8)==0)
break;
}
if(hf==NULL)
return 0;
replaces = hf->body;
trim(&replaces);
rcallid.s = replaces.s;
for(rcallid.len=0; rcallid.len<replaces.len; rcallid.len++)
{
if(rcallid.s[rcallid.len]==';')
break;
}
if(rcallid.len>th_callid_prefix.len
&& strncmp(rcallid.s, th_callid_prefix.s, th_callid_prefix.len)==0)
{
/* value encoded - decode it */
out.s = th_mask_decode(rcallid.s, rcallid.len,
&th_callid_prefix, 0, &out.len);
} else {
/* value decoded - encode it */
out.s = th_mask_encode(rcallid.s, rcallid.len,
&th_callid_prefix, &out.len);
}
if(out.s==NULL)
{
LM_ERR("cannot update Replaces callid\n");
return -1;
}
l=del_lump(msg, rcallid.s-msg->buf, rcallid.len, 0);
if (l==0)
{
LM_ERR("failed deleting Replaces callid\n");
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0) {
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
return 0;
}
int th_unmask_route(sip_msg_t *msg)
{
hdr_field_t *hdr;
struct lump* l;
int i;
rr_t *rr;
str out;
str eval;
if(msg->route==NULL)
{
LM_DBG("no record route header\n");
return 0;
}
hdr = msg->route;
i = 0;
while(hdr!=NULL)
{
if (parse_rr(hdr) < 0)
{
LM_ERR("failed to parse RR\n");
return -1;
}
rr =(rr_t*)hdr->parsed;
while(rr)
{
i++;
if(i!=1)
{
if(th_get_uri_param_value(&rr->nameaddr.uri, &th_uparam_name,
&eval)<0 || eval.len<=0)
return -1;
out.s = th_mask_decode(eval.s, eval.len,
&th_uparam_prefix, 0, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot decode R %d\n", i);
return -1;
}
l=del_lump(msg, rr->nameaddr.uri.s-msg->buf,
rr->nameaddr.uri.len, 0);
if (l==0)
{
LM_ERR("failed deleting R [%d]\n", i);
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0){
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
}
rr = rr->next;
}
hdr = next_sibling_hdr(hdr);
}
return 0;
}
int th_flip_record_route(sip_msg_t *msg, int mode)
{
hdr_field_t *hdr;
struct lump* l;
int i;
rr_t *rr;
str out;
int utype;
str pval;
int r2;
int act;
if(msg->record_route==NULL)
{
LM_DBG("no record route header\n");
return 0;
}
hdr = msg->record_route;
i = 0;
act = 0;
if(mode==1)
act = 2;
while(hdr!=NULL)
{
if (parse_rr(hdr) < 0)
{
LM_ERR("failed to parse RR\n");
return -1;
}
rr =(rr_t*)hdr->parsed;
while(rr)
{
i++;
r2 = 0;
utype = th_get_uri_type(&rr->nameaddr.uri, &r2, &pval);
if(utype==0 && mode==1)
{
if(r2==1)
{
act--;
if(act==0)
return 0;
utype = 1;
} else {
return 0;
}
}
out.s = NULL;
switch(utype) {
case 1: /* encode */
if(act!=0 && mode==1)
{
out.s = th_mask_encode(rr->nameaddr.uri.s,
rr->nameaddr.uri.len, &th_uri_prefix, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot encode r-r %d\n", i);
return -1;
}
}
break;
case 2: /* decode */
if(mode==0)
{
out.s = th_mask_decode(pval.s,
pval.len, &th_uparam_prefix, 0, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot decode r-r %d\n", i);
return -1;
}
}
break;
}
if(out.s!=NULL)
{
l=del_lump(msg, rr->nameaddr.uri.s-msg->buf,
rr->nameaddr.uri.len, 0);
if (l==0)
{
LM_ERR("failed deleting r-r [%d]\n", i);
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0){
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
}
rr = rr->next;
}
hdr = next_sibling_hdr(hdr);
}
return 0;
}
int th_unmask_via(sip_msg_t *msg, str *cookie)
{
hdr_field_t *hdr;
struct via_body *via;
struct via_body *via2;
struct via_param *vp;
struct lump* l;
int i;
str out;
int vlen;
i=0;
for(hdr=msg->h_via1; hdr; hdr=next_sibling_hdr(hdr))
{
for(via=(struct via_body*)hdr->parsed; via; via=via->next)
{
i++;
LM_DBG("=======via[%d]\n", i);
LM_DBG("hdr: [%.*s]\n", via->hdr.len, via->hdr.s);
vlen = th_skip_rw(via->name.s, via->bsize);
LM_DBG("body: %d: [%.*s]\n", vlen, vlen, via->name.s);
if(i!=1)
{
vp = th_get_via_param(via, &th_vparam_name);
if(vp==NULL)
{
LM_ERR("cannot find param in via %d\n", i);
return -1;
}
if(i==2)
out.s = th_mask_decode(vp->value.s, vp->value.len,
&th_vparam_prefix, CRLF_LEN+1, &out.len);
else
out.s = th_mask_decode(vp->value.s, vp->value.len,
&th_vparam_prefix, 0, &out.len);
if(out.s==NULL)
{
LM_ERR("cannot encode via %d\n", i);
return -1;
}
LM_DBG("+body: %d: [%.*s]\n", out.len, out.len, out.s);
if(i==2)
{
via2=pkg_malloc(sizeof(struct via_body));
if (via2==0)
{
LM_ERR("out of memory\n");
pkg_free(out.s);
return -1;
}
memset(via2, 0, sizeof(struct via_body));
memcpy(out.s+out.len, CRLF, CRLF_LEN);
out.s[out.len+CRLF_LEN]='X';
if(parse_via(out.s, out.s+out.len+CRLF_LEN+1, via2)==NULL)
{
LM_ERR("error parsing decoded via2\n");
free_via_list(via2);
pkg_free(out.s);
return -1;
}
out.s[out.len] = '\0';
vp = th_get_via_param(via2, &th_cookie_name);
if(vp==NULL)
{
LM_ERR("cannot find cookie in via2\n");
free_via_list(via2);
pkg_free(out.s);
return -1;
}
*cookie = vp->value;
free_via_list(via2);
}
l=del_lump(msg, via->name.s-msg->buf, vlen, 0);
if (l==0)
{
LM_ERR("failed deleting via [%d]\n", i);
pkg_free(out.s);
return -1;
}
if (insert_new_lump_after(l, out.s, out.len, 0)==0)
{
LM_ERR("could not insert new lump\n");
pkg_free(out.s);
return -1;
}
}
}
}
return 0;
}
