dlg_state.c

Go to the documentation of this file.

#include <time.h>

#include "dlg_state.h"

#include "../../mem/shm_mem.h"
#include "../sl/sl_funcs.h"

#include "sip.h"
#include "release_call.h"
#include "ims_pm.h"

int p_dialogs_hash_size;                    
p_dialog_hash_slot *p_dialogs=0;            
extern int pcscf_dialogs_expiration_time;   
extern int pcscf_dialogs_enable_release;    
time_t d_time_now;                          
extern str pcscf_record_route_mo;           
extern str pcscf_record_route_mo_uri;       
extern str pcscf_record_route_mt;           
extern str pcscf_record_route_mt_uri;       
extern str pcscf_name_str;                  
extern struct tm_binds tmb;
extern int pcscf_min_se;


int (*sl_reply)(struct sip_msg* _msg, char* _str1, char* _str2); 
int supports_extension(struct sip_msg *m, str *extension);
int requires_extension(struct sip_msg *m, str *extension);

#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 FParam_INT(val) { \
     .v = { \
        .i = val \
     },\
    .type = FPARAM_INT, \
    .orig = "int_value", \
};

#define FParam_STRING(val) { \
    .v = { \
        .str = STR_STATIC_INIT(val) \
    },\
    .type = FPARAM_STR, \
    .orig = val, \
};


inline unsigned int get_p_dialog_hash(str call_id)
{
    if (call_id.len==0) return 0;
#define h_inc h+=v^(v>>3)
   char* p;
   register unsigned v;
   register unsigned h;

   h=0;
   for (p=call_id.s; p<=(call_id.s+call_id.len-4); p+=4){
       v=(*p<<24)+(p[1]<<16)+(p[2]<<8)+p[3];
       h_inc;
   }
   v=0;
   for (;p<(call_id.s+call_id.len); p++) {
       v<<=8;
       v+=*p;
   }
   h_inc;

   h=((h)+(h>>11))+((h>>13)+(h>>23));
   return (h)%p_dialogs_hash_size;
#undef h_inc 
}

int p_dialogs_init(int hash_size)
{
    int i;
    
    p_dialogs_hash_size = hash_size;
    p_dialogs = shm_malloc(sizeof(p_dialog_hash_slot)*p_dialogs_hash_size);

    if (!p_dialogs) return 0;

    memset(p_dialogs,0,sizeof(p_dialog_hash_slot)*p_dialogs_hash_size);
    
    for(i=0;i<p_dialogs_hash_size;i++){
        p_dialogs[i].lock = lock_alloc();
        if (!p_dialogs[i].lock){
            LOG(L_ERR,"ERR:"M_NAME":d_hash_table_init(): Error creating lock\n");
            return 0;
        }
        p_dialogs[i].lock = lock_init(p_dialogs[i].lock);
    }
            
    return 1;
}

void p_dialogs_destroy()
{
    int i;
    p_dialog *d,*nd;
    for(i=0;i<p_dialogs_hash_size;i++){
        d_lock(i);
            d = p_dialogs[i].head;
            while(d){
                nd = d->next;
                free_p_dialog(d);
                d = nd;
            }
        d_unlock(i);
        lock_dealloc(p_dialogs[i].lock);
    }
    shm_free(p_dialogs);
}

inline void d_lock(unsigned int hash)
{
//  LOG(L_CRIT,"GET %d\n",hash);
    lock_get(p_dialogs[(hash)].lock);
//  LOG(L_CRIT,"GOT %d\n",hash);    
}

 inline void d_unlock(unsigned int hash)
{
    lock_release(p_dialogs[(hash)].lock);
//  LOG(L_CRIT,"RELEASED %d\n",hash);   
}

inline int d_act_time()
{
    d_time_now=time(0);
    return d_time_now;
}

extern int* pcscf_dialog_count;
extern int pcscf_max_dialog_count;
extern gen_lock_t* pcscf_dialog_count_lock;

inline void p_dialog_count_lock()
{
    lock_get(pcscf_dialog_count_lock);
}

