dlg_state.c

Go to the documentation of this file.

/*
 * $Id: dlg_state.c 554 2008-04-17 17:54:56Z vingarzan $
 *  
 * Copyright (C) 2004-2006 FhG Fokus
 *
 * This file is part of Open IMS Core - an open source IMS CSCFs & HSS
 * implementation
 *
 * Open IMS Core is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * For a license to use the Open IMS Core software under conditions
 * other than those described here, or to purchase support for this
 * software, please contact Fraunhofer FOKUS by e-mail at the following
 * addresses:
 *     info@open-ims.org
 *
 * Open IMS Core is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * It has to be noted that this Open Source IMS Core System is not 
 * intended to become or act as a product in a commercial context! Its 
 * sole purpose is to provide an IMS core reference implementation for 
 * IMS technology testing and IMS application prototyping for research 
 * purposes, typically performed in IMS test-beds.
 * 
 * Users of the Open Source IMS Core System have to be aware that IMS
 * technology may be subject of patents and licence terms, as being 
 * specified within the various IMS-related IETF, ITU-T, ETSI, and 3GPP
 * standards. Thus all Open IMS Core users have to take notice of this 
 * fact and have to agree to check out carefully before installing, 
 * using and extending the Open Source IMS Core System, if related 
 * patents and licences may become applicable to the intended usage 
 * context.  
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 */
 
#include <time.h>

#include "dlg_state.h"
#include "../tm/tm_load.h"
#include "../sl/sl_funcs.h"
#include "../../mem/shm_mem.h"
#include "../../parser/parse_rr.h"

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

extern struct tm_binds tmb;

int s_dialogs_hash_size;                        
s_dialog_hash_slot *s_dialogs=0;                
extern int scscf_dialogs_expiration_time;       
extern int scscf_dialogs_enable_release;    
extern str scscf_name_str;
extern str scscf_record_route_mo;               
extern str scscf_record_route_mt;               
extern str scscf_record_route_mo_uri;           
extern str scscf_record_route_mt_uri;           
time_t d_time_now;                              
extern int scscf_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_s_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)%s_dialogs_hash_size;
#undef h_inc 
}

