sip.c

Go to the documentation of this file.

#include "sip.h"

#include "../../mem/mem.h"
#include "../../data_lump.h"
#include "../../data_lump_rpl.h"
#include "../../parser/parse_to.h"
#include "../../parser/parse_from.h"
#include "../../parser/parse_expires.h"
#include "../../parser/parse_via.h"
#include "../../parser/parse_content.h"
#include "../../parser/parse_nameaddr.h"
#include "../../parser/contact/contact.h"
#include "../../parser/contact/parse_contact.h"

#include "../tm/tm_load.h"

#include "mod.h"
#include "auth_api.h"

#define strtotime(src,dest) \
{\
    int i;\
    (dest)=0;\
    for(i=0;i<(src).len;i++)\
        if ((src).s[i]>='0' && (src).s[i]<='9')\
            (dest) = (dest)*10 + (src).s[i] -'0';\
}


#define get_qparam(src,name,dst) \
{\
    int i,j;\
    (dst).s=0;(dst).len=0;\
    for(i=0;i<(src).len-(name).len;i++)\
        if (strncasecmp((src).s+i,(name).s,(name).len)==0){\
            j=i+(name).len;\
            (dst).s = (src).s+j;\
            (dst).len = 0;\
            while(j<(src).len && (src).s[j]!='\"') \
                j++;            \
            (dst).len = j-i-(name).len;\
            break;\
        }       \
}

#define get_param(src,name,dst) \
{\
    int i,j;\
    (dst).s=0;(dst).len=0;\
    for(i=0;i<(src).len-(name).len;i++)\
        if (strncasecmp((src).s+i,(name).s,(name).len)==0 &&\
            ((src).s[i-1]==' ' ||(src).s[i-1]==';'||(src).s[i-1]=='\t')){\
            j=i+(name).len;\
            (dst).s = (src).s+j;\
            (dst).len = 0;\
            while(j<(src).len && (src).s[j]!=','&& (src).s[j]!=' '&& (src).s[j]!='\t'&& (src).s[j]!=';') \
                j++;            \
            (dst).len = j-i-(name).len;\
            break;\
        }       \
}

extern struct tm_binds tmb;            
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) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_add_header_first: anchor_lump failed\n");
        return 0;
    }

    if (!(l=insert_new_lump_before(anchor, hdr->s,hdr->len,type))){
        LOG(L_ERR, "ERR:"M_NAME":cscf_add_header_first: error creating lump for header\n" );
        return 0;
    }   
    return 1;
}

int cscf_add_header(struct sip_msg *msg, str *hdr,int type)
{
    struct hdr_field *last;
    struct lump* anchor;
    last = msg->headers;
    while(last->next) 
        last = last->next;
    anchor = anchor_lump(msg, last->name.s + last->len - msg->buf, 0 , 0);
    if (anchor == NULL) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_add_header_first: anchor_lump failed\n");
        return 0;
    }

    if (!insert_new_lump_after(anchor, hdr->s,hdr->len,type)){
        LOG(L_ERR, "ERR:"M_NAME":cscf_add_header_first: error creting lump for header\n" );
        return 0;
    }   
    return 1;
}

int cscf_add_header_rpl(struct sip_msg *msg, str *hdr)
{
    if (add_lump_rpl( msg, hdr->s, hdr->len, LUMP_RPL_HDR)==0) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_add_header_rpl: Can't add header <%.*s>\n",
            hdr->len,hdr->s);
        return 0;
    }
    return 1;
}



str cscf_get_private_identity(struct sip_msg *msg, str realm)
{
    str pi={0,0};
    struct hdr_field* h=0;
    int ret,i;

    if (parse_headers(msg,HDR_AUTHORIZATION_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_private_identity: Error parsing until header Authorization: \n");
        return pi;
    }

    if (!msg->authorization){
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_private_identity: Message does not contain Authorization header.\n");
        goto fallback;
    }

    ret = find_credentials(msg, &realm, HDR_AUTHORIZATION_F, &h);
    if (ret < 0) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_private_identity: Error while looking for credentials.\n");
        goto fallback;
    } else 
        if (ret > 0) {
            LOG(L_ERR, "ERR:"M_NAME":cscf_get_private_identity: No credentials for this realm found.\n");
            goto fallback;
        }
    
    if (h) pi=((auth_body_t*)h->parsed)->digest.username.whole;

    goto done;
        
fallback:
    LOG(L_INFO,"INF:"M_NAME":cscf_get_private_identity: Falling back to private_id=stripped(public_id)\n"
        "-> Message did not contain a valid Authorization Header!!! This fallback is deprecated outside Early-IMS or NASS-Bundled!\n"); 
    pi = cscf_get_public_identity(msg);
    if (pi.len>4&&strncasecmp(pi.s,"sip:",4)==0) {pi.s+=4;pi.len-=4;}
    for(i=0;i<pi.len;i++)
        if (pi.s[i]==';') {
            pi.len=i;
            break;
        }
done:   
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_private_identity: <%.*s> \n",
        pi.len,pi.s);
    return pi;  
}