inline void p_dialog_count_unlock()
{
        lock_release(pcscf_dialog_count_lock);
}


inline int p_dialog_count_increment ()
{
    if (pcscf_max_dialog_count<0) return 1;
    p_dialog_count_lock();  
    if (*pcscf_dialog_count<pcscf_max_dialog_count){
        (*pcscf_dialog_count)++;
        p_dialog_count_unlock();
        return 1;
    } else {
        p_dialog_count_unlock();
        return 0;
    }
    LOG(L_DBG,"DBG:"M_NAME":p_dialog_count_increment(): P-CSCF Dialog counter value is %d\n", *pcscf_dialog_count);
}

inline void p_dialog_count_decrement()
{
    if (pcscf_max_dialog_count<0) return ;
    p_dialog_count_lock();
    (*pcscf_dialog_count)--;
    p_dialog_count_unlock();
    LOG(L_DBG,"DBG:"M_NAME":p_dialog_count_decrement(): P-CSCF Dialog counter value is %d\n", *pcscf_dialog_count);    
}


p_dialog* new_p_dialog(str call_id,str host,int port, int transport)
{
    p_dialog *d;
    
    if (!p_dialog_count_increment()) return 0;
    d = shm_malloc(sizeof(p_dialog));
    if (!d) {
        LOG(L_ERR,"ERR:"M_NAME":new_p_dialog(): Unable to alloc %d bytes\n",
            sizeof(p_dialog));
        goto error;
    }
    memset(d,0,sizeof(p_dialog));
    
    d->hash = get_p_dialog_hash(call_id);       
    STR_SHM_DUP(d->call_id,call_id,"shm");
    STR_SHM_DUP(d->host,host,"shm");    
    d->port = port;
    d->transport = transport;
                
    return d;
error:
out_of_memory:
    if (d){
        if (d->call_id.s) shm_free(d->call_id.s);
        if (d->host.s) shm_free(d->host.s);
        shm_free(d);        
    }
    p_dialog_count_decrement();
    return 0;
}

p_dialog* add_p_dialog(str call_id,str host,int port, int transport)
{
    p_dialog *d;
    
    d = new_p_dialog(call_id,host,port,transport);
    if (!d) return 0;       
    
    d_lock(d->hash);
        d->next = 0;
        d->prev = p_dialogs[d->hash].tail;
        if (d->prev) d->prev->next = d;
        p_dialogs[d->hash].tail = d;
        if (!p_dialogs[d->hash].head) p_dialogs[d->hash].head = d;

        return d;
}

int is_p_dialog(str call_id,str host,int port, int transport,enum p_dialog_direction *dir)
{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);

    d_lock(hash);
        d = p_dialogs[hash].head;
        while(d){
            if ((!dir || d->direction == *dir) &&
                d->port == port &&
/*              d->transport == transport &&*/
/* commented because of strange behaviour */
                d->host.len == host.len &&
                d->call_id.len == call_id.len &&
                strncasecmp(d->host.s,host.s,host.len)==0 &&
                strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                    d_unlock(hash);
                    return 1;
                }
            d = d->next;
        }
    d_unlock(hash);
    return 0;
}

int is_p_dialog_dir(str call_id,enum p_dialog_direction dir)
{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);
        d_lock(hash);
        d = p_dialogs[hash].head;
        while(d){
            if (d->direction==dir && d->call_id.len == call_id.len &&
                        strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                d_unlock(hash);
                return 1;
            }
            d=d->next;
        }
        d_unlock(hash);
        return 0;
}

p_dialog* get_p_dialog(str call_id,str host,int port, int transport,enum p_dialog_direction *dir)
{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);

    d_lock(hash);
        d = p_dialogs[hash].head;
        while(d){
            if ((!dir || d->direction == *dir) &&
                d->port == port &&
/*              d->transport == transport &&*/
/* commented because of strange behaviour */
                d->host.len == host.len &&
                d->call_id.len == call_id.len &&
                strncasecmp(d->host.s,host.s,host.len)==0 &&
                strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                    return d;
                }
            d = d->next;
        }
    d_unlock(hash);
    return 0;
}

