sip.c

Go to the documentation of this file.

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#include "../../str.h"
#include "../../parser/parse_expires.h"
#include "../../dprint.h"
#include "../../mem/mem.h"
#include "../scscf/scscf_load.h"
#include "../tm/tm_load.h"


#include "sip.h"
#include "mod.h"
#include "mark.h"

extern struct tm_binds isc_tmb;            
extern struct scscf_binds isc_scscfb;            
int str2cmp(str x, str y) {
    if (x.len < y.len) return -1;
    if (x.len > y.len) return +1;
    return strncmp(x.s, y.s, x.len);
}

int str2icmp(str x, str y) {
    if (x.len < y.len) return -1;
    if (x.len > y.len) return +1;
    return strncasecmp(x.s, y.s, x.len);
}


static str bye_s={"BYE",3};
static str ack_s={"ACK",3};
static str prack_s={"PRACK",5};
static str update_s={"UPDATE",6};
static str notify_s={"NOTIFY",6};
int isc_is_initial_request(struct sip_msg *msg)
{
    if (msg->first_line.type != SIP_REQUEST ) return 0;
    if (strncasecmp(msg->first_line.u.request.method.s,bye_s.s,bye_s.len)==0) return 0;
    if (strncasecmp(msg->first_line.u.request.method.s,ack_s.s,ack_s.len)==0) return 0;
    if (strncasecmp(msg->first_line.u.request.method.s,prack_s.s,prack_s.len)==0) return 0;
    if (strncasecmp(msg->first_line.u.request.method.s,update_s.s,update_s.len)==0) return 0;
    if (strncasecmp(msg->first_line.u.request.method.s,notify_s.s,notify_s.len)==0) return 0;
    return 1;
}


static str register_s={"REGISTER",8};
int isc_is_register(struct sip_msg *msg)
{
    if (msg->first_line.type != SIP_REQUEST ) return 0;
    if (strncasecmp(msg->first_line.u.request.method.s,register_s.s,register_s.len)==0) return 1;           
    return 0;
}


static inline void isc_strip_uri(str *uri)
{
    int i;
    /* Strip the ending */
    i=0;
    while(i<uri->len&&uri->s[i]!='@')
        i++;
    while(i<uri->len&&
            uri->s[i]!=':'&&
            uri->s[i]!='/'&&
            uri->s[i]!='&')
        i++;
    uri->len=i;
}


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_RIT,"%.*s",id.uri.len,id.uri.s);
            return id.uri;
        }
        h = h->next;
    }
    return id.uri;
}
int isc_get_originating_user( struct sip_msg * msg, isc_mark *mark, str *uri )
{
    struct to_body * from;
    if (mark && mark->aor.len){
        *uri = mark->aor;
        return 1;
    }
    *uri = cscf_get_asserted_identity(msg);
    if (!uri->len) {        
        /* Fallback to From header */
        if ( parse_from_header( msg ) == -1 ) {
            LOG(L_ERR,"ERROR:"M_NAME":isc_get_originating_user: unable to extract URI from FROM header\n" );
            return 0;
        }
        if (!msg->from) return 0;
        from = (struct to_body*) msg->from->parsed;
        *uri = from->uri;
        isc_strip_uri(uri);
    }
    DBG("DEBUG:"M_NAME":isc_get_originating_user: From %.*s\n", uri->len,uri->s );
    return 1;
}

int isc_is_registered(str *uri)
{
    int result = 0;
    r_public *p;
    
    p = isc_scscfb.get_r_public(*uri);
    
    if (p) {
        result = p->reg_state;
        isc_scscfb.r_unlock(p->hash);
    }   
    return result;
}

inline int isc_get_terminating_type(str *uri)
{
    if (isc_is_registered(uri)) return IFC_TERMINATING_SESSION;
        else return IFC_TERMINATING_UNREGISTERED;
}

str cscf_get_public_identity_from_requri(struct sip_msg *msg)
{
    str pu={0,0};
    int i;
    if (msg->first_line.type!=SIP_REQUEST) {
        LOG(L_INFO,"ERR:"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,"ERR:"M_NAME":cscf_get_public_identity_from_requri: Error parsing requesturi \n");    
        return pu;
    }
    pu = msg->first_line.u.request.uri;
    for(i=0;i<pu.len&& pu.s[i]!=';'&&pu.s[i]!='?';i++);
    pu.len = i;
    
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_public_identity_from_requri: <%.*s> \n",
        pu.len,pu.s);   
    return pu;
}

int isc_get_terminating_user( struct sip_msg * msg, isc_mark *mark, str *uri )
{
    if (mark && mark->aor.len){
        *uri = mark->aor;
        return 1;
    }   
    *uri = cscf_get_public_identity_from_requri(msg);
    if (!uri->len) return IMS_USER_NOT_REGISTERED;
    /*if ( isc_get_terminating_type( uri ) == IFC_TERMINATING_UNREGISTERED )
        DBG("DBG:"M_NAME":isc_get_terminating_type: To UNREGISTERED %.*s\n", uri->len,uri->s);
    else
        DBG("DBG:"M_NAME":isc_get_terminating_type: To REGISTERED %.*s\n", uri->len,uri->s);    */
    return IMS_USER_REGISTERED;
}