str cscf_get_public_identity(struct sip_msg *msg)
{
    str pu={0,0};
    struct to_body *to;
    int i;
    
    if (parse_headers(msg,HDR_TO_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_public_identity: Error parsing until header To: \n");
        return pu;
    }
    
    if ( get_to(msg) == NULL ) {
        to = (struct to_body*) pkg_malloc(sizeof(struct to_body));
        parse_to( msg->to->body.s, msg->to->body.s + msg->to->body.len, to );
        msg->to->parsed = to;
    }
    else to=(struct to_body *) msg->to->parsed;

    pu = to->uri;
    
    /* truncate to sip:username@host or tel:number */
    for(i=4;i<pu.len;i++)
        if (pu.s[i]==';' || pu.s[i]=='?' ||pu.s[i]==':'){
            pu.len = i;
        }
    
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_public_identity: <%.*s> \n",
        pu.len,pu.s);   
    return pu;
}


    
int cscf_get_expires_hdr(struct sip_msg *msg)
{
    exp_body_t *exp;
    int expires;
    if (!msg) return -1;
    /*first search in Expires header */
    if (parse_headers(msg,HDR_EXPIRES_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_expires_hdr: Error parsing until header EXPIRES: \n");
        return -1;
    }
    if (msg->expires){      
        if (!msg->expires->parsed) {
            parse_expires(msg->expires);
        }
        if (msg->expires->parsed) {
            exp = (exp_body_t*) msg->expires->parsed;
            if (exp->valid) {
                expires = exp->val;
                LOG(L_DBG,"DBG:"M_NAME":cscf_get_expires_hdr: <%d> \n",expires);
                return expires;
            }
        }
    }
    
    return -1;
}

int cscf_get_max_expires(struct sip_msg *msg)
{
    unsigned int exp;
    int max_expires = -1;
    struct hdr_field *h;
    contact_t *c;
    /*first search in Expires header */
    max_expires = cscf_get_expires_hdr(msg);
    
    cscf_parse_contacts(msg);
    for(h=msg->contact;h;h=h->next){
        if (h->type==HDR_CONTACT_T && h->parsed) {
            for(c=((contact_body_t *) h->parsed)->contacts;c;c=c->next){
                if(c->expires){
                    if (!str2int(&(c->expires->body), (unsigned int*)&exp) && (int)exp>max_expires) max_expires = exp;
                }
            }
        }   
    }
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_max_expires: <%d> \n",max_expires);
    return max_expires;
}

str cscf_get_public_identity_from_requri(struct sip_msg *msg)
{
    str pu={0,0};
    
    if (msg->first_line.type!=SIP_REQUEST) {
        LOG(L_ERR,"INF:"M_NAME":cscf_get_public_identity_from_requri: This ain't a request \n");    
        return pu;
    }
    if (parse_sip_msg_uri(msg)<0){
        LOG(L_ERR,"INF:"M_NAME":cscf_get_public_identity_from_requri: Error parsing requesturi \n");    
        return pu;
    }
    
    if(msg->parsed_uri.type==TEL_URI_T){
        pu.len = 4 + msg->parsed_uri.user.len ;
        pu.s = shm_malloc(pu.len+1);
        sprintf(pu.s,"tel:%.*s",
            msg->parsed_uri.user.len,
            msg->parsed_uri.user.s);
    }else{
        pu.len = 4 + msg->parsed_uri.user.len + 1 + msg->parsed_uri.host.len;
        pu.s = shm_malloc(pu.len+1);
        sprintf(pu.s,"sip:%.*s@%.*s",
            msg->parsed_uri.user.len,   
            msg->parsed_uri.user.s, 
            msg->parsed_uri.host.len,   
            msg->parsed_uri.host.s);
    }   
    
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_public_identity_from_requri: <%.*s> \n",
        pu.len,pu.s);   
    return pu;
}

struct sip_msg *cscf_get_request(unsigned int hash,unsigned int label)
{
    struct cell *c;
    if (tmb.t_lookup_ident(&c,hash,label)<0){
        LOG(L_INFO,"INF:"M_NAME":Cx_UAA_timeout: No transaction found for %u %u\n",
            hash,label);
        return 0;
    }
    return c->uas.request;
}

static str s_ip={"integrity-protected",19};
int cscf_get_integrity_protected(struct sip_msg *msg,str realm)
{
    struct hdr_field* h=0;
    int ret,i,j;

    if (parse_headers(msg,HDR_AUTHORIZATION_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_integrity_protected: Error parsing until header Authorization: \n");
        return 0;
    }

    if (!msg->authorization){
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_integrity_protected: Message does not contain Authorization header.\n");
        return 0;
    }

    ret = find_credentials(msg, &realm, HDR_AUTHORIZATION_F, &h);
    if (ret < 0) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_integrity_protected: Error while looking for credentials.\n");
        return 0;
    } else 
        if (ret > 0) {
            LOG(L_ERR, "ERR:"M_NAME":cscf_get_integrity_protected: No credentials for this realm found.\n");
            return 0;
        }
    
    if (h) {
        for(i=0;i<h->body.len-s_ip.len;i++)
            if (strncasecmp(h->body.s+i,s_ip.s,s_ip.len)==0)
                for(j=i+s_ip.len;j<h->body.len;j++){
                    if (h->body.s[j]=='y' || h->body.s[j]=='Y') return 1;
                    if (h->body.s[j]==' ') return 0;
                }           
    }
    
    return 0;
}