p_dialog* get_p_dialog_dir(str call_id,enum p_dialog_direction dir)
{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);

    d_lock(hash);
        d = p_dialogs[hash].head;
        while(d){
            if (d->direction == dir &&
                d->call_id.len == call_id.len &&
                strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                    return d;
                }
            d = d->next;
        }
    d_unlock(hash);
    return 0;
}


p_dialog* get_p_dialog_dir_nolock(str call_id,enum p_dialog_direction dir)
{
    p_dialog *d=0;
    unsigned int hash = get_p_dialog_hash(call_id);

    d = p_dialogs[hash].head;
    while(d){
        if (d->direction == dir &&
            d->call_id.len == call_id.len &&
            strncasecmp(d->call_id.s,call_id.s,call_id.len)==0) {
                return d;
            }
        d = d->next;
    }
    return 0;
}

str reason_terminate_p_dialog_s={"Session terminated in the P-CSCF",32};
int terminate_p_dialog(p_dialog *d)
{
    if (!pcscf_dialogs_enable_release) return 0;
    switch (d->method){
        case DLG_METHOD_INVITE:
            if (release_call_p(d,503,reason_terminate_p_dialog_s)==-1){             
                del_p_dialog(d);
            }
            return 1;
            break;
        case DLG_METHOD_SUBSCRIBE:
            LOG(L_ERR,"ERR:"M_NAME":terminate_p_dialog(): Not needed for SUBSCRIBE dialogs - silent drop on expiration.\n");
            return 0;
            break;
        default:
            LOG(L_ERR,"ERR:"M_NAME":terminate_p_dialog(): Not implemented yet for method[%d]!\n",d->method);
            return 0;
    }
}

void del_p_dialog(p_dialog *d)
{
    if (d->prev) d->prev->next = d->next;
    else p_dialogs[d->hash].head = d->next;
    if (d->next) d->next->prev = d->prev;
    else p_dialogs[d->hash].tail = d->prev;
    free_p_dialog(d);
}

void free_p_dialog(p_dialog *d)
{
    int i;
    if (!d) return;
    if (d->call_id.s) shm_free(d->call_id.s);
    if (d->host.s) shm_free(d->host.s); 
    if (d->method_str.s) shm_free(d->method_str.s); 
    if (d->routes){
        for(i=0;i<d->routes_cnt;i++)
            shm_free(d->routes[i].s);
        shm_free(d->routes);
    }
    if (d->dialog_s) tmb.free_dlg(d->dialog_s);
    if (d->dialog_c) tmb.free_dlg(d->dialog_c);
    if (d->refresher.s) shm_free(d->refresher.s);
    shm_free(d);
    p_dialog_count_decrement(); 
}

void print_p_dialogs(int log_level)
{
    p_dialog *d;
    int i,j;
    if (debug<log_level) return; /* to avoid useless calls when nothing will be printed */
    d_act_time();
    LOG(log_level,"INF:"M_NAME":----------  P-CSCF Dialog List begin --------------\n");
    for(i=0;i<p_dialogs_hash_size;i++){
        d_lock(i);
            d = p_dialogs[i].head;
            while(d){
                LOG(log_level,"INF:"M_NAME":[%4d] Dir:["ANSI_MAGENTA"%d"ANSI_GREEN
                    "]\tCall-ID:<"ANSI_BLUE"%.*s"ANSI_GREEN
                    ">\tAOR:"ANSI_RED"%d://%.*s:%d"ANSI_GREEN"\n"
                    ,i,             
                    d->direction,
                    d->call_id.len,d->call_id.s,
                    d->transport,d->host.len,d->host.s,d->port);
                LOG(log_level,"INF:"M_NAME":\t\tMethod:["ANSI_MAGENTA"%d"ANSI_GREEN
                    "] State:["ANSI_MAGENTA"%d"ANSI_GREEN
                    "] Exp:["ANSI_MAGENTA"%4d"ANSI_GREEN"]\n",
                    d->method,d->state,
                    (int)(d->expires - d_time_now));    
                for(j=0;j<d->routes_cnt;j++)
                    LOG(log_level,"INF:"M_NAME":\t\t RR: <"ANSI_YELLOW"%.*s"ANSI_GREEN">\n",            
                        d->routes[j].len,d->routes[j].s);                   
                d = d->next;
            }       
        d_unlock(i);
    }
    LOG(log_level,"INF:"M_NAME":----------  P-CSCF Dialog List end   --------------\n");    
}