int s_dialogs_init(int hash_size)
{
    int i;
    
    s_dialogs_hash_size = hash_size;
    s_dialogs = shm_malloc(sizeof(s_dialog_hash_slot)*s_dialogs_hash_size);

    if (!s_dialogs) return 0;

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

void s_dialogs_destroy()
{
    int i;
    s_dialog *d,*nd;
    for(i=0;i<s_dialogs_hash_size;i++){
        d_lock(i);
            d = s_dialogs[i].head;
            while(d){
                nd = d->next;
                free_s_dialog(d);
                d = nd;
            }
        d_unlock(i);
        lock_dealloc(s_dialogs[i].lock);
    }
    shm_free(s_dialogs);
}

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

inline void d_unlock(unsigned int hash)
{
    lock_release(s_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* scscf_dialog_count;
extern int scscf_max_dialog_count;
extern gen_lock_t* scscf_dialog_count_lock;

inline void s_dialog_count_lock()
{
    lock_get(scscf_dialog_count_lock);
}

inline void s_dialog_count_unlock()
{
        lock_release(scscf_dialog_count_lock);
}


inline int s_dialog_count_increment ()
{
    if (scscf_max_dialog_count<0) return 1;
    s_dialog_count_lock();  
    if (*scscf_dialog_count<scscf_max_dialog_count){
        (*scscf_dialog_count)++;
        s_dialog_count_unlock();
        return 1;
    } else {
        s_dialog_count_unlock();
        return 0;
    }
    LOG(L_DBG,"DBG:"M_NAME":s_dialog_count_increment(): P-CSCF Dialog counter value is %d\n", *scscf_dialog_count);
}

inline void s_dialog_count_decrement()
{
    if (scscf_max_dialog_count<0) return ;
    s_dialog_count_lock();
    (*scscf_dialog_count)--;
    s_dialog_count_unlock();
    LOG(L_DBG,"DBG:"M_NAME":s_dialog_count_decrement(): P-CSCF Dialog counter value is %d\n", *scscf_dialog_count);    
}


s_dialog* new_s_dialog(str call_id,str aor, enum s_dialog_direction dir)
{
    s_dialog *d;
    
    if (!s_dialog_count_increment()) return 0;
    d = shm_malloc(sizeof(s_dialog));
    if (!d) {
        LOG(L_ERR,"ERR:"M_NAME":new_s_dialog(): Unable to alloc %d bytes\n",
            sizeof(s_dialog));
        goto error;
    }
    memset(d,0,sizeof(s_dialog));
    
    d->hash = get_s_dialog_hash(call_id);       
    STR_SHM_DUP(d->call_id,call_id,"shm");
    STR_SHM_DUP(d->aor,aor,"shm");  
    d->direction = dir;
    d->is_releasing = 0;
    return d;
error:
out_of_memory:
    if (d){
        shm_free(d);        
    }
    s_dialog_count_decrement();
    return 0;
}

s_dialog* add_s_dialog(str call_id,str aor,enum s_dialog_direction dir)
{
    s_dialog *d;
    
    d = new_s_dialog(call_id,aor,dir);
    if (!d) return 0;       
    
    d_lock(d->hash);
        d->next = 0;
        d->prev = s_dialogs[d->hash].tail;
        if (d->prev) d->prev->next = d;
        s_dialogs[d->hash].tail = d;
        if (!s_dialogs[d->hash].head) s_dialogs[d->hash].head = d;

        return d;
}

int is_s_dialog(str call_id,str aor,enum s_dialog_direction dir)
{
    s_dialog *d=0;
    unsigned int hash = get_s_dialog_hash(call_id);

    d_lock(hash);
        d = s_dialogs[hash].head;
        while(d){
                if (d->direction == dir &&
                    d->aor.len == aor.len &&
                    d->call_id.len == call_id.len &&
                    strncasecmp(d->aor.s,aor.s,aor.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_s_dialog_dir(str call_id,enum s_dialog_direction dir)
{
    s_dialog *d=0;
    unsigned int hash = get_s_dialog_hash(call_id);

    d_lock(hash);
        d = s_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;
}

s_dialog* get_s_dialog(str call_id,str aor)
{
    s_dialog *d=0;
    unsigned int hash = get_s_dialog_hash(call_id);

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

s_dialog* get_s_dialog_dir(str call_id,enum s_dialog_direction dir)
{
    s_dialog *d=0;
    unsigned int hash = get_s_dialog_hash(call_id);

    d_lock(hash);
        d = s_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;
}

s_dialog* get_s_dialog_dir_nolock(str call_id,enum s_dialog_direction dir)
{
    s_dialog *d=0;
    unsigned int hash = get_s_dialog_hash(call_id);

    d = s_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;
}

static str Reason={"Reason: SIP ;cause=503 ;text=\"Session Time-out on S-CSCF\"\r\n",59};
int terminate_s_dialog(s_dialog *d)
{
    if (!scscf_dialogs_enable_release) return 0;    
    switch (d->method){
        case DLG_METHOD_INVITE:
            if (release_call_s(d,Reason)<=0){
                //dialog has expired and not confirmed
                // or error releasing dialog
                del_s_dialog(d);
            }
            return 1;
            break;
        case DLG_METHOD_SUBSCRIBE:
            if (!release_subscription(d)){
                //error releasing the subscription - just drop silently
                del_s_dialog(d);
            }
            return 1;
            break;
        default:
            LOG(L_ERR,"ERR:"M_NAME":terminate_s_dialog(): Not implemented yet for method[%d]!\n",d->method);
            return 0;
    }
}

void del_s_dialog(s_dialog *d)
{
    LOG(L_INFO,"DBG:"M_NAME":del_s_dialog(): Deleting dialog <%.*s> DIR[%d]\n",d->call_id.len,d->call_id.s,d->direction);
    if (d->prev) d->prev->next = d->next;
    else s_dialogs[d->hash].head = d->next;
    if (d->next) d->next->prev = d->prev;
    else s_dialogs[d->hash].tail = d->prev;
    free_s_dialog(d);
}


void free_s_dialog(s_dialog *d)
{
    if (!d) return;
    if (d->call_id.s) shm_free(d->call_id.s);
    if (d->aor.s) shm_free(d->aor.s);   
    if (d->method_str.s) shm_free(d->method_str.s);
    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);       
    if (d->event.s) shm_free(d->event.s);       
    shm_free(d);
    s_dialog_count_decrement();     
}

void print_s_dialogs(int log_level)
{
    s_dialog *d;
    int i;
    if (debug<log_level) return; /* to avoid useless calls when nothing will be printed */
    d_act_time();
    LOG(log_level,"INF:"M_NAME":----------  S-CSCF Dialog List begin --------------\n");
    for(i=0;i<s_dialogs_hash_size;i++){
        d_lock(i);
            d = s_dialogs[i].head;
            while(d){
                LOG(log_level,"INF:"M_NAME":[%4d] Dir["ANSI_MAGENTA"%d"ANSI_GREEN
                    "] Call-ID:<"ANSI_BLUE"%.*s"ANSI_GREEN
                    "> AOR:<"ANSI_RED"%.*s"ANSI_GREEN
                    ">\n",i,                
                    d->direction,
                    d->call_id.len,d->call_id.s,
                    d->aor.len,d->aor.s);
                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"] Ref:["ANSI_MAGENTA"%.*s"ANSI_GREEN"] Event:["ANSI_MAGENTA"%.*s"ANSI_GREEN"]\n",              
                    d->method,
                    d->state,
                    (int)(d->expires - d_time_now),
                    d->refresher.len,d->refresher.s,
                    d->event.len,d->event.s);
                    
                d = d->next;
            }       
        d_unlock(i);
    }
    LOG(log_level,"INF:"M_NAME":----------  S-CSCF Dialog List end   --------------\n");    
}



enum s_dialog_direction get_dialog_direction(char *direction)
{
    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_aor(struct sip_msg *msg,enum s_dialog_direction d,str *aor)
{
    if (msg->first_line.type!=SIP_REQUEST)
        return 0;
    switch(d){
        case DLG_MOBILE_ORIGINATING:
            *aor = cscf_get_asserted_identity(msg); 
            if (!aor->len) return 0;
            return 1;
            break;
        case DLG_MOBILE_TERMINATING:
            *aor = cscf_get_called_party_id(msg,0); 
            if (!aor->len) *aor = cscf_get_identity_from_ruri(msg);
            if (!aor->len) return 0;
            return 1;
            break;
        default:
            LOG(L_CRIT,"ERR:"M_NAME":find_dialog_aor(): Unknown direction %d",d);
            return 0;
    }
    return 1;
}
static inline enum s_dialog_direction find_dialog_route_dir(struct sip_msg *msg)
{
    str r;  
    r = cscf_get_first_route(msg,0);
    
//  LOG(L_ERR,"DBG:"M_NAME":find_dialog_route_dir(): Route <%.*s>\n",r.len,r.s);
//      scscf_record_route_mo_uri.len,scscf_record_route_mo_uri.s,
//      scscf_record_route_mt_uri.len,scscf_record_route_mt_uri.s);
    
    if (!r.len) return DLG_MOBILE_UNKNOWN;
    
    if (r.len >= scscf_record_route_mo_uri.len &&
        strncasecmp(r.s,scscf_record_route_mo_uri.s,scscf_record_route_mo_uri.len)==0){
        return DLG_MOBILE_ORIGINATING;
    }
    if (r.len >= scscf_record_route_mt_uri.len &&
        strncasecmp(r.s,scscf_record_route_mt_uri.s,scscf_record_route_mt_uri.len)==0){
        return DLG_MOBILE_TERMINATING;
    }
    return DLG_MOBILE_UNKNOWN;
}

int S_is_in_dialog(struct sip_msg* msg, char* str1, char* str2)
{
    str call_id;
    enum s_dialog_direction dir = get_dialog_direction(str1);
    enum s_dialog_direction dirmsg = find_dialog_route_dir(msg);
    

//  LOG(L_CRIT,"%d - %d\n",dir,dirmsg);
    if (dir!=dirmsg) return CSCF_RETURN_FALSE;              
            
//  print_s_dialogs(L_ERR);
    call_id = cscf_get_call_id(msg,0);
    if (!call_id.len){
        
        return CSCF_RETURN_FALSE;
    }
    
    if (is_s_dialog_dir(call_id,dir))
        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 s_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 s_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 S_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":S_422_session_expires(): no memory for hdr\n");
        goto error;
    }

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

    if (!cscf_add_header_rpl(msg, &hdr)) {
        LOG(L_ERR, "ERR:"M_NAME":S_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 S_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 >= scscf_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 < scscf_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":S_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, scscf_min_se);
        min_se_time = scscf_min_se;
        cscf_add_header(msg, &new_min_se, HDR_OTHER_T);
        if (t_time < scscf_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":S_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, scscf_min_se);
            t_time = scscf_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 S_save_dialog(struct sip_msg* msg, char* str1, char* str2)
{
    str call_id;
    s_dialog *d;
    str aor;
    char buf1[256],buf2[256];
    str uri,tag,ruri,x; 
    time_t t_time;
    str ses_exp = {0,0};
    str refresher = {0,0};
    str event = {0,0};
    struct hdr_field *h;
    unsigned int hash;
    
    enum s_dialog_direction dir = get_dialog_direction(str1);
    
    if (!find_dialog_aor(msg,dir,&aor)){
        LOG(L_ERR,"ERR:"M_NAME":S_save_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_INFO,"DBG:"M_NAME":S_save_dialog(%s): Call-ID <%.*s>\n",str1,call_id.len,call_id.s);

    if (is_s_dialog(call_id,aor,dir)){
        LOG(L_ERR,"ERR:"M_NAME":S_save_dialog: dialog already exists!\n");  
        return CSCF_RETURN_TRUE;
    }
    
    d = add_s_dialog(call_id,aor,dir);
    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");
    }
    
    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);
    
    event = cscf_get_event(msg);
    if (event.len){
        STR_SHM_DUP(d->event,event,"shm");
    }
    else
        d->event = event;

    d_unlock(d->hash);
    
    print_s_dialogs(L_INFO);
    
    return CSCF_RETURN_TRUE;    
out_of_memory:
    if (d){
        hash = d->hash;
        del_s_dialog(d);
        d_unlock(hash);
    }
    return CSCF_RETURN_ERROR;   
}

int update_dialog_on_reply(struct sip_msg *msg, s_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()+scscf_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 S_update_dialog(struct sip_msg* msg, char* str1, char* str2)
{
    str call_id;
    s_dialog *d;
    int response;
    int cseq;

    struct hdr_field *h=0;
    struct sip_msg *req=0;
    int expires=0;
    str totag;
    time_t t_time;
    str ses_exp = {0,0};
    str refresher = {0,0};

    enum s_dialog_direction dir = get_dialog_direction(str1);
        
//  if (!find_dialog_aor(msg,str1,&aor)){
//      req = cscf_get_request_from_reply(msg);     
//      if (!find_dialog_aor(req,str1,&aor)){
//          LOG(L_ERR,"ERR:"M_NAME":S_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":S_update_dialog(%s): Call-ID <%.*s>\n",str1,call_id.len,call_id.s);

    d = get_s_dialog_dir(call_id,dir);
//  if (!d && msg->first_line.type==SIP_REPLY){
//      /* Try to get the dialog from the request */
//      if (!req) req = cscf_get_request_from_reply(msg);       
//      if (!find_dialog_aor(req,str1,&aor)){
//          LOG(L_ERR,"ERR:"M_NAME":S_update_dialog(%s): Error retrieving %s contact\n",str1,str1);
//          return CSCF_RETURN_BREAK;
//      }       
//      d = get_s_dialog_dir(call_id,aor);      
//  }
    if (!d){
        LOG(L_INFO,"INFO:"M_NAME