int cscf_get_transaction(struct sip_msg *msg, unsigned int *hash,unsigned int *label)
{
    
    if (tmb.t_get_trans_ident(msg,hash,label)<0){   
        LOG(L_DBG,"DBG:"M_NAME":cscf_get_transaction: SIP message without transaction. OK - first request\n");
        if (tmb.t_newtran(msg)<0) 
            LOG(L_INFO,"INF:"M_NAME":cscf_get_transaction: Failed creating SIP transaction\n");
        if (tmb.t_get_trans_ident(msg,hash,label)<0){   
            LOG(L_INFO,"INF:"M_NAME":cscf_get_transaction: SIP message still without transaction\n");
            return -1;
        }else {
            LOG(L_DBG,"DBG:"M_NAME":cscf_get_transaction: New SIP message transaction %u %u\n",
                *hash,*label);
            return 1;
        }                       
    }else {
        LOG(L_INFO,"INF:"M_NAME":cscf_get_transaction: Transaction %u %u exists."
        "Retransmission?\n",*hash,*label);
        return 0;
    }
}

int cscf_reply_transactional(struct sip_msg *msg, int code, char *text)
{
    unsigned int hash,label;
    if (tmb.t_get_trans_ident(msg,&hash,&label)<0){ 
    
        if (tmb.t_newtran(msg)<0) 
            LOG(L_INFO,"INF:"M_NAME":cscf_get_transaction: Failed creating SIP transaction\n");
    }
    return tmb.t_reply(msg,code,text);
}

str cscf_get_auts(struct sip_msg *msg, str realm)
{
    str name={"auts=\"",6};
    struct hdr_field* h=0;
    int i,ret;
    str auts={0,0};

    if (parse_headers(msg,HDR_AUTHORIZATION_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_auts: Error parsing until header Authorization: \n");
        return auts;
    }

    if (!msg->authorization){
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_auts: Message does not contain Authorization header.\n");
        return auts;
    }

    ret = find_credentials(msg, &realm, HDR_AUTHORIZATION_F, &h);
    if (ret < 0) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_auts: Error while looking for credentials.\n");
        return auts;
    } else 
        if (ret > 0) {
            LOG(L_ERR, "ERR:"M_NAME":cscf_get_auts: No credentials for this realm found.\n");
            return auts;
        }
    
    if (h) {
        for(i=0;i<h->body.len-name.len;i++)
            if (strncasecmp(h->body.s+i,name.s,name.len)==0){
                auts.s = h->body.s+i+name.len;
                while(i+auts.len<h->body.len && auts.s[auts.len]!='\"')
                    auts.len++;
            }
    }
    
    return auts;    
}

str cscf_get_nonce(struct sip_msg *msg, str realm)
{
    struct hdr_field* h=0;
    int ret;
    str nonce={0,0};

    if (parse_headers(msg,HDR_AUTHORIZATION_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_nonce: Error parsing until header Authorization: \n");
        return nonce;
    }

    if (!msg->authorization){
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_nonce: Message does not contain Authorization header.\n");
        return nonce;
    }

    ret = find_credentials(msg, &realm, HDR_AUTHORIZATION_F, &h);
    if (ret < 0) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_nonce: Error while looking for credentials.\n");
        return nonce;
    } else 
        if (ret > 0) {
            LOG(L_ERR, "ERR:"M_NAME":cscf_get_nonce: No credentials for this realm found.\n");
            return nonce;
        }
    
    if (h&&h->parsed) {
        nonce = ((auth_body_t*)h->parsed)->digest.nonce;
    }
    
    return nonce;   
}

str cscf_get_algorithm(struct sip_msg *msg, str realm)
{
    struct hdr_field* h=0;
    int ret;
    str alg={0,0};

    if (parse_headers(msg,HDR_AUTHORIZATION_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_algorithm: Error parsing until header Authorization: \n");
        return alg;
    }

    if (!msg->authorization){
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_algorithm: Message does not contain Authorization header.\n");
        return alg;
    }

    ret = find_credentials(msg, &realm, HDR_AUTHORIZATION_F, &h);
    if (ret < 0) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_algorithm: Error while looking for credentials.\n");
        return alg;
    } else 
        if (ret > 0) {
            LOG(L_ERR, "ERR:"M_NAME":cscf_get_algorithm: No credentials for this realm found.\n");
            return alg;
        }
    
    if (h&&h->parsed) {
        alg = ((auth_body_t*)h->parsed)->digest.alg.alg_str;
    }
    return alg; 
}

