mark.c

Go to the documentation of this file.

#include <stdio.h>

#include "../../mem/mem.h"
#include "../../dprint.h"
#include "../../action.h"

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

extern str isc_my_uri;              
char *hexchars="0123456789abcdef";
int bin_to_base16(char *from,int len, char *to)
{
    int i,j;
    for(i=0,j=0;i<len;i++,j+=2){
        to[j] = hexchars[(((unsigned char)from[i]) >>4 )&0x0F];
        to[j+1] = hexchars[(((unsigned char)from[i]))&0x0F];
    }   
    return 2*len;
}

#define HEX_DIGIT(x) \
    ((x>='0'&&x<='9')?x-'0':((x>='a'&&x<='f')?x-'a'+10:((x>='A'&&x<='F')?x-'A'+10:0)))

int base16_to_bin(char *from,int len, char *to)
{
    int i,j;
    for(i=0,j=0;j<len;i++,j+=2){
        to[i] = (unsigned char) ( HEX_DIGIT(from[j])<<4 | HEX_DIGIT(from[j+1]));
    }   
    return i;
}

int isc_mark_set(struct sip_msg *msg, isc_match *match, isc_mark *mark)
{
    str route={0,0};
    str as={0,0};
    char chr_mark[256];
    char aor_hex[256];
    int len;

    /* Drop all the old Header Lump "Route: <as>, <my>" */
    isc_mark_drop_route(msg);
    
    len = bin_to_base16(mark->aor.s,mark->aor.len,aor_hex);
    /* Create the Marking */        
    sprintf(chr_mark,"%s@%.*s;lr;s=%d;h=%d;d=%d;a=%.*s",
        ISC_MARK_USERNAME,
        isc_my_uri.len,isc_my_uri.s,
        mark->skip,
        mark->handling,
        mark->direction,
        len,aor_hex
        );
    /* Add it in a lump */
    route.s = chr_mark;
    route.len = strlen(chr_mark);
    if (match) as = match->server_name;
    isc_mark_write_route(msg,&as,&route);
    LOG(L_INFO,"INFO:"M_NAME":isc_mark_set: NEW mark <%s>\n",chr_mark); 
    
    return 1;
}


void isc_mark_get(str x,isc_mark *mark)
{
    int i,j,k;
    str aor_hex={0,0};
    if (mark->aor.s) pkg_free(mark->aor.s);
    mark->aor=aor_hex;
    for(i=0;i<x.len&&x.s[i]!=';';i++);
    while(i<x.len){
        if (x.s[i+1]=='=') {
            k = 0;
            for(j=i+2;j<x.len && x.s[j]!=';';j++)
                k = k*10+(x.s[j]-'0');
            switch(x.s[i]){
                case 's':
                    mark->skip = k;
                    break;
                case 'h':
                    mark->handling = k;
                    break;
                case 'd':
                    mark->direction = k;
                    break;
                case 'a':
                    aor_hex.s=x.s+i+2;
                    aor_hex.len=0;
                    for(j=i+2;j<x.len && x.s[j]!=';';j++)
                        aor_hex.len++;
                    mark->aor.len = aor_hex.len/2;
                    mark->aor.s = pkg_malloc(mark->aor.len);
                    if (!mark->aor.s){
                        LOG(L_ERR, "ERR:"M_NAME":isc_mark_get: Error allocating %d bytes\n",mark->aor.len);
                        mark->aor.len = 0;
                    }else{
                        mark->aor.len = base16_to_bin(aor_hex.s,aor_hex.len,mark->aor.s);
                    }
                    break;
                default:
                    LOG(L_ERR,"INFO:"M_NAME":isc_mark_get: unkown parameter found: %c !\n",x.s[i]);
            }
            i = j+1;                                
        } 
        else i++;
    }
}

#define HEX_VAL(c)  ( (c<='9')?(c-'0'):(c-'A'+10) )

int isc_mark_get_from_msg(struct sip_msg *msg,isc_mark *mark)
{
    struct hdr_field *hdr;
    rr_t *rr;
    str x;
    LOG(L_INFO,"INFO:"M_NAME":isc_mark_get_from_msg: Trying to get the mark from the message \n");
    
    memset(mark,0,sizeof(isc_mark));
    
    parse_headers(msg,HDR_EOH_F,0);
    hdr = msg->headers;
    while(hdr){
        if (hdr->type == HDR_ROUTE_T){
            if (!hdr->parsed){
                if (parse_rr(hdr) < 0) {
                    LOG(L_ERR, "ERROR:"M_NAME":isc_mark_get_from_msg: Error while parsing Route HF\n");
                    hdr = hdr->next;
                    continue;
                }
            }
            rr = (rr_t*)hdr->parsed;
            while(rr){
                x = rr->nameaddr.uri;
                if (x.len >= ISC_MARK_USERNAME_LEN + 1 + isc_my_uri.len &&
                    strncasecmp(x.s,ISC_MARK_USERNAME,ISC_MARK_USERNAME_LEN)==0 &&
                    strncasecmp(x.s+ISC_MARK_USERNAME_LEN+1,isc_my_uri.s,isc_my_uri.len)==0)
                {
                    LOG(L_INFO,"INFO:"M_NAME":isc_mark_get_from_msg: Found <%.*s>\n",x.len,x.s);                        
                    isc_mark_get(x,mark);
                    return 1;
                }                   
                rr = rr->next;
            }
        }       
        hdr = hdr->next;
    }       
    return 0;
}

int isc_mark_get_from_lump(struct sip_msg *msg,isc_mark *mark)
{
    struct lump* lmp,*tmp;;
    struct lump* anchor;
    str x;

    anchor = anchor_lump(msg, msg->headers->name.s - msg->buf, 0 , 0);

    memset(mark,0,sizeof(isc_mark));
        
    LOG(L_DBG,"DEBUG:"M_NAME":isc_mark_get_from_lump: 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))
        {           
            LOG(L_DBG,"DEBUG:"M_NAME":isc_mark_get_from_lump: Found lump %s ... dropping\n",tmp->u.value);                                      
            x.s = lmp->u.value;
            x.len = lmp->len;
            isc_mark_get(x,mark);
            return 1;
        }
        lmp = lmp->next;        
    }
    LOG(L_DBG,"DEBUG:"M_NAME":isc_mark_get_from_lump: ---------- End \n");
    
    return 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);
    LOG(L_DBG,"DEBUG:"M_NAME":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) {
        LOG(L_ERR, "ERROR:"M_NAME":isc_mark_write_route: anchor_lump failed\n");
        return 0;
    }

    if (!insert_new_lump_before(anchor, route.s,route.len,HDR_ROUTE_T)){
            LOG( L_ERR, "ERROR:"M_NAME":isc_mark_write_route: error creting lump for header_mark\n" );
    }   
    return 1;
}


inline int isc_mark_drop_route(struct sip_msg *msg)
{
    struct lump* lmp,*tmp;
    struct lump* anchor;

    parse_headers(msg,HDR_EOH_F,0);         

    anchor = anchor_lump(msg, msg->headers->name.s - msg->buf, 0 , 0);
        
    LOG(L_DBG,"DEBUG:"M_NAME":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))
        {           
            LOG(L_DBG,"DEBUG:"M_NAME":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;        
    }
    LOG(L_DBG,"DEBUG:"M_NAME":ifc_mark_drop_route: ---------- End \n");
    
    return 1;
}

---