static inline enum p_dialog_direction get_dialog_direction(char *direction)
{
    if (!direction) {
        LOG(L_CRIT,"ERR:"M_NAME":get_dialog_direction(): Unknown direction NULL");
        return DLG_MOBILE_UNKNOWN;
    }
    switch(direction[0]){
        case 'o':
        case 'O':
        case '0':
            return DLG_MOBILE_ORIGINATING;
        case 't':
        case 'T':
        case '1':
            return DLG_MOBILE_TERMINATING;
        default:
            LOG(L_CRIT,"ERR:"M_NAME":get_dialog_direction(): Unknown direction %s",direction);
            return DLG_MOBILE_UNKNOWN;
    }
}

static inline int find_dialog_contact(struct sip_msg *msg,enum p_dialog_direction dir,str *host,int *port,int *transport)
{
    switch(dir){
        case DLG_MOBILE_ORIGINATING:
            if (!cscf_get_originating_contact(msg,host,port,transport))
                return 0;
            if (*port==0) *port = 5060;
            return 1;
        case DLG_MOBILE_TERMINATING:
            if (!cscf_get_terminating_contact(msg,host,port,transport))
                return 0;
            if (*port==0) *port = 5060;
            return 1;
        default:
            LOG(L_CRIT,"ERR:"M_NAME":find_dialog_contact(): Unknown direction %d",dir);
            return 0;
    }
    return 1;
}

int P_is_in_dialog(struct sip_msg* msg, char* str1, char* str2)
{
    str call_id;
    str host;
    int port,transport;
    enum p_dialog_direction dir;

    dir = get_dialog_direction(str1);
    
    if (!find_dialog_contact(msg,dir,&host,&port,&transport)){
        LOG(L_ERR,"ERR:"M_NAME":P_is_in_dialog(%s): Error retrieving %s contact\n",str1,str1);
        return CSCF_RETURN_BREAK;
    }       

    //print_p_dialog(L_ERR);
    call_id = cscf_get_call_id(msg,0);
    if (!call_id.len)
        return CSCF_RETURN_FALSE;
            
    if (is_p_dialog(call_id,host,port,transport,0)) {
        return CSCF_RETURN_TRUE;
    }
    else 
        return CSCF_RETURN_FALSE;
}

str s_OTHER={"<OTHER>",7};
str s_INVITE={"INVITE",6};
str s_SUBSCRIBE={"SUBSCRIBE",9};
static enum p_dialog_method get_dialog_method(str method)
{
    if (method.len == s_INVITE.len &&
        strncasecmp(method.s,s_INVITE.s,s_INVITE.len)==0) return DLG_METHOD_INVITE;
    if (method.len == s_SUBSCRIBE.len &&
        strncasecmp(method.s,s_SUBSCRIBE.s,s_SUBSCRIBE.len)==0) return DLG_METHOD_SUBSCRIBE;
    return DLG_METHOD_OTHER;
}

#ifdef WITH_IMS_PM

static str get_dialog_method_str(enum p_dialog_method method)
{
    switch(method){
        case DLG_METHOD_INVITE:
            return s_INVITE;
        case DLG_METHOD_SUBSCRIBE:
            return s_SUBSCRIBE;
        default:
            return s_OTHER;
    }   
}
#endif

static fparam_t fp_422 = FParam_INT(422);
static fparam_t fp_se_small = FParam_STRING("Session Interval Too Small");