str cscf_get_digest_uri(struct sip_msg *msg, str realm)
{
    struct hdr_field* h=0;
    int ret;
    str uri={0,0};

    if (parse_headers(msg,HDR_AUTHORIZATION_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_digest_uri: Error parsing until header Authorization: \n");
        return uri;
    }

    if (!msg->authorization){
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_digest_uri: Message does not contain Authorization header.\n");
        return uri;
    }

    ret = find_credentials(msg, &realm, HDR_AUTHORIZATION_F, &h);
    if (ret < 0) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_digest_uri: Error while looking for credentials.\n");
        return uri;
    } else 
        if (ret > 0) {
            LOG(L_ERR, "ERR:"M_NAME":cscf_get_digest_uri: No credentials for this realm found.\n");
            return uri;
        }
    
    if (h&&h->parsed) {
        uri = ((auth_body_t*)h->parsed)->digest.uri;
    }
    return uri; 
}

int cscf_get_nonce_response(struct sip_msg *msg, str realm,str *nonce,str *response,
    enum qop_type *qop,str *qop_str,str *nc,str *cnonce,str *uri)
{
    struct hdr_field* h=0;
    int ret;

    if (parse_headers(msg,HDR_AUTHORIZATION_F,0)!=0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_nonce: Error parsing until header Authorization: \n");
        return 0;
    }

    if (!msg->authorization){
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_nonce: Message does not contain Authorization header.\n");
        return 0;
    }

    ret = find_credentials(msg, &realm, HDR_AUTHORIZATION_F, &h);
    if (ret < 0) {
        LOG(L_ERR, "ERR:"M_NAME":cscf_get_nonce: Error while looking for credentials.\n");
        return 0;
    } else 
        if (ret > 0) {
            LOG(L_ERR, "ERR:"M_NAME":cscf_get_nonce: No credentials for this realm found.\n");
            return 0;
        }
    
    if (h&&h->parsed) {
        if (nonce) *nonce = ((auth_body_t*)h->parsed)->digest.nonce;
        if (response) *response = ((auth_body_t*)h->parsed)->digest.response;
        if (qop) *qop = ((auth_body_t*)h->parsed)->digest.qop.qop_parsed;
        if (qop_str) *qop_str = ((auth_body_t*)h->parsed)->digest.qop.qop_str;
        if (nc) *nc = ((auth_body_t*)h->parsed)->digest.nc;
        if (cnonce) *cnonce = ((auth_body_t*)h->parsed)->digest.cnonce;
        if (uri) *uri = ((auth_body_t*)h->parsed)->digest.uri;
    }
    
    return 1;   
}


str ua_dummy={"Unknown UA",10};
str ua_nomsg={"No Message",10};
str cscf_get_user_agent(struct sip_msg *msg)
{
    str ua;
    if (!msg) return ua_nomsg;
    ua.len = 0;
    if (parse_headers(msg, HDR_USERAGENT_F, 0) != -1 && msg->user_agent &&
        msg->user_agent->body.len > 0) 
    {
        ua.len = msg->user_agent->body.len;
        ua.s = msg->user_agent->body.s;
    }
    if (ua.len == 0) ua=ua_dummy;
    return ua;
}

