int tps_add_headers(sip_msg_t *msg, str *hname, str *hbody, int hpos)
{
struct lump* anchor;
str hs;
if(hname==NULL || hname->len<=0 || hbody==NULL || hbody->len<=0)
return 0;
parse_headers(msg, HDR_EOH_F, 0);
if(hpos == 0) { /* append */
/* after last header */
anchor = anchor_lump(msg, msg->unparsed - msg->buf, 0, 0);
} else { /* insert */
/* before first header */
anchor = anchor_lump(msg, msg->headers->name.s - msg->buf, 0, 0);
}
if(anchor == 0) {
LM_ERR("can't get anchor\n");
return -1;
}
hs.len = hname->len + 2 + hbody->len;
hs.s = (char*)pkg_malloc(hs.len + 3);
if (hs.s==NULL) {
LM_ERR("no pkg memory left (%.*s - %d)\n",
hname->len, hname->s, hs.len);
return -1;
}
memcpy(hs.s, hname->s, hname->len);
hs.s[hname->len] = ':';
hs.s[hname->len+1] = ' ';
memcpy(hs.s + hname->len + 2, hbody->s, hbody->len);
/* add end of header if not present */
if(hs.s[hname->len + 2 + hbody->len]!='\n') {
hs.s[hname->len + 2 + hbody->len] = '\r';
hs.s[hname->len + 2 + hbody->len+1] = '\n';
hs.len += 2;
}
if (insert_new_lump_before(anchor, hs.s, hs.len, 0) == 0) {
LM_ERR("can't insert lump\n");
pkg_free(hs.s);
return -1;
}
return 0;
}
static int
alter_mediaip(struct sip_msg *msg, str *body, str *oldip, str *newip,
int *clendelta, int preserve)
{
char *buf;
int offset;
struct lump* anchor;
/* check that updating mediaip is really necessary */
if (7 == oldip->len && memcmp("0.0.0.0", oldip->s, 7) == 0)
return 0;
if (newip->len == oldip->len &&
memcmp(newip->s, oldip->s, newip->len) == 0)
return 0;
if (preserve != 0) {
anchor = anchor_lump(&(msg->add_rm),
body->s + body->len - msg->buf, 0, 0);
if (anchor == NULL) {
LOG(L_ERR, "ERROR: alter_mediaip: anchor_lump failed\n");
return -1;
}
buf = pkg_malloc(AOLDMEDIAIP_LEN + oldip->len + CRLF_LEN);
if (buf == NULL) {
LOG(L_ERR, "ERROR: alter_mediaip: out of memory\n");
return -1;
}
memcpy(buf, AOLDMEDIAIP, AOLDMEDIAIP_LEN);
memcpy(buf + AOLDMEDIAIP_LEN, oldip->s, oldip->len);
memcpy(buf + AOLDMEDIAIP_LEN + oldip->len, CRLF, CRLF_LEN);
if (insert_new_lump_after(anchor, buf,
AOLDMEDIAIP_LEN + oldip->len + CRLF_LEN, 0) == NULL) {
LOG(L_ERR, "ERROR: alter_mediaip: insert_new_lump_after failed\n");
pkg_free(buf);
return -1;
}
*clendelta += AOLDMEDIAIP_LEN + oldip->len + CRLF_LEN;
}
buf = pkg_malloc(newip->len);
if (buf == NULL) {
LOG(L_ERR, "ERROR: alter_mediaip: out of memory\n");
return -1;
}
offset = oldip->s - msg->buf;
anchor = del_lump(&msg->add_rm, offset, oldip->len, 0);
if (anchor == NULL) {
LOG(L_ERR, "ERROR: alter_mediaip: del_lump failed\n");
pkg_free(buf);
return -1;
}
memcpy(buf, newip->s, newip->len);
if (insert_new_lump_after(anchor, buf, newip->len, 0) == 0) {
LOG(L_ERR, "ERROR: alter_mediaip: insert_new_lump_after failed\n");
pkg_free(buf);
return -1;
}
*clendelta += newip->len - oldip->len;
return 0;
}
/**
* Given some header text, append it to the passed in message.
*
* @param msg The message to append the header text to.
* @param header The header text to append.
*
* @return 0 on success, non-zero on failure.
*/
static int append_header(struct sip_msg *msg, const char *header)
{
struct lump* anchor = NULL;
char *s = NULL;
int len = 0;
LM_DBG("Appending header: %s", header);
if (parse_headers(msg, HDR_EOH_F, 0) == -1) {
LM_ERR("failed to parse headers in message.\n");
return(1);
}
if ((anchor = anchor_lump(msg, msg->unparsed - msg->buf, 0)) == 0) {
LM_ERR("failed to get anchor to append header\n");
return(1);
}
len = strlen(header);
if ((s = (char *)pkg_malloc(len)) == 0) {
LM_ERR("No more pkg memory. (size requested = %d)\n", len);
return(1);
}
memcpy(s, header, len);
if (insert_new_lump_before(anchor, s, len, 0) == 0) {
LM_ERR("failed to insert lump\n");
pkg_free(s);
return(1);
}
LM_DBG("Done appending header successfully.\n");
return(0);
}
/**
* Deletes the previous marking attempts (lumps).
*
* @param msg - SIP mesage to mark
* @returns 1 on success
*/
inline int isc_mark_drop_route(struct sip_msg *msg) {
struct lump* lmp, *tmp;
parse_headers(msg, HDR_EOH_F, 0);
anchor_lump(msg, msg->headers->name.s - msg->buf, 0, 0);
LM_DBG("ifc_mark_drop_route: Start --------- \n");
lmp = msg->add_rm;
while (lmp) {
tmp = lmp->before;
if (tmp && tmp->op == LUMP_ADD && tmp->u.value
&& strstr(tmp->u.value, ISC_MARK_USERNAME)) {
LM_DBG("ifc_mark_drop_route: Found lump %s ... dropping\n", tmp->u.value);
//tmp->op=LUMP_NOP;
tmp->len = 0;
/*lmp->before = tmp->before;
free_lump(tmp); */
}
lmp = lmp->next;
}
LM_DBG("ifc_mark_drop_route: ---------- End \n");
return 1;
}
/** * Inserts the Route header for marking, before first header. * - the marking will be in a header like below * - if the "as" parameter is empty: \code Route: <[iscmark]> \endcode * - else: \code Route: <sip:[email protected];lr>, <[iscmark]> \endcode * * * @param msg - SIP mesage to mark * @param as - SIP addres of the application server to forward to * @param iscmark - the mark to write * @returns 1 on success, else 0 */ inline int isc_mark_write_route(struct sip_msg *msg, str *as, str *iscmark) { struct hdr_field *first; struct lump* anchor; str route; parse_headers(msg, HDR_EOH_F, 0); first = msg->headers; if (as && as->len) { route.s = pkg_malloc(21+as->len+iscmark->len); sprintf(route.s, "Route: <%.*s;lr>, <%.*s>\r\n", as->len, as->s, iscmark->len, iscmark->s); } else { route.s = pkg_malloc(18+iscmark->len); sprintf(route.s, "Route: <%.*s>\r\n", iscmark->len, iscmark->s); } route.len = strlen(route.s); LM_DBG("isc_mark_write_route: <%.*s>\n", route.len, route.s); anchor = anchor_lump(msg, first->name.s - msg->buf, 0, HDR_ROUTE_T); if (anchor == NULL) { LM_ERR("isc_mark_write_route: anchor_lump failed\n"); return 0; } if (!insert_new_lump_before(anchor, route.s, route.len, HDR_ROUTE_T)) { LM_ERR("isc_mark_write_route: error creating lump for header_mark\n"); } return 1; }
static int search_append_f(struct sip_msg* msg, char* key, char* str)
{
struct lump* l;
regmatch_t pmatch;
char* s;
int len;
char *begin;
int off;
begin=get_header(msg); /* msg->orig/buf previously .. uri problems */
off=begin-msg->buf;
if (regexec((regex_t*) key, begin, 1, &pmatch, 0)!=0) return -1;
if (pmatch.rm_so!=-1){
if ((l=anchor_lump(msg, off+pmatch.rm_eo, 0, 0))==0)
return -1;
len=strlen(str);
s=pkg_malloc(len);
if (s==0){
LOG(L_ERR, "ERROR: search_append_f: mem. allocation failure\n");
return -1;
}
memcpy(s, str, len);
if (insert_new_lump_after(l, s, len, 0)==0){
LOG(L_ERR, "ERROR: could not insert new lump\n");
pkg_free(s);
return -1;
}
return 1;
}
return -1;
}
static int insert_header_lump(struct sip_msg* msg, char* msg_position, int lump_before, str* hname, str *val) {
struct lump* anchor;
char *s;
int len;
anchor = anchor_lump(msg, msg_position - msg->buf, 0, 0);
if (anchor == 0) {
LOG(L_ERR, "ERROR: textops: insert_header_lump(): Can't get anchor\n");
return -1;
}
len=hname->len+2+val->len+2;
s = (char*)pkg_malloc(len);
if (!s) {
LOG(L_ERR, "ERROR: textops: insert_header_lump(): not enough memory\n");
return -1;
}
memcpy(s, hname->s, hname->len);
s[hname->len] = ':';
s[hname->len+1] = ' ';
memcpy(s+hname->len+2, val->s, val->len);
s[hname->len+2+val->len] = '\r';
s[hname->len+2+val->len+1] = '\n';
if ( (lump_before?insert_new_lump_before(anchor, s, len, 0):insert_new_lump_after(anchor, s, len, 0)) == 0) {
LOG(L_ERR, "ERROR: textops: insert_header_lump(): Can't insert lump\n");
pkg_free(s);
return -1;
}
return 1;
}
int _test_insert_to_reply( struct sip_msg *msg, char *str )
{
struct lump* anchor;
char *buf;
int len;
len=strlen( str );
buf=pkg_malloc( len );
if (!buf) {
LOG(L_ERR, "_test_insert_to_reply: no mem\n");
return 0;
}
memcpy( buf, str, len );
anchor = anchor_lump(msg, msg->headers->name.s - msg->buf, 0 , 0);
if (anchor == NULL) {
LOG(L_ERR, "_test_insert_to_reply: anchor_lump failed\n");
return 0;
}
if (insert_new_lump_before(anchor,buf, len, 0)==0) {
LOG(L_ERR, "_test_insert_to_reply: inser_new_lump failed\n");
return 0;
}
return 1;
}
static int lua_sr_hdr_insert (lua_State *L)
{
struct lump* anchor;
struct hdr_field *hf;
char *txt;
int len;
char *hdr;
sr_lua_env_t *env_L;
env_L = sr_lua_env_get();
txt = (char*)lua_tostring(L, -1);
if(txt==NULL || env_L->msg==NULL)
return 0;
LM_DBG("insert hf: %s\n", txt);
hf = env_L->msg->headers;
len = strlen(txt);
hdr = (char*)pkg_malloc(len);
if(hdr==NULL)
{
LM_ERR("no pkg memory left\n");
return 0;
}
memcpy(hdr, txt, len);
anchor = anchor_lump(env_L->msg,
hf->name.s + hf->len - env_L->msg->buf, 0, 0);
if(insert_new_lump_before(anchor, hdr, len, 0) == 0)
{
LM_ERR("can't insert lump\n");
pkg_free(hdr);
return 0;
}
return 0;
}
int th_add_hdr_cookie(sip_msg_t *msg)
{
struct lump* anchor;
str h;
h.len = th_cookie_name.len + 2 + th_cookie_value.len + 1 + CRLF_LEN;
h.s = (char*)pkg_malloc(h.len+1);
if(h.s == 0)
{
LM_ERR("no more pkg\n");
return -1;
}
anchor = anchor_lump(msg, msg->unparsed - msg->buf, 0, 0);
if(anchor == 0)
{
LM_ERR("can't get anchor\n");
pkg_free(h.s);
return -1;
}
memcpy(h.s, th_cookie_name.s, th_cookie_name.len);
memcpy(h.s+th_cookie_name.len, ": ", 2);
memcpy(h.s+th_cookie_name.len+2, th_cookie_value.s, th_cookie_value.len);
memcpy(h.s+th_cookie_name.len+2+th_cookie_value.len+1, CRLF, CRLF_LEN);
h.s[h.len-1-CRLF_LEN] = 'h';
h.s[h.len] = '\0';
if (insert_new_lump_before(anchor, h.s, h.len, 0) == 0)
{
LM_ERR("can't insert lump\n");
pkg_free(h.s);
return -1;
}
LM_DBG("+++++++++++++ added cookie header [%s]\n", h.s);
return 0;
}
static int search_append_body_f(struct sip_msg* msg, regex_t* key, str* str2)
{
struct lump* l;
regmatch_t pmatch;
char* s;
int off;
str body;
if ( get_body(msg,&body)!=0 || body.len==0) {
LM_DBG("message body has zero length\n");
return -1;
}
off=body.s-msg->buf;
if (regexec(key, body.s, 1, &pmatch, 0)!=0) return -1;
if (pmatch.rm_so!=-1){
if ((l=anchor_lump(msg, off+pmatch.rm_eo, 0))==0)
return -1;
s=pkg_malloc(str2->len);
if (s==0){
LM_ERR("memory allocation failure\n");
return -1;
}
memcpy(s, str2->s, str2->len);
if (insert_new_lump_after(l, s, str2->len, 0)==0){
LM_ERR("could not insert new lump\n");
pkg_free(s);
return -1;
}
return 1;
}
return -1;
}
static int search_append_f(struct sip_msg* msg, regex_t* key, str* str2)
{
struct lump* l;
regmatch_t pmatch;
char* s;
char *begin;
int off;
begin=get_header(msg); /* msg->orig/buf previously .. uri problems */
off=begin-msg->buf;
if (regexec(key, begin, 1, &pmatch, 0)!=0) return -1;
if (pmatch.rm_so!=-1){
if ((l=anchor_lump(msg, off+pmatch.rm_eo, 0))==0)
return -1;
s=pkg_malloc(str2->len);
if (s==0){
LM_ERR("memory allocation failure\n");
return -1;
}
memcpy(s, str2->s, str2->len);
if (insert_new_lump_after(l, s, str2->len, 0)==0){
LM_ERR("could not insert new lump\n");
pkg_free(s);
return -1;
}
return 1;
}
return -1;
}
static int ki_add_sock_hdr(sip_msg_t* msg, str *hdr_name)
{
struct socket_info* si;
struct lump* anchor;
str hdr;
char *p;
if(hdr_name==NULL || hdr_name->s==NULL || hdr_name->len<=0) {
LM_ERR("invalid header name parameter\n");
return -1;
}
si = msg->rcv.bind_address;
if (parse_headers( msg, HDR_EOH_F, 0) == -1) {
LM_ERR("failed to parse message\n");
goto error;
}
anchor = anchor_lump( msg, msg->unparsed-msg->buf, 0, 0);
if (anchor==0) {
LM_ERR("can't get anchor\n");
goto error;
}
hdr.len = hdr_name->len + 2 + si->sock_str.len + CRLF_LEN;
if ( (hdr.s=(char*)pkg_malloc(hdr.len))==0 ) {
LM_ERR("no more pkg mem\n");
goto error;
}
p = hdr.s;
memcpy( p, hdr_name->s, hdr_name->len);
p += hdr_name->len;
*(p++) = ':';
*(p++) = ' ';
memcpy( p, si->sock_str.s, si->sock_str.len);
p += si->sock_str.len;
memcpy( p, CRLF, CRLF_LEN);
p += CRLF_LEN;
if ( p-hdr.s!=hdr.len ) {
LM_CRIT("buffer overflow (%d!=%d)\n", (int)(long)(p-hdr.s),hdr.len);
goto error1;
}
if (insert_new_lump_before( anchor, hdr.s, hdr.len, 0) == 0) {
LM_ERR("can't insert lump\n");
goto error1;
}
return 1;
error1:
pkg_free(hdr.s);
error:
return -1;
}
/**
* Adds a received parameter to the first via with the source IP of the message.
* @param req - the SIP request
* @param str1 - not used
* @param str2 - not used
* @returns true if ok, false if not or error
*/
int P_add_via_received(struct sip_msg *msg,char *str1, char *str2)
{
struct via_body *via;
struct via_param *vp;
str received={0,0};
struct ip_addr *src_ip;
char *src_ip_ch;
int len;
struct lump* anchor,*l;
char *x;
/* first add a received parameter */
via = msg->via1;
/* if we already have a received header, SER will take care of it and put the right value */
if (via->received) goto delete_others;
x = via->port_str.s+via->port_str.len;
if (!x) x= via->host.s+via->host.len;
anchor = anchor_lump(msg, x-msg->buf, 0 , 0 );
if (anchor == NULL) {
LOG(L_ERR, "ERR:"M_NAME":P_add_via_received(): anchor_lump failed\n");
return 0;
}
src_ip = &(msg->rcv.src_ip);
src_ip_ch = ip_addr2a(src_ip);
len = strlen(src_ip_ch);
received.len = s_received.len+len;
received.s = pkg_malloc(received.len);
if (!received.s){
LOG(L_ERR, "ERR:"M_NAME":P_add_via_received(): allocating %d bytes\n",received.len);
return CSCF_RETURN_ERROR;
}
memcpy(received.s,s_received.s,s_received.len);
memcpy(received.s+s_received.len,src_ip_ch,len);
if (!(l=insert_new_lump_before(anchor, received.s,received.len,0))){
LOG(L_ERR, "ERR:"M_NAME":P_add_via_received(): error creating lump for received parameter\n" );
return CSCF_RETURN_ERROR;
}
/* then remove the old received params*/
delete_others:
for(vp = via->param_lst; vp; vp = vp->next)
if (vp->name.len == s_received2.len &&
strncasecmp(vp->name.s,s_received2.s,s_received2.len)==0){
LOG(L_ERR, "ERR:"M_NAME":P_add_via_received(): Found old received parameter!! This might indicate an attack.\n" );
if (!del_lump(msg,vp->start-msg->buf-1,vp->size+1,0)){
LOG(L_ERR,"ERR:"M_NAME":P_add_via_received(): Error deleting old received parameter from first via\n");
return CSCF_RETURN_ERROR;
}
}
return CSCF_RETURN_TRUE;
}
int add_maxfwd_header( struct sip_msg* msg , unsigned int val )
{
unsigned int len;
char *buf;
struct lump* anchor;
/* double check just to be sure */
if ( msg->maxforwards )
{
LOG( L_ERR , "ERROR: add_maxfwd_header :"
" MAX_FORWARDS header already exists (%p) !\n",msg->maxforwards);
goto error;
}
/* constructing the header */
len = 14 /*"MAX-FORWARDS: "*/+ CRLF_LEN + 3/*val max on 3 digits*/;
buf = (char*)pkg_malloc( len );
if (!buf) {
LOG(L_ERR, "ERROR : add_maxfwd_header : "
"No memory left\n");
return -1;
}
memcpy( buf , "Max-Forwards: ", 14 );
len = 14 ;
len += btostr( buf+len , val );
memcpy( buf+len , CRLF , CRLF_LEN );
len +=CRLF_LEN;
/*inserts the header at the begining of the message*/
anchor = anchor_lump(msg, msg->headers->name.s - msg->buf, 0 , 0);
if (anchor == 0) {
LOG(L_ERR, "ERROR: add_maxfwd_header :"
" Error, can't get anchor\n");
goto error1;
}
if (insert_new_lump_before(anchor, buf, len, 0) == 0) {
LOG(L_ERR, "ERROR: add_maxfwd_header : "
"Error, can't insert MAX-FORWARDS\n");
goto error1;
}
return 1;
error1:
pkg_free( buf );
error:
return -1;
}
static int sr_mono_hdr_append (MonoString *hv)
{
struct lump* anchor;
struct hdr_field *hf;
char *hdr;
str txt = {0};
sr_mono_env_t *env_M;
env_M = sr_mono_env_get();
txt.s = mono_string_to_utf8(hv);
if(txt.s==NULL || env_M->msg==NULL)
goto error;
txt.len = strlen(txt.s);
LM_DBG("append hf: %s\n", txt.s);
if (parse_headers(env_M->msg, HDR_EOH_F, 0) == -1)
{
LM_ERR("error while parsing message\n");
goto error;
}
hf = env_M->msg->last_header;
hdr = (char*)pkg_malloc(txt.len+1);
if(hdr==NULL)
{
PKG_MEM_ERROR;
goto error;
}
memcpy(hdr, txt.s, txt.len);
hdr[txt.len] = '\0';
anchor = anchor_lump(env_M->msg,
hf->name.s + hf->len - env_M->msg->buf, 0, 0);
if(insert_new_lump_before(anchor, hdr, txt.len, 0) == 0)
{
LM_ERR("can't insert lump\n");
pkg_free(hdr);
goto error;
}
mono_free(txt.s);
return 0;
error:
if(txt.s!=NULL)
mono_free(txt.s);
return -1;
}
static inline int apply_urihdr_changes( struct sip_msg *req,
str *uri, str *hdr)
{
struct lump* anchor;
/* add the uri - move it to branch directly FIXME (bogdan)*/
if (req->new_uri.s)
{
pkg_free(req->new_uri.s);
req->new_uri.len=0;
}
req->parsed_uri_ok=0;
req->new_uri.s = (char*)pkg_malloc(uri->len+1);
if (req->new_uri.s==0)
{
LM_ERR("no more pkg\n");
goto error;
}
memcpy( req->new_uri.s, uri->s, uri->len);
req->new_uri.s[uri->len]=0;
req->new_uri.len=uri->len;
ruri_mark_new();
/* add the header */
if (parse_headers(req, HDR_EOH_F, 0) == -1)
{
LM_ERR("failed to parse message\n");
goto error;
}
anchor = anchor_lump(req, req->unparsed - req->buf, 0, 0);
if (anchor==0)
{
LM_ERR("failed to get anchor\n");
goto error;
}
if (insert_new_lump_before(anchor, hdr->s, hdr->len, 0) == 0)
{
LM_ERR("faield to insert lump\n");
goto error;
}
return 0;
error:
pkg_free( hdr->s );
return -1;
}
/*!
* \brief Set Request-URI as last Route header of a SIP
*
* Set Request-URI as last Route header of a SIP message,
* this is necessary when forwarding to a strict router.
* Allocates memory for message lump in private memory.
* \param _m SIP message
* \return negative on failure, 0 on success
*/
static inline int save_ruri(struct sip_msg* _m)
{
struct lump* anchor;
char *s;
int len;
/* We must parse the whole message header here, because
* the Request-URI must be saved in last Route HF in the message
*/
if (parse_headers(_m, HDR_EOH_F, 0) == -1) {
LM_ERR("failed to parse message\n");
return -1;
}
/* Create an anchor */
anchor = anchor_lump(_m, _m->unparsed - _m->buf, 0, 0);
if (anchor == 0) {
LM_ERR("failed to get anchor\n");
return -2;
}
/* Create buffer for new lump */
len = RR_ROUTE_PREFIX_LEN + _m->first_line.u.request.uri.len
+ ROUTE_SUFFIX_LEN;
s = (char*)pkg_malloc(len);
if (!s) {
LM_ERR("No memory pkg left\n");
return -3;
}
/* Create new header field */
memcpy(s, RR_ROUTE_PREFIX, RR_ROUTE_PREFIX_LEN);
memcpy(s + RR_ROUTE_PREFIX_LEN, _m->first_line.u.request.uri.s,
_m->first_line.u.request.uri.len);
memcpy(s + RR_ROUTE_PREFIX_LEN + _m->first_line.u.request.uri.len,
ROUTE_SUFFIX, ROUTE_SUFFIX_LEN);
LM_DBG("New header: '%.*s'\n", len, ZSW(s));
/* Insert it */
if (insert_new_lump_before(anchor, s, len, 0) == 0) {
pkg_free(s);
LM_ERR("failed to insert lump\n");
return -4;
}
return 0;
}
static int lua_sr_hdr_append (lua_State *L)
{
struct lump* anchor;
struct hdr_field *hf;
char *txt;
int len;
char *hdr;
sr_lua_env_t *env_L;
env_L = sr_lua_env_get();
txt = (char*)lua_tostring(L, -1);
if(txt==NULL || env_L->msg==NULL)
return 0;
LM_DBG("append hf: %s\n", txt);
if (parse_headers(env_L->msg, HDR_EOH_F, 0) == -1)
{
LM_ERR("error while parsing message\n");
return 0;
}
hf = env_L->msg->last_header;
len = strlen(txt);
hdr = (char*)pkg_malloc(len);
if(hdr==NULL)
{
LM_ERR("no pkg memory left\n");
return 0;
}
memcpy(hdr, txt, len);
anchor = anchor_lump(env_L->msg,
hf->name.s + hf->len - env_L->msg->buf, 0, 0);
if(anchor==NULL)
{
LM_ERR("unable to get the anchor\n");
pkg_free(hdr);
return 0;
}
if(insert_new_lump_before(anchor, hdr, len, 0) == 0)
{
LM_ERR("can't insert lump\n");
pkg_free(hdr);
return 0;
}
return 0;
}
static int insert_via_lump(struct sip_msg* msg, char* via, int via_len)
{
struct lump* anchor;
anchor = anchor_lump(msg, msg->unparsed - msg->buf, 0, HDR_VIA_T);
if (anchor == 0) {
ERR("Unable to create anchor\n");
return -1;
}
if (insert_new_lump_after(anchor, via, via_len, HDR_VIA_T) == 0) {
ERR("Unable to insert via lump\n");
return -1;
}
return 0;
}
/*
* Create an AVP to be used by registrar with the source IP and port
* of the REGISTER
*/
static int
fix_nated_register_f(struct sip_msg* msg, char* str1, char* str2)
{
contact_t* c;
struct lump* anchor;
char* param;
str uri;
if (create_rcv_uri(&uri, msg) < 0) {
return -1;
}
if (contact_iterator(&c, msg, 0) < 0) {
return -1;
}
while(c) {
param = (char*)pkg_malloc(RECEIVED_LEN + 2 + uri.len);
if (!param) {
ERR("No memory left\n");
return -1;
}
memcpy(param, RECEIVED, RECEIVED_LEN);
param[RECEIVED_LEN] = '\"';
memcpy(param + RECEIVED_LEN + 1, uri.s, uri.len);
param[RECEIVED_LEN + 1 + uri.len] = '\"';
anchor = anchor_lump(msg, c->name.s + c->len - msg->buf, 0, 0);
if (anchor == NULL) {
ERR("anchor_lump failed\n");
return -1;
}
if (insert_new_lump_after(anchor, param, RECEIVED_LEN + 1 + uri.len + 1, 0) == 0) {
ERR("insert_new_lump_after failed\n");
pkg_free(param);
return -1;
}
if (contact_iterator(&c, msg, c) < 0) {
return -1;
}
}
return 1;
}
int th_add_via_cookie(sip_msg_t *msg, struct via_body *via)
{
struct lump* l;
int viap;
str out;
if (via->params.s) {
viap = via->params.s - via->hdr.s - 1;
} else {
if (via->host.s) {
viap = via->host.s - via->hdr.s + via->host.len;
} else {
LM_ERR("no via parameter and no via host, can't insert cookie\n");
return -1;
}
if (via->port!=0)
viap += via->port_str.len + 1; /* +1 for ':'*/
}
l = anchor_lump(msg, via->hdr.s - msg->buf + viap, 0, 0);
if (l==0)
{
LM_ERR("failed adding cookie to via [%p]\n", via);
return -1;
}
out.len = 1+th_cookie_name.len+1+th_cookie_value.len+1;
out.s = (char*)pkg_malloc(out.len+1);
if(out.s==0)
{
LM_ERR("no pkg memory\n");
return -1;
}
out.s[0] = ';';
memcpy(out.s+1, th_cookie_name.s, th_cookie_name.len);
out.s[th_cookie_name.len+1]='=';
memcpy(out.s+th_cookie_name.len+2, th_cookie_value.s, th_cookie_value.len);
out.s[out.len-1] = 'v';
out.s[out.len] = '\0';
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;
}
/**
* Adds a header to the message as the first one in the message
* @param msg - the message to add a header to
* @param content - the str containing the new header
* @returns 1 on succes, 0 on failure
*/
int cscf_add_header_first(struct sip_msg *msg, str *hdr,int type)
{
struct hdr_field *first;
struct lump* anchor,*l;
first = msg->headers;
anchor = anchor_lump(msg, first->name.s - msg->buf, 0 , 0 );
if (anchor == NULL) {
LM_DBG( "cscf_add_header_first: anchor_lump failed\n");
return 0;
}
if (!(l=insert_new_lump_before(anchor, hdr->s,hdr->len,type))){
LM_ERR( "cscf_add_header_first: error creating lump for header\n" );
return 0;
}
return 1;
}
int add_maxfwd_header( struct sip_msg* msg , unsigned int val )
{
unsigned int len;
char *buf;
struct lump* anchor;
/* constructing the header */
len = MF_HDR_LEN /*"MAX-FORWARDS: "*/+ CRLF_LEN + 3/*val max on 3 digits*/;
buf = (char*)pkg_malloc( len );
if (!buf) {
LOG(L_ERR, "ERROR:maxfwd:add_maxfwd_header: no more pkg memory\n");
goto error;
}
memcpy( buf , MF_HDR, MF_HDR_LEN );
len = MF_HDR_LEN ;
len += btostr( buf+len , val );
memcpy( buf+len , CRLF , CRLF_LEN );
len +=CRLF_LEN;
/*inserts the header at the beginning of the message*/
anchor = anchor_lump(msg, msg->headers->name.s - msg->buf, 0 , 0);
if (anchor == 0) {
LOG(L_ERR, "ERROR:maxfwd:add_maxfwd_header: failed to get anchor\n");
goto error1;
}
if (insert_new_lump_before(anchor, buf, len, 0) == 0) {
LOG(L_ERR, "ERROR:maxfwd:add_maxfwd_header: failed to insert "
"MAX-FORWARDS lump\n");
goto error1;
}
return 1;
error1:
pkg_free( buf );
error:
return -1;
}
static inline int add_diversion_helper(struct sip_msg* msg, str* s)
{
char *ptr;
static struct lump* anchor = 0;
static unsigned int msg_id = 0;
if (msg_id != msg->id) {
msg_id = msg->id;
anchor = 0;
}
if (!msg->diversion && parse_headers(msg, HDR_DIVERSION_F, 0) == -1) {
LM_ERR("header parsing failed\n");
return -1;
}
if (msg->diversion) {
/* Insert just before the topmost Diversion header */
ptr = msg->diversion->name.s;
} else {
/* Insert at the end */
ptr = msg->unparsed;
}
if (!anchor) {
anchor = anchor_lump(msg, ptr - msg->buf, 0);
if (!anchor) {
LM_ERR("can't get anchor\n");
return -2;
}
}
if (!insert_new_lump_before(anchor, s->s, s->len, 0)) {
LM_ERR("can't insert lump\n");
return -3;
}
return 0;
}
/*
* Copy of append_hf_helper from textops.
*/
static inline int append_rpid_helper(struct sip_msg* _m, str *_s)
{
struct lump* anchor;
if (parse_headers(_m, HDR_EOH_F, 0) == -1) {
LM_ERR("failed to parse message\n");
return -1;
}
anchor = anchor_lump(_m, _m->unparsed - _m->buf, 0);
if (!anchor) {
LM_ERR("can't get anchor\n");
return -2;
}
if (!insert_new_lump_before(anchor, _s->s, _s->len, 0)) {
LM_ERR("can't insert lump\n");
return -3;
}
return 0;
}
static int append_hf_helper(struct sip_msg* msg, str *str1, str *str2)
{
struct lump* anchor;
char *s;
int len;
if (parse_headers(msg, HDR_EOH_F, 0) == -1) {
LOG(L_ERR, "append_hf(): Error while parsing message\n");
return -1;
}
anchor = anchor_lump(msg, msg->unparsed - msg->buf, 0, 0);
if (anchor == 0) {
LOG(L_ERR, "append_hf(): Can't get anchor\n");
return -1;
}
len=str1->len;
if (str2) len+= str2->len + REQ_LINE(msg).uri.len;
s = (char*)pkg_malloc(len);
if (!s) {
LOG(L_ERR, "append_hf(): No memory left\n");
return -1;
}
memcpy(s, str1->s, str1->len);
if (str2) {
memcpy(s+str1->len, REQ_LINE(msg).uri.s, REQ_LINE(msg).uri.len);
memcpy(s+str1->len+REQ_LINE(msg).uri.len, str2->s, str2->len );
}
if (insert_new_lump_before(anchor, s, len, 0) == 0) {
LOG(L_ERR, "append_hf(): Can't insert lump\n");
pkg_free(s);
return -1;
}
return 1;
}
/*
* Append header to SIP message
* param msg SIP message
* param header Header to be appended
* return 0 success, -1 failure
*/
static int ospAppendHeader(
struct sip_msg* msg,
str* header)
{
char* s;
struct lump* anchor;
if((msg == 0) || (header == 0) || (header->s == 0) || (header->len <= 0)) {
LM_ERR("bad parameters for appending header\n");
return -1;
}
if (parse_headers(msg, HDR_EOH_F, 0) == -1) {
LM_ERR("failed to parse message\n");
return -1;
}
anchor = anchor_lump(msg, msg->unparsed - msg->buf, 0, 0);
if (anchor == 0) {
LM_ERR("failed to get anchor\n");
return -1;
}
s = (char*)pkg_malloc(header->len);
if (s == 0) {
LM_ERR("no pkg memory\n");
return -1;
}
memcpy(s, header->s, header->len);
if (insert_new_lump_before(anchor, s, header->len, 0) == 0) {
LM_ERR("failed to insert lump\n");
pkg_free(s);
return -1;
}
return 0;
}
static int insert_value_lump(struct sip_msg* msg, struct hdr_field* hf, char* msg_position, int lump_before, str *val) {
struct lump* anchor;
char *s;
int len;
anchor = anchor_lump(msg, msg_position - msg->buf, 0, 0);
if (anchor == 0) {
LOG(L_ERR, "ERROR: textops: insert_value_lump(): Can't get anchor\n");
return -1;
}
len=val->len+1;
s = (char*)pkg_malloc(len);
if (!s) {
LOG(L_ERR, "ERROR: textops: insert_value_lump(): not enough memory\n");
return -1;
}
if (!hf) {
memcpy(s, val->s, val->len);
len--;
}
else if (msg_position == hf->body.s+hf->body.len) {
s[0] = ',';
memcpy(s+1, val->s, val->len);
}
else {
memcpy(s, val->s, val->len);
s[val->len] = ',';
}
if ( (lump_before?insert_new_lump_before(anchor, s, len, 0):insert_new_lump_after(anchor, s, len, 0)) == 0) {
LOG(L_ERR, "ERROR: textops: insert_value_lump(): Can't insert lump\n");
pkg_free(s);
return -1;
}
return 1;
}
int gzc_set_msg_body(sip_msg_t *msg, str *obody, str *nbody)
{
struct lump *anchor;
char* buf;
/* none should be here - just for safety */
del_nonshm_lump( &(msg->body_lumps) );
msg->body_lumps = NULL;
if(del_lump(msg, obody->s - msg->buf, obody->len, 0) == 0)
{
LM_ERR("cannot delete existing body");
return -1;
}
anchor = anchor_lump(msg, obody->s - msg->buf, 0, 0);
if (anchor == 0)
{
LM_ERR("failed to get body anchor\n");
return -1;
}
buf=pkg_malloc(nbody->len * sizeof(char));
if (buf==0)
{
LM_ERR("out of pkg memory\n");
return -1;
}
memcpy(buf, nbody->s, nbody->len);
if (insert_new_lump_after(anchor, buf, nbody->len, 0) == 0)
{
LM_ERR("failed to insert body lump\n");
pkg_free(buf);
return -1;
}
return 0;
}