int P_422_session_expires(struct sip_msg* msg, char* str1, char* str2)
{
    str hdr = {pkg_malloc(32), 0};
    
    if (!hdr.s) {
        LOG(L_ERR, "ERR:"M_NAME":P_422_session_expires(): no memory for hdr\n");
        goto error;
    }

    hdr.len = snprintf(hdr.s, 31, "Min-SE: %d\r\n", pcscf_min_se);

    if (!cscf_add_header_rpl(msg, &hdr)) {
        LOG(L_ERR, "ERR:"M_NAME":P_422_session_expires(): Can't add header\n");
        goto error;
    }
    
    return sl_reply(msg, (char *)&fp_422, (char *)&fp_se_small);

error:
    if (hdr.s) pkg_free(hdr.s);
    return CSCF_RETURN_FALSE;
}


static str s_refresher = {"refresher=", 10};
static str str_ext_timer = {"timer", 5};
static str str_min_se = {"Min-SE:",7};
static str str_se = {"Session-Expires:",16}; 
static str str_require = {"Require:",8}; 

int P_check_session_expires(struct sip_msg* msg, char* str1, char* str2)
{
    time_t t_time;
    time_t min_se_time = 0;
    str ses_exp = {0,0};
    str min_se = {0,0};
    str new_min_se = {0,0};
    str new_ses_exp = {0,0};
    struct hdr_field *h_se, *h_min_se;
    str refresher;

    ses_exp = cscf_get_session_expires_body(msg, &h_se);
    t_time = cscf_get_session_expires(ses_exp, &refresher);
    
    if (!t_time || t_time >= pcscf_min_se)
        return CSCF_RETURN_TRUE;
    if (!supports_extension(msg, &str_ext_timer)) //does not suports timer extension
    {
        //add Min-SE header with its minimum interval
        min_se = cscf_get_min_se(msg, &h_min_se);
        if (min_se.len) {
            strtotime(min_se, min_se_time);
            if (min_se_time < pcscf_min_se)
                cscf_del_header(msg, h_min_se);
            else
                return CSCF_RETURN_TRUE;
        }
        new_min_se.len = 11/*int value*/ + str_min_se.len+3;
        new_min_se.s = pkg_malloc(new_min_se.len+1);
        if (!new_min_se.s) {
            LOG(L_ERR,"ERR:"M_NAME":P_check_session_expires: Error allocating %d bytes\n",new_min_se.len);
            goto error;
        }
        new_min_se.len = snprintf(new_min_se.s, new_min_se.len, "%.*s %d\r\n",str_min_se.len, str_min_se.s, pcscf_min_se);
        min_se_time = pcscf_min_se;
        cscf_add_header(msg, &new_min_se, HDR_OTHER_T);
        if (t_time < pcscf_min_se) {
            cscf_del_header(msg, h_se);
            new_ses_exp.len = 11 + str_se.len+3;
            new_ses_exp.s = pkg_malloc(new_ses_exp.len+1);
            if (!new_ses_exp.s) {
                LOG(L_ERR,"ERR:"M_NAME":P_check_session_expires: Error allocating %d bytes\n",new_ses_exp.len);
                goto error;
            }
            new_ses_exp.len = snprintf(new_ses_exp.s, new_ses_exp.len, "%.*s %d\r\n",str_se.len, str_se.s, pcscf_min_se);
            t_time = pcscf_min_se;
            cscf_add_header(msg, &new_ses_exp, HDR_OTHER_T);
        }
        return CSCF_RETURN_TRUE;
    }
error:
    if (new_min_se.s) pkg_free(new_min_se.s);
    if (new_ses_exp.s) pkg_free(new_ses_exp.s);
    return CSCF_RETURN_FALSE;
}       