contact_body_t *cscf_parse_contacts(struct sip_msg *msg)
{
    struct hdr_field* ptr;
    if (!msg) return 0;
    if (parse_headers(msg, HDR_EOH_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_parse_contacts: Error parsing headers \n");
        return 0;
    }
    if (msg->contact) {
        ptr = msg->contact;
        while(ptr) {
            if (ptr->type == HDR_CONTACT_T) {
                if (ptr->parsed==0){
                    if (parse_contact(ptr)<0){
                            LOG(L_ERR,"ERR:"M_NAME":cscf_parse_contacts: error parsing contacts [%.*s]\n",
                                ptr->body.len,ptr->body.s);                         
                    }
                }
            }                   
            ptr = ptr->next;
        }
    }
    if (!msg->contact) return 0;
    return msg->contact->parsed;
}

str cscf_get_path(struct sip_msg *msg)
{
    str path={0,0};
    struct hdr_field *h;
    if (!msg) return path;
    if (parse_headers(msg, HDR_EOH_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_path: error parsing headers\n");
        return path;
    }
    h = msg->headers;
    while(h){
        if (h->name.len==4 &&
            strncasecmp(h->name.s,"Path",4)==0){
                path.len+=h->body.len+1;
            }
        h = h->next;
    }
    path.s = pkg_malloc(path.len);
    if (!path.s){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_path: error allocating %d bytes\n",
            path.len);
        path.len=0;
        return path;
    }
    h = msg->headers;
    path.len=0;
    while(h){
        if (h->name.len==4 &&
            strncasecmp(h->name.s,"Path",4)==0){
                if (path.len) path.s[path.len++]=',';
                memcpy(path.s+path.len,h->body.s,h->body.len);
                path.len+=h->body.len;
            }
        h = h->next;
    }

    return path;
}

str cscf_get_event(struct sip_msg *msg)
{
    str e={0,0};
    if (!msg) return e;
    if (parse_headers(msg, HDR_EVENT_F, 0) != -1 && msg->event &&
        msg->event->body.len > 0) 
    {
        e.len = msg->event->body.len;
        e.s = msg->event->body.s;
    }
    return e;
}


str s_asserted_identity={"P-Asserted-Identity",19};
str cscf_get_asserted_identity(struct sip_msg *msg)
{
    name_addr_t id;
    struct hdr_field *h;
    rr_t *r;
    memset(&id,0,sizeof(name_addr_t));
    if (!msg) return id.uri;
    if (parse_headers(msg, HDR_EOH_F, 0)<0) {
        return id.uri;
    }
    h = msg->headers;
    while(h)
    {
        if (h->name.len == s_asserted_identity.len  &&
            strncasecmp(h->name.s,s_asserted_identity.s,s_asserted_identity.len)==0)
        {
            if (parse_rr(h)<0){
                //This might be an old client
                LOG(L_CRIT,"WARN:"M_NAME":cscf_get_asserted_identity: P-Asserted-Identity header must contain a Nameaddr!!! Fix the client!\n");
                id.name.s = h->body.s;
                id.name.len = 0;
                id.len = h->body.len;
                id.uri = h->body;
                while(id.uri.len && (id.uri.s[0]==' ' || id.uri.s[0]=='\t' || id.uri.s[0]=='<')){
                    id.uri.s = id.uri.s+1;
                    id.uri.len --;
                }
                while(id.uri.len && (id.uri.s[id.uri.len-1]==' ' || id.uri.s[id.uri.len-1]=='\t' || id.uri.s[id.uri.len-1]=='>')){
                    id.uri.len--;
                }
                return id.uri;  
            }
            r = (rr_t*) h->parsed;
            id = r->nameaddr; 
            free_rr(&r);
            h->parsed=r;
            //LOG(L_CRIT,"%.*s",id.uri.len,id.uri.s);
            return id.uri;
        }
        h = h->next;
    }
    return id.uri;
}

str cscf_get_asserted_identity_domain(struct sip_msg *msg)
{
    struct sip_uri puri;
    str uri = cscf_get_asserted_identity(msg);
    if (!uri.len) return uri;
    
    if (parse_uri(uri.s,uri.len,&puri)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_asserted_identity_domain: error parsing uri <%.*s>\n",
            uri.len,uri.s);
        uri.len=0;uri.s=0;
        return uri;         
    }
    return puri.host;
}

str cscf_get_contact(struct sip_msg *msg)
{
    str id={0,0};
    struct hdr_field *h;
    struct contact_body *cb;
    
    if (!msg) return id;
    if (parse_headers(msg, HDR_CONTACT_F, 0)<0) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_contact: Error parsing headers until Contact.\n");
        return id;
    }

    h = msg->contact;
    if (!h) {
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_contact: Contact header not found.\n");
        return id;
    }
    if (h->parsed==0 &&
        parse_contact(h)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_contact: Error parsing contacts.\n");
        return id;
    }
    
    cb = (struct contact_body *)h->parsed;
    if (!cb || !cb->contacts){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_contact: No contacts in header.\n");
        return id;
    }
    id = cb->contacts->uri;
    
    return id;
}


str cscf_get_first_route(struct sip_msg *msg,struct hdr_field **hr)
{
    struct hdr_field *h;
    rr_t *r;
    str route={0,0};
    if (hr) *hr = 0;    
    if (!msg) return route;
    if (parse_headers(msg, HDR_ROUTE_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_first_route: error parsing headers\n");
        return route;
    }
    h = msg->route;
    if (!h){
        LOG(L_DBG,"DBG:"M_NAME":cscf_get_first_route: Header Route not found\n");
        return route;
    }
    if (hr) *hr = h;
    if (parse_rr(h)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_first_route: Error parsing as Route header\n");
        return route;
    }
    r = (rr_t*)h->parsed;
    route = r->nameaddr.uri;
    
    return route;
}

static str route_hdr_s={"Route: ",7};
static str route_hdr_e={"\r\n",2};
int cscf_remove_first_route(struct sip_msg *msg,str value)
{
    struct hdr_field *h;
    str route={0,0},x;
    int i;
        
    route = cscf_get_first_route(msg,&h);
    if (!h||!route.len) return 0;
    
    if ((route.len == value.len || (route.len>value.len && route.s[value.len]==';')) &&
        strncasecmp(route.s,value.s,value.len)==0)
    {
        cscf_del_header(msg,h);
        route = h->body;
        i=0;
        while(i<route.len && route.s[i]!=',')
            i++;
        i++;
        if (i<route.len){
            route.s+=i;
            route.len-=i;
            x.s = pkg_malloc(route_hdr_s.len + route.len +route_hdr_e.len);
            if (!x.s){
                LOG(L_ERR, "ERR"M_NAME":cscf_remove_first_route: Error allocating %d bytes\n",
                    route.len);
                x.len=0;
            }else{
                x.len = 0;
                STR_APPEND(x,route_hdr_s);
                STR_APPEND(x,route);
                STR_APPEND(x,route_hdr_e);              
                if (!cscf_add_header_first(msg,&x,HDR_ROUTE_T))
                    pkg_free(x.s);
            }
        }
    }
    
    return 1;
}



inline int cscf_is_myself(str uri)
{
    int ret;
    struct sip_uri puri;
    
    if (parse_uri(uri.s,uri.len,&puri)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_is_myself: error parsing uri <%.*s>\n",
            uri.len,uri.s);
        return 0;           
    }
    
    ret = check_self(&(puri.host), puri.port_no ? puri.port_no : SIP_PORT, 0);
    if (ret < 0) return 0;
    
    return ret;
}