int isc_get_expires(struct sip_msg *msg)
{   
    if (msg->expires) {
        if (parse_expires(msg->expires) < 0) {
            LOG(L_INFO, "INFO:ifc:ifc_get_expires:Error while parsing Expires header\n");
            return -1;
        }
         return ((exp_body_t*) msg->expires->parsed)->val;
    } else {
        return -1;
    }
}


int cscf_get_transaction(struct sip_msg *msg, unsigned int *hash,unsigned int *label)
{
    
    if (isc_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 (isc_tmb.t_newtran(msg)<0) 
            LOG(L_INFO,"INF:"M_NAME":cscf_get_transaction: Failed creating SIP transaction\n");
        if (isc_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;
    }
}


struct sip_msg* cscf_get_request_from_reply(struct sip_msg *reply)
{
    struct cell *t;
    t = isc_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;
    }
    return t->uas.request;
}

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;
}

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 (msg->contact->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;
}

int cscf_get_first_p_associated_uri(struct sip_msg *msg,str *public_id)
{
    struct hdr_field *h;
    rr_t *r;
    public_id->s=0;public_id->len=0;
    
    if (!msg) return 0;
    if (parse_headers(msg, HDR_EOH_F, 0)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_p_associated_uri: error parsing headers\n");
        return 0;
    }
    h = msg->headers;
    while(h){
        if (h->name.len==16 && strncasecmp(h->name.s,"P-Associated-URI",16)==0)
            break;
        h = h->next;
    }
    if (!h){
        LOG(L_DBG,"DBG:"M_NAME":cscf_get_p_associated_uri: Header P-Associated-URI not found\n");
        return 0;
    }
    if (parse_rr(h)<0){
        LOG(L_ERR,"ERR:"M_NAME":cscf_get_p_associated_uri: Error parsing as Route header\n");
        return 0;
    }
    r = (rr_t*)h->parsed;
    h->type = HDR_ROUTE_T;
    
    if (r) {
        *public_id=r->nameaddr.uri;
        return 1;
    }
    else
        return 0;
}

str cscf_get_public_identity(struct sip_msg *msg)
{
    str pu={0,0};
    struct to_body *to;
    
    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;
    
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_public_identity: <%.*s> \n",
        pu.len,pu.s);
    return pu;
}

str cscf_p_access_network_info={"P-Access-Network-Info",21};

str cscf_get_access_network_info(struct sip_msg *msg, struct hdr_field **h)
{
    str ani={0,0};
    struct hdr_field *hdr;
    
    *h=0;
    if (parse_headers(msg,HDR_EOH_F,0)!=0) {
        LOG(L_DBG,"DBG:"M_NAME":cscf_get_access_network_info: Error parsing until header EOH: \n");
        return ani;
    }
    hdr = msg->headers;
    while(hdr){
        if (hdr->name.len==cscf_p_access_network_info.len &&
            strncasecmp(hdr->name.s,cscf_p_access_network_info.s,hdr->name.len)==0)
        {
            *h = hdr;
            ani = hdr->body;
            goto done;
        }                 
        hdr = hdr->next;
    }
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_access_network_info: P-Access-Network-Info header not found \n");
    
done:
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_access_network_info: <%.*s> \n",
        ani.len,ani.s);
    return ani;
}

str cscf_p_visited_network_id={"P-Visited-Network-ID",20};

str cscf_get_visited_network_id(struct sip_msg *msg, struct hdr_field **h)
{
    str vnid={0,0};
    struct hdr_field *hdr;
    
    *h=0;
    if (parse_headers(msg,HDR_EOH_F,0)!=0) {
        LOG(L_DBG,"DBG:"M_NAME":cscf_get_public_identity: Error parsing until header EOH: \n");
        return vnid;
    }
    hdr = msg->headers;
    while(hdr){
        if (hdr->name.len==cscf_p_visited_network_id.len &&
            strncasecmp(hdr->name.s,cscf_p_visited_network_id.s,hdr->name.len)==0)
        {
            *h = hdr;
            vnid = hdr->body;
            goto done;
        }
        hdr = hdr->next;
    }
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_visited_network_id: P-Visited-Network-ID header not found \n");

done:
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_visited_network_id: <%.*s> \n",
        vnid.len,vnid.s);
    return vnid;
}

str cscf_p_charging_vector={"P-Charging-Vector",17};

str cscf_get_charging_vector(struct sip_msg *msg, struct hdr_field **h)
{
    str cv={0,0};
    struct hdr_field *hdr;
    
    *h=0;
    if (parse_headers(msg,HDR_EOH_F,0)!=0) {
        LOG(L_DBG,"DBG:"M_NAME":cscf_get_charging_vector: Error parsing until header EOH: \n");
        return cv;
    }
    hdr = msg->headers;
    while(hdr){
        if (hdr->name.len==cscf_p_charging_vector.len &&
            strncasecmp(hdr->name.s,cscf_p_charging_vector.s,hdr->name.len)==0)
        {
            *h = hdr;
            cv = hdr->body;
            goto done;
        }
        hdr = hdr->next;
    }
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_charging_vector: P-Charging-Vector header not found \n");

done:
    LOG(L_DBG,"DBG:"M_NAME":cscf_get_charging_vector: <%.*s> \n",
        cv.len,cv.s);
    return cv;
}

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;
}

---