int P_save_dialog(struct sip_msg* msg, char* str1, char* str2)
{
    str call_id;
    p_dialog *d;
    str host;
    time_t t_time;
    str ses_exp = {0,0};
    str refresher = {0,0};
    int port,transport;
    char buf1[256],buf2[256];
    str tag,ruri,uri,x;
    struct hdr_field *h;
    unsigned int hash;
    enum p_dialog_direction dir;
    
    dir = get_dialog_direction(str1);
    
    if (!find_dialog_contact(msg,dir,&host,&port,&transport)){
        LOG(L_ERR,"ERR:"M_NAME":P_is_in_dialog(): Error retrieving %s contact\n",str1);
        return CSCF_RETURN_BREAK;
    }       
        
    call_id = cscf_get_call_id(msg,0);
    if (!call_id.len)
        return CSCF_RETURN_FALSE;

    LOG(L_DBG,"DBG:"M_NAME":P_save_dialog(%s): Call-ID <%.*s>\n",str1,call_id.len,call_id.s);

    if (is_p_dialog(call_id,host,port,transport,&dir)){
        LOG(L_ERR,"ERR:"M_NAME":P_save_dialog: dialog already exists!\n");  
        return CSCF_RETURN_TRUE;
    }
    
    d = add_p_dialog(call_id,host,port,transport);
    if (!d) return CSCF_RETURN_FALSE;

    d->method = get_dialog_method(msg->first_line.u.request.method);
    STR_SHM_DUP(d->method_str,msg->first_line.u.request.method,"shm");
    d->first_cseq = cscf_get_cseq(msg,0);
    d->last_cseq = d->first_cseq;
    d->state = DLG_STATE_INITIAL;

    d->uac_supp_timer = supports_extension(msg, &str_ext_timer);

    ses_exp = cscf_get_session_expires_body(msg, &h);
    t_time = cscf_get_session_expires(ses_exp, &refresher);
    if (!t_time){
        d->expires = d_act_time() + 60;
        d->lr_session_expires = 0;
    }else {
        d->expires = d_act_time() + t_time;
        d->lr_session_expires = t_time;
        if (refresher.len)
            STR_SHM_DUP(d->refresher, refresher, "DIALOG_REFRESHER");
    }
    
    d->direction=dir;
                
    cscf_get_from_tag(msg,&tag);
    cscf_get_from_uri(msg,&x);
    uri.len = snprintf(buf1,256,"<%.*s>",x.len,x.s);
    uri.s = buf1;   
    cscf_get_to_uri(msg,&x);
    ruri.len = snprintf(buf2,256,"<%.*s>",x.len,x.s);
    ruri.s = buf2;
        
    tmb.new_dlg_uac(&call_id,
                    &tag,
                    d->first_cseq,
                    &uri,
                    &ruri,
                    &d->dialog_c);
                    
    tmb.new_dlg_uas(msg,99,&d->dialog_s);
        
    d_unlock(d->hash);
    print_p_dialogs(L_INFO);
    
    return CSCF_RETURN_TRUE;
out_of_memory:
    if (d){
        hash = d->hash;
        del_p_dialog(d);
        d_unlock(hash);
    }
    return CSCF_RETURN_FALSE;
}