int cscf_remove_own_route(struct sip_msg *msg,struct hdr_field **h)
{
    str route={0,0},x;
    int i;
        
    route = cscf_get_first_route(msg,h);
    if (!h||!route.len) return 0;
    
    LOG(L_DBG,"DBG:"M_NAME":cscf_remove_own_route: <%.*s>\n",
        route.len,route.s);
    if (cscf_is_myself(route))
    {
        cscf_del_header(msg,*h);
        route = (*h)->body;
        i=0;
        while(i<route.len && route.s[i]!=',')
            i++;
        i++;
        if (i<route.len){
            route.s+=i;
            route.len-=i;
            x.s = pkg_malloc(route_hdr_s.len + route.len +route_hdr_e.len);
            if (!x.s){
                LOG(L_ERR, "ERR"M_NAME":cscf_remove_own_route: Error allocating %d bytes\n",
                    route.len);
                x.len=0;
            }else{
                x.len = 0;
                STR_APPEND(x,route_hdr_s);
                STR_APPEND(x,route);
                STR_APPEND(x,route_hdr_e);              
                if (!cscf_add_header_first(msg,&x,HDR_ROUTE_T))
                    pkg_free(x.s);
            }
        }
    }
    
    return 1;
}


static str s_record_route={"Record-route",12};
str cscf_get_record_routes(struct sip_msg *msg)
{
    struct hdr_field *h;
    str route={0,0};
    
    if (!msg) return route;
    
    if (parse_headers(msg, HDR_EOH_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_record_routes: error parsing headers\n");
        return route;
    }
    h = msg->record_route;
    while (h){
        if (h->name.len == s_record_route.len &&
            strncasecmp(h->name.s,s_record_route.s,s_record_route.len)==0)
        {
            LOG(L_DBG,"DBG:"M_NAME":cscf_get_record_routes: RR %.*s\n",h->body.len,h->body.s);
            if (route.s){
                route.s = pkg_realloc(route.s,route.len+1+h->body.len);
                route.s[route.len++]=',';
            }else{
                route.s = pkg_malloc(h->body.len);          
            }
            memcpy(route.s+route.len,h->body.s,h->body.len);
            route.len+=h->body.len;
        }
        h = h->next;
    }   
    return route;
}

struct hdr_field* cscf_get_next_record_route(struct sip_msg *msg,struct hdr_field *start)
{
    struct hdr_field *h;
    
    if (!msg) return 0;
    
    
    if (parse_headers(msg, HDR_EOH_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_next_record_routes: error parsing headers\n");
        return 0;
    }
    if (start) h = start->next;
    else h = msg->record_route;
    while (h){
        if (h->type == HDR_RECORDROUTE_T)
        {
            LOG(L_DBG,"DBG:"M_NAME":cscf_get_next_record_routes: RR %.*s\n",h->body.len,h->body.s);
            if (!h->parsed){
                if (parse_rr(h)<0){
                    LOG(L_ERR,"ERR:"M_NAME":cscf_get_next_record_routes: Error parsing as Route header\n");
                    return 0;
                }               
            }
            return h;
        }
        h = h->next;
    }   
    return 0;
}

struct hdr_field* cscf_get_next_via_hdr(struct sip_msg *msg,struct hdr_field *start)
{
    struct hdr_field *h;
    
    if (!msg) return 0;
    
    if (parse_headers(msg, HDR_EOH_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_next_via: error parsing headers\n");
        return 0;
    }
    if (start) h = start->next;
    else h = msg->headers;
    while (h){
        if (h->type == HDR_VIA_T)
            return h;
        h = h->next;
    }   
    return 0;
}

static int str_trim(str *s)
{
    int i;
    for (i = 0;i < s->len; i++)
    {
        if (s->s[i] != '\r' && s->s[i] != '\t' && s->s[i] != ' ')
        {
            break;
        }
    }
    s->s = s->s + i;    
    s->len -= i;

    for (i = s->len;i >=0; i--)
    {
        if (s->s[i] == '\r' && s->s[i] == '\t' && s->s[i] == ' ')
        {
            s->len--;
        }
        else
        {
            break;
        }
    }
    return 1;
}

str cscf_get_next_via_str(struct sip_msg *msg, struct hdr_field * h, int pos, struct hdr_field **h_out, int *pos_out)
{
    char *viab;
    int i, viab_start;
    str via_str={0,0};
    if (!h_out || !pos_out)
        return via_str; 
    
    if (!h)
    {
        h = cscf_get_next_via_hdr(msg,0);
        pos = 0;
    }

    viab = h->body.s;
    i = viab_start = pos;

    while (i < h->body.len)
    {
        if (viab[i] == ',')
        {
            via_str.s = viab + viab_start;
            via_str.len = i - viab_start;
            str_trim(&via_str);
            viab_start = i+1;
            *h_out = h;
            *pos_out = viab_start;
            return via_str;
        }
        i++;
    }
    via_str.s = viab + viab_start;
    via_str.len = i - viab_start;
    str_trim(&via_str);
    *h_out = cscf_get_next_via_hdr(msg,h);
    *pos_out = 0;   
    return via_str;
}

int cscf_via_matching( struct via_body *req_via, struct via_body *rpl_via )
{
    if ((!req_via->branch && rpl_via->branch) || (req_via->branch && !rpl_via->branch))
    {
        LOG(L_INFO,"DBG:"M_NAME":cscf_via_matching: branch param missing\n");
        return 0;;
    }
    if (req_via->branch && rpl_via->branch)
    {
        if (req_via->branch->value.len != rpl_via->branch->value.len ||
            strncasecmp(req_via->branch->value.s, rpl_via->branch->value.s,rpl_via->branch->value.len)!=0)
        {
            LOG(L_INFO,"DBG:"M_NAME":cscf_via_matching: different branch param\n");
            return 0;
        }
    }
    if (req_via->host.len!=rpl_via->host.len||
        strncasecmp(req_via->host.s, rpl_via->host.s,rpl_via->host.len)!=0)
    {
        LOG(L_INFO,"DBG:"M_NAME":cscf_via_matching: different host \n");
        return 0;
    }
    if (req_via->port!=rpl_via->port)
    {
        LOG(L_INFO,"DBG:"M_NAME":cscf_via_matching: different port \n");
        return 0;
    }
    
    if (req_via->transport.len!=rpl_via->transport.len||
        strncasecmp(req_via->transport.s, rpl_via->transport.s,rpl_via->transport.len)!=0)
    {
        LOG(L_INFO,"DBG:"M_NAME":cscf_via_matching: transport host \n");
        return 0;
    }
    /* everything matched -- we found it */
    return 1;
}





static inline void free_via_param_list(struct via_param* vp)
{
    struct via_param* foo;
    while(vp){
        foo=vp;
        vp=vp->next;
        pkg_free(foo);
    }
}

static str via_hdr_term={"\r\n.",3};
int cscf_str_via_matching(str *sreq_via, str *srpl_via)
{   
    struct via_body req_via, rpl_via;
    str hdr1={0,0}, hdr2={0,0};
    int result = 0;
    
    memset(&req_via, 0, sizeof(struct via_body));
    memset(&rpl_via, 0, sizeof(struct via_body));

    if (sreq_via->s[sreq_via->len+1] !='\r' || sreq_via->s[sreq_via->len+2] != '\n') //check for CRLF 
    {
        hdr1.len = sreq_via->len + via_hdr_term.len;
        hdr1.s = pkg_malloc(hdr1.len);
        if (!hdr1.s)
        {
            LOG(L_ERR, "ERR:"M_NAME":cscf_str_via_matching: cannot alloc bytes : %d", hdr1.len);
            return 0;
        }
        hdr1.len=0;
        STR_APPEND(hdr1, *sreq_via);
        STR_APPEND(hdr1, via_hdr_term);
        parse_via(hdr1.s,hdr1.s+hdr1.len,&req_via);
    }
    else
        parse_via(sreq_via->s,sreq_via->s+sreq_via->len, &req_via);
    
    
    if (srpl_via->s[srpl_via->len+1] !='\r' || srpl_via->s[srpl_via->len+2] != '\n') //check for CRLF 
    {
        hdr2.len = srpl_via->len + via_hdr_term.len;
        hdr2.s = pkg_malloc(hdr2.len);
        if (!hdr2.s)
        {
            LOG(L_ERR, "ERR:"M_NAME":cscf_str_via_matching: cannot alloc bytes : %d", hdr2.len);
            goto done;
        }
        hdr2.len=0;
        STR_APPEND(hdr2, *srpl_via);
        STR_APPEND(hdr2, via_hdr_term);
        parse_via(hdr2.s,hdr2.s+hdr2.len,&rpl_via);
    }
    else
        parse_via(srpl_via->s, srpl_via->s+srpl_via->len, &rpl_via);
        
    result = cscf_via_matching(&req_via, &rpl_via);
    
done:   
    if (hdr1.s) pkg_free(hdr1.s);
    if (hdr1.s) pkg_free(hdr2.s);
    if (req_via.param_lst) free_via_param_list(req_via.param_lst);
    if (rpl_via.param_lst) free_via_param_list(rpl_via.param_lst);
    return result;
}



str cscf_get_realm_from_ruri(struct sip_msg *msg)
{
    str realm={0,0};
    if (!msg || msg->first_line.type!=SIP_REQUEST){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_realm_from_ruri: This is not a request!!!\n");
        return realm;
    }
    if (!msg->parsed_orig_ruri_ok)
        if (parse_orig_ruri(msg) < 0) 
            return realm;
    
    realm = msg->parsed_orig_ruri.host;
    return realm;   
}

str cscf_get_identity_from_ruri(struct sip_msg *msg)
{
    str aor={0,0};
    if (!msg || msg->first_line.type!=SIP_REQUEST){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_identity_from_ruri: This is not a request!!!\n");
        return aor;
    }
    aor.s = msg->first_line.u.request.uri.s;
    aor.len = 0;
    while(aor.s[aor.len]!=' '&&aor.s[aor.len]!='\t'&&
          aor.s[aor.len]!=';'&&aor.s[aor.len]!='&'&&
          aor.s[aor.len]!='\r'&&aor.s[aor.len]!='\n')
        aor.len++;
//  if (!msg->parsed_orig_ruri_ok)
//      if (parse_orig_ruri(msg) < 0) 
//          return aor;
//          
//  aor = msg->parsed_orig_ruri.host;
//  if (msg->parsed_orig_ruri.user.len){
//      aor.s = msg->parsed_orig_ruri.;
//      aor.len = msg->parsed_orig_ruri.user.len+msg->parsed_orig_ruri.passwd.len+1+
//          msg->parsed_orig_ruri.host.len;
//  }
    return aor; 
}


str cscf_get_call_id(struct sip_msg *msg,struct hdr_field **hr)
{
    struct hdr_field *h;
    str call_id={0,0};
    if (hr) *hr = 0;    
    if (!msg) return call_id;
    if (parse_headers(msg, HDR_CALLID_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_call_id: error parsing headers\n");
        return call_id;
    }
    h = msg->callid;
    if (!h){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_call_id: Header Call-ID not found\n");
        return call_id;
    }
    if (hr) *hr = h;
    call_id = h->body;  
    return call_id;
}


int cscf_get_cseq(struct sip_msg *msg,struct hdr_field **hr)
{
    struct hdr_field *h;
    struct cseq_body *cseq;
    int nr = 0,i;
    
    if (hr) *hr = 0;    
    if (!msg) return 0;
    if (parse_headers(msg, HDR_CSEQ_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_cseq: error parsing headers\n");
        return 0;
    }
    h = msg->cseq;
    if (!h){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_cseq: Header CSeq not found\n");
        return 0;
    }
    if (hr) *hr = h;
    if (!h->parsed){
        cseq = pkg_malloc(sizeof(struct cseq_body));
        if (!cseq){
            LOG(L_ERR,"ERR:"M_NAME":cscf_get_cseq: Header CSeq not found\n");
            return 0;
        }
        parse_cseq(h->body.s,h->body.s+h->body.len,cseq);
        h->parsed = cseq;
    }else
        cseq = (struct cseq_body*) h->parsed;       
    for(i=0;i<cseq->number.len;i++)
        nr = (nr*10)+(cseq->number.s[i]-'0');
    return nr;
}

str cscf_get_cseq_method(struct sip_msg *msg,struct hdr_field **hr)
{
    struct hdr_field *h;
    struct cseq_body *cseq;
    str method = {0,0};
    
    if (hr) *hr = 0;    
    if (!msg) return method;
    if (parse_headers(msg, HDR_CSEQ_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_cseq: error parsing headers\n");
        return method;
    }
    h = msg->cseq;
    if (!h){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_cseq: Header CSeq not found\n");
        return method;
    }
    if (hr) *hr = h;
    if (!h->parsed){
        cseq = pkg_malloc(sizeof(struct cseq_body));
        if (!cseq){
            LOG(L_ERR,"ERR:"M_NAME":cscf_get_cseq: Header CSeq not found\n");
            return method;
        }
        parse_cseq(h->body.s,h->body.s+h->body.len,cseq);
        h->parsed = cseq;
    }else
        cseq = (struct cseq_body*) h->parsed;       
    return cseq->method;
}

struct sip_msg* cscf_get_request_from_reply(struct sip_msg *reply)
{
    struct cell *t;
    t = tmb.t_gett();
    if (!t || t==(void*) -1){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_request_from_reply: Reply without transaction\n");
        return 0;
    }
    if (t) return t->uas.request;
    else return 0;
}


static str s_called_party_id={"P-Called-Party-ID",17};
str cscf_get_called_party_id(struct sip_msg *msg,struct hdr_field **hr)
{
    str id={0,0};
    struct hdr_field *h;
    if (hr) *hr=0;
    if (!msg) return id;
    if (parse_headers(msg, HDR_EOH_F, 0)<0) {
        return id;
    }
    h = msg->headers;
    while(h)
    {
        if (h->name.len == s_called_party_id.len  &&
            strncasecmp(h->name.s,s_called_party_id.s,s_called_party_id.len)==0)
        {
            id = h->body;
            while(id.len && (id.s[0]==' ' || id.s[0]=='\t' || id.s[0]=='<')){
                id.s = id.s+1;
                id.len --;
            }
            while(id.len &&am