void save_dialog_routes(struct sip_msg* msg, char* str1,p_dialog *d)
{
    int i;
    rr_t *rr,*ri;   
    struct hdr_field *hdr;
    if (d->routes){
        for(i=0;i<d->routes_cnt;i++)
            shm_free(d->routes[i].s);
        shm_free(d->routes);
        d->routes = 0;
    }
    d->routes_cnt = 0;
    for(hdr=cscf_get_next_record_route(msg,0);hdr;hdr=cscf_get_next_record_route(msg,hdr)){
        rr = (rr_t*)hdr->parsed;
        for(ri=rr;ri;ri=ri->next)
            d->routes_cnt++;
    }
    d->routes = shm_malloc(sizeof(str)*d->routes_cnt);
    if (!d->routes){
        LOG(L_ERR,"ERR:"M_NAME":save_dialog_routes(): Unable to alloc %d bytes\n",
            sizeof(str)*d->routes_cnt);
        d->routes_cnt = 0;
        return;     
    }
    if (!str1) return;
    if (str1[0]=='o'||str1[0]=='0'||str1[0]=='O'){
        /* originating - reverse order */
        i = d->routes_cnt-1;
        for(hdr=cscf_get_next_record_route(msg,0);hdr;hdr=cscf_get_next_record_route(msg,hdr)){
            rr = (rr_t*)hdr->parsed;
            for(ri=rr;ri;ri=ri->next){
                STR_SHM_DUP(d->routes[i],ri->nameaddr.uri,"shm");
                i--;
            }
        }
    }else{
        /* terminating - normal order */
        i = 0;
        for(hdr=cscf_get_next_record_route(msg,0);hdr;hdr=cscf_get_next_record_route(msg,hdr)){
            rr = (rr_t*)hdr->parsed;
            for(ri=rr;ri;ri=ri->next){
                STR_SHM_DUP(d->routes[i],ri->nameaddr.uri,"shm");
                i++;
            }
        }
    }       
out_of_memory:
    return; 
}
int update_dialog_on_reply(struct sip_msg *msg, p_dialog *d)
{
    struct hdr_field *h_req;
    struct hdr_field *h=0;
    int res=0;
    time_t t_time=0;
    str ses_exp = {0,0};
    str refresher = {0,0};
    str new_ses_exp = {0,0};
    str new_ext = {0,0};
    int expires = 0;

    ses_exp = cscf_get_session_expires_body(msg, &h);
    t_time = cscf_get_session_expires(ses_exp, &refresher);
    if (!t_time) //i.e not session-expires header in response
    {
        if (!d->uac_supp_timer || !d->lr_session_expires)
        {
            expires = cscf_get_expires_hdr(msg);
            if (expires >= 0)
            {
                d->expires = d_act_time()+expires;  
            }
            else
            {
                d->expires = d_act_time()+pcscf_dialogs_expiration_time;    
            }
        }
        else// uac supports timer, but no session-expires header found in response
        {
            d->expires = d_act_time()+d->lr_session_expires;
            
            new_ses_exp.len = 11/*int value*/ + str_se.len+s_refresher.len+8;
            new_ses_exp.s = pkg_malloc(new_ses_exp.len+1);
            if (!new_ses_exp.s) {
                LOG(L_ERR,"ERR:"M_NAME":update_dialog_on_reply: Error allocating %d bytes\n",new_ses_exp.len);
                goto error;
            }
            new_ses_exp.len = snprintf(new_ses_exp.s, new_ses_exp.len, "%.*s %d; %.*suac\r\n",str_se.len, str_se.s, (int)d->lr_session_expires ,s_refresher.len, s_refresher.s);
            cscf_add_header(msg, &new_ses_exp, HDR_OTHER_T);
            if (!requires_extension(msg, &str_ext_timer)) //must have require timer extenstion
            {
                /* walk through all Require headers to find first require header*/
                res = parse_headers(msg, HDR_EOH_F, 0);
                if (res == -1) {
                    ERR("Error while parsing headers (%d)\n", res);
                    return 0; /* what to return here ? */
                }
                
                h_req = msg->require;
                while (h_req) {
                    if (h_req->type == HDR_REQUIRE_T) {
                        if (h_req->body.s[new_ext.len-1]=='\n')
                        {
                            new_ext.len = str_require.len + 1/* */+h_req->body.len + 7;/*, timer*/
                            new_ext.s = pkg_malloc(new_ext.len);
                            if (!new_ext.s) {
                                LOG(L_ERR,"ERR:"M_NAME":update_dialog_on_reply: Error allocating %d bytes\n",new_ext.len);
                                goto error;
                            }           
                            new_ext.len = snprintf(new_ext.s, str_require.len, "%.*s %.*s, timer\r\n", str_require.len, str_require.s, h_req->body.len-2, h_req->body.s);
                        }
                        else
                        {
                            new_ext.len = str_require.len + 1/*space*/ + h_req->body.len + 9;/*, timer\r\n*/
                            new_ext.s = pkg_malloc(new_ext.len);
                            if (!new_ext.s) {
                                LOG(L_ERR,"ERR:"M_NAME":update_dialog_on_reply: Error allocating %d bytes\n",new_ext.len);
                                goto error;
                            }           
                            new_ext.len = snprintf(new_ext.s, str_require.len, "%.*s %.*s, timer\r\n", str_require.len, str_require.s, h_req->body.len, h_req->body.s);
                        }
                        cscf_del_header(msg, h_req);
                        cscf_add_header(msg, &new_ext, HDR_REQUIRE_T);
                        break;
                    }
                    h_req = h_req->next;
                }
            }
        }
    }
    else{
        d->expires = d_act_time() + t_time;
        d->lr_session_expires = t_time;
    }   
    return 1;
error:
    if (new_ses_exp.s) pkg_free(new_ses_exp.s);
    if (new_ext.s) pkg_free(new_ext.s);
    return 0;   
}

int P_update_dialog(struct sip_msg* msg, char* str1, char* str2)
{
    str call_id;
    p_dialog *d;
    int response;
    int cseq;
    struct hdr_field *h=0;
    struct sip_msg *req=0;
    str host;
    int port,transport;
    int expires;
    str totag;
    time_t t_time=0;
    str ses_exp = {0,0};
    str refresher = {0,0};
    enum p_dialog_direction dir;
    
    dir = get_dialog_direction(str1);
    
    if (msg->first_line.type==SIP_REPLY) req = cscf_get_request_from_reply(msg);
    else req = msg;
    if (!find_dialog_contact(req,dir,&host,&port,&transport)){
        LOG(L_ERR,"ERR:"M_NAME":P_update_dialog(%s): Error retrieving %s contact\n",str1,str1);
        return CSCF_RETURN_BREAK;
    }       
        
    call_id = cscf_get_call_id(msg,0);
    if (!call_id.len)
        return CSCF_RETURN_FALSE;

    LOG(L_DBG,"DBG:"M_NAME":P_update_dialog(%s): Call-ID <%.*s>\n",str1,call_id.len,call_id.s);

    d = get_p_dialog(call_id,host,port,transport,&dir);
    if (!d)
        d = get_p_dialog(call_id,host,port,transport,0);
    if (!d){
        if (msg->first_line.type==SIP_REQUEST &&
            msg->first_line.u.request.method.len == 3 && 
            strncasecmp(msg->first_line.u.request.method.s,"ACK",3)){
            /* to skip the ACK after a 4xx when the dialog was dropped already*/
            return CSCF_RETURN_TRUE;
        }else{
            LOG(L_CRIT,"ERR:"M_NAME":P_update_dialog: dialog does not exists!\n");
            return CSCF_RETURN_FALSE;
        }   
    }


    if (msg->first_line.type==SIP_REQUEST){
        /* Request */
        LOG(L_DBG,"DBG:"M_NAME":P_update_dialog(%s): Method <%.*s> \n",str1,
            msg->first_line.u.request.method.len,msg->first_line.u.request.method.s);
        cseq = cscf_get_cseq(msg,&h);
        if (cseq>d->last_cseq) d->last_cseq = cseq;
        if (get_dialog_method(msg->first_line.u.request.method) == DLG_METHOD_INVITE)
        {
            d->uac_supp_timer = supports_extension(msg, &str_ext_timer);
    
            ses_exp = cscf_get_session_expires_body(msg, &h);
            t_time = cscf_get_session_expires(ses_exp, &refresher);
            if (!t_time){
                d->expires = d_act_time()+pcscf_dialogs_expiration_time;
                d->lr_session_expires = 0;
            } else {
                d->expires = d_act_time() + t_time;
                d->lr_session_expires = t_time;
                if (refresher.len)
                    STR_SHM_DUP(d->refresher, refresher, "DIALOG_REFRESHER");
            }
        }
        else if (d->method == DLG_METHOD_SUBSCRIBE && 
            msg->first_line.u.request.method.len == 6 && 
            strncasecmp(msg->first_line.u.request.method.s,"NOTIFY",6)==0)
        {
            // Subscription-State header is mandatory for NOTIFY. See RFC 3265, Section 7.2
            expires =