mod.c

Go to the documentation of this file.

/*
 * $Id: mod.c 591 2008-10-15 12:46:34Z 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 "mod.h"

#include "../../db/db.h"
#include "../../sr_module.h"
#include "../../timer.h"
#include "../../locking.h"
#include "../tm/tm_load.h"
#include "../cdp/cdp_load.h"
#include "../dialog/dlg_mod.h"

#include "registration.h"
#include "registrar.h"
#include "registrar_storage.h"
#include "registrar_notify.h"
#include "sip.h"
#include "cx.h"
#include "scscf_load.h"
#include "dlg_state.h"
#include "s_persistency.h"
#include "ims_pm_scscf.h"
#include "privacy.h"

MODULE_VERSION

static int mod_init(void);
static int mod_child_init(int rank);
static void mod_destroy(void);


/* parameters storage */
char* scscf_name="sip:scscf.open-ims.test:6060";    
char* scscf_forced_hss_peer="";         
char *scscf_user_data_dtd=0;            /* Path to "CxDataType.dtd"                                 */
char *scscf_user_data_xsd=0;            /* Path to "CxDataType_Rel6.xsd" or "CxDataType_Rel7.xsd"   */

int auth_data_hash_size=1024;           
int auth_vector_timeout=60;             
int auth_data_timeout=60;               
int av_request_at_once=1;               
int av_request_at_sync=1;               
int server_assignment_store_data=0;     
int registrar_hash_size=1024;           
int registration_default_expires=3600;  
int registration_min_expires=10;        
int registration_max_expires=1000000;   
char *registration_qop="auth,auth-int"; 
str registration_qop_str={0,0};         
char* registration_default_algorithm="AKAv1-MD5";   
unsigned char registration_default_algorithm_type=1;    
int registration_disable_early_ims=1;   
int registration_disable_nass_bundled=1;
int subscription_default_expires=3600;  
int subscription_min_expires=10;        
int subscription_max_expires=1000000;   
int append_branches=1;                  
int scscf_dialogs_hash_size=256;        
int scscf_dialogs_expiration_time=3600; 
int scscf_dialogs_enable_release=1;     
int scscf_min_se=90;                    
int* scscf_dialog_count = 0;            
int scscf_max_dialog_count=20000;       
gen_lock_t* scscf_dialog_count_lock=0;  
int scscf_support_wildcardPSI =0;

persistency_mode_t scscf_persistency_mode=NO_PERSISTENCY;           
char* scscf_persistency_location="/opt/OpenIMSCore/persistency";    
int scscf_persistency_timer_authdata=60;                            
int scscf_persistency_timer_dialogs=60;                             
int scscf_persistency_timer_registrar=60;                           
char* scscf_db_url="postgres://mario:mario@localhost/scscfdb";
int* auth_snapshot_version=0;   
int* auth_step_version=0;   
int* dialogs_snapshot_version=0; 
int* dialogs_step_version=0; 
int* registrar_snapshot_version=0; 
int* registrar_step_version=0; 
gen_lock_t* db_lock; 
#ifdef WITH_IMS_PM

    char* ims_pm_node_type="S-CSCF";
    char* ims_pm_logfile="/opt/OpenIMSCore/default_ims_pm.log";
#endif /* WITH_IMS_PM */


/* fixed parameter storage */
str scscf_name_str;                     
str scscf_record_route_mo;              
str scscf_record_route_mt;              
str scscf_record_route_mo_uri;          
str scscf_record_route_mt_uri;          
str scscf_service_route;                
str scscf_service_route_uri;            
str scscf_registration_min_expires;     
str scscf_subscription_min_expires;     
str scscf_forced_hss_peer_str;          
int * callback_singleton;               
int * shutdown_singleton;               
static cmd_export_t scscf_cmds[]={
    {"load_scscf",                  (cmd_function)load_scscf,   NO_SCRIPT, 0, 0},
    {"get_r_public",                (cmd_function)get_r_public, NO_SCRIPT, 0, 0},
    {"get_r_public_expires",        (cmd_function)get_r_public_expires, NO_SCRIPT, 0, 0},
    {"r_unlock",                    (cmd_function)r_unlock,     NO_SCRIPT, 0, 0},
    
    {"S_is_integrity_protected",    S_is_integrity_protected,   1,0,REQUEST_ROUTE},
    {"S_challenge",                 S_challenge,                1,0,REQUEST_ROUTE},
    {"S_is_authorized",             S_is_authorized,            1,0,REQUEST_ROUTE},
    {"S_add_path_service_routes",   S_add_path_service_routes,  0,0,REQUEST_ROUTE},
    {"S_add_allow",                 S_add_allow,                1,0,REQUEST_ROUTE},
    {"S_add_service_route",         S_add_service_route,        1,0,REQUEST_ROUTE},
    {"S_check_visited_network_id",  S_check_visited_network_id, 1, fixup_regex_1 ,REQUEST_ROUTE},
    {"S_add_p_charging_function_addresses", S_add_p_charging_function_addresses, 0, 0, REQUEST_ROUTE},

    {"S_assign_server",             S_assign_server,            1,0,REQUEST_ROUTE},
    {"S_assign_server_unreg",       S_assign_server_unreg,      2,0,REQUEST_ROUTE},
    {"S_update_contacts",           S_update_contacts,          0,0,REQUEST_ROUTE},
    {"S_lookup",                    S_lookup,                   0,0,REQUEST_ROUTE|FAILURE_ROUTE},

    {"S_is_not_registered",         S_is_not_registered,        0,0,REQUEST_ROUTE},
    
    {"S_term_registered",           S_term_registered,          0,0,REQUEST_ROUTE|FAILURE_ROUTE},
    {"S_term_not_registered",       S_term_not_registered,      0,0,REQUEST_ROUTE},
    {"S_term_unregistered",         S_term_unregistered,        0,0,REQUEST_ROUTE},

    {"S_orig_registered",           S_orig_registered,          0,0,REQUEST_ROUTE},
    {"S_orig_not_registered",       S_orig_not_registered,      0,0,REQUEST_ROUTE},
    {"S_orig_unregistered",         S_orig_unregistered,        0,0,REQUEST_ROUTE},

    {"S_can_subscribe",             S_can_subscribe,            0,0,REQUEST_ROUTE},
    {"S_subscribe",                 S_subscribe,                0,0,REQUEST_ROUTE},

    {"S_trans_in_processing",       S_trans_in_processing,      0,0,REQUEST_ROUTE},
    
    
    {"S_mobile_originating",        S_mobile_originating,       0,0,REQUEST_ROUTE},
    
    {"S_originating_barred",        S_originating_barred,       0,0,REQUEST_ROUTE},
    {"S_terminating_barred",        S_terminating_barred,       0,0,REQUEST_ROUTE},

    {"S_is_in_dialog",              S_is_in_dialog,             1,0,REQUEST_ROUTE},
    {"S_save_dialog",               S_save_dialog,              1,0,REQUEST_ROUTE|FAILURE_ROUTE},
    {"S_update_dialog",             S_update_dialog,            1,0,REQUEST_ROUTE|ONREPLY_ROUTE},
    {"S_record_route",              S_record_route,             1,0,REQUEST_ROUTE}, 
    {"S_is_record_routed",          S_is_record_routed,         1,0,REQUEST_ROUTE}, 
    {"S_add_p_asserted_identity",   S_add_p_asserted_identity,  0,0,REQUEST_ROUTE|FAILURE_ROUTE},   

    {"S_check_session_expires",     S_check_session_expires,    0, 0, REQUEST_ROUTE},
    {"S_422_session_expires",       S_422_session_expires,      0, 0, REQUEST_ROUTE},
    
    {"S_privacy_hook",              S_privacy_hook,             0, 0, REQUEST_ROUTE},
    {"S_apply_privacy",             S_apply_privacy,            0, 0, REQUEST_ROUTE},
    
    {0, 0, 0, 0, 0}
};

static param_export_t scscf_params[]={ 
    {"name",                            STR_PARAM, &scscf_name},

    {"forced_hss_peer",                 STR_PARAM, &scscf_forced_hss_peer},

    {"auth_data_hash_size",             INT_PARAM, &auth_data_hash_size},
    {"auth_vector_timeout",             INT_PARAM, &auth_vector_timeout},
    {"auth_data_timeout",               INT_PARAM, &auth_data_timeout},
    {"av_request_at_once",              INT_PARAM, &av_request_at_once},
    {"av_request_at_sync",              INT_PARAM, &av_request_at_sync},

    {"server_assignment_store_data",    INT_PARAM, &server_assignment_store_data},

    {"user_data_dtd",                   STR_PARAM, &scscf_user_data_dtd},
    {"user_data_xsd",                   STR_PARAM, &scscf_user_data_xsd},

    {"registrar_hash_size",             INT_PARAM, &registrar_hash_size},
    {"registration_default_expires",    INT_PARAM, &registration_default_expires},
    {"registration_min_expires",        INT_PARAM, &registration_min_expires},
    {"registration_max_expires",        INT_PARAM, &registration_max_expires},
    {"registration_qop",                        STR_PARAM, &registration_qop},
    {"registration_default_algorithm",  STR_PARAM, &registration_default_algorithm},
    {"registration_disable_early_ims",  INT_PARAM, &registration_disable_early_ims},
    {"registration_disable_nass_bundled",INT_PARAM, &registration_disable_nass_bundled},

    {"subscription_default_expires",    INT_PARAM, &subscription_default_expires},
    {"subscription_min_expires",        INT_PARAM, &subscription_min_expires},
    {"subscription_max_expires",        INT_PARAM, &subscription_max_expires},

    {"append_branches",                 INT_PARAM, &append_branches},

    {"dialogs_hash_size",               INT_PARAM, &scscf_dialogs_hash_size},
    {"dialogs_expiration_time",         INT_PARAM, &scscf_dialogs_expiration_time},
    {"dialogs_enable_release",          INT_PARAM, &scscf_dialogs_enable_release},
    {"max_dialog_count",                INT_PARAM, &scscf_max_dialog_count},
    {"min_se",                          INT_PARAM, &scscf_min_se},
    {"support_wildcardPSI",             INT_PARAM, &scscf_support_wildcardPSI},
    {"persistency_mode",                INT_PARAM, &scscf_persistency_mode},    
    {"persistency_location",            STR_PARAM, &scscf_persistency_location},
    {"persistency_timer_authdata",      INT_PARAM, &scscf_persistency_timer_authdata},
    {"persistency_timer_dialogs",       INT_PARAM, &scscf_persistency_timer_dialogs},
    {"persistency_timer_registrar",     INT_PARAM, &scscf_persistency_timer_registrar},
    {"scscf_db_url",                    STR_PARAM, &scscf_db_url},

#ifdef WITH_IMS_PM
    {"ims_pm_node_type",                STR_PARAM, &ims_pm_node_type},
    {"ims_pm_logfile",                  STR_PARAM, &ims_pm_logfile},
#endif /* WITH_IMS_PM */

    {0,0,0} 
};

struct module_exports exports = {
    "scscf", 
    scscf_cmds,
    0,
    scscf_params,
    
    mod_init,       /* module initialization function */
    0,              /* response function*/
    mod_destroy,    /* destroy function */
    0,              /* onbreak function */
    mod_child_init  /* per-child init function */
};


int (*sl_reply)(struct sip_msg* _msg, char* _str1, char* _str2); 
struct tm_binds tmb;                            
struct cdp_binds cdpb;                          
dlg_func_t dialogb;                             
extern auth_hash_slot_t *auth_data;             
extern r_hash_slot *registrar;                  
extern r_notification_list *notification_list;  
extern s_dialog_hash_slot *s_dialogs;           
db_con_t* scscf_db = NULL; 
db_func_t scscf_dbf;    
static str s_qop_s={", qop=\"",7};
static str s_qop_e={"\"",1};
static str s_service_route = {"Service-Route: <",16};
static str s_orig = {"sip:orig@",9};
static str s_sr_end = {";lr>\r\n",6};
static str s_min_expires_s={"Min-Expires: ",13};
static str s_min_expires_e={"\r\n",2};

static str s_record_route_s={"Record-Route: <",15};
static str s_mo = {"sip:mo@",7};
static str s_mt = {"sip:mt@",7};
static str s_record_route_e={";lr>\r\n",6};
static inline int build_record_service_route()
{
    scscf_service_route.s = pkg_malloc(s_service_route.len+s_orig.len+scscf_name_str.len+s_sr_end.len);
    if (!scscf_service_route.s){
        LOG(L_ERR, "ERR"M_NAME":mod_init: Error allocating %d bytes\n",
            s_service_route.len+s_orig.len+scscf_name_str.len+s_sr_end.len);
        return 0;
    }
    scscf_registration_min_expires.s = pkg_malloc(s_min_expires_s.len+10+s_min_expires_e.len);
    if (!scscf_registration_min_expires.s){
        LOG(L_ERR, "ERR"M_NAME":mod_init: Error allocating %d bytes\n",
            s_min_expires_s.len+10+s_min_expires_e.len);
        return 0;
    }
    scscf_subscription_min_expires.s = pkg_malloc(s_min_expires_s.len+10+s_min_expires_e.len);
    if (!scscf_subscription_min_expires.s){
        LOG(L_ERR, "ERR"M_NAME":mod_init: Error allocating %d bytes\n",
            s_min_expires_s.len+10+s_min_expires_e.len);
        return 0;
    }
    
    if (registration_qop && strlen(registration_qop)>0) {
        registration_qop_str.len = s_qop_s.len+strlen(registration_qop)+s_qop_e.len;
        registration_qop_str.s = pkg_malloc(registration_qop_str.len);
        if (!registration_qop_str.s){
            LOG(L_ERR, "ERR"M_NAME":mod_init: Error allocating %d bytes\n",registration_qop_str.len);
            registration_qop_str.len = 0;
            return 0;
        }
        registration_qop_str.len = 0;
        STR_APPEND(registration_qop_str,s_qop_s);
        memcpy(registration_qop_str.s+registration_qop_str.len,registration_qop,strlen(registration_qop));
        registration_qop_str.len += strlen(registration_qop);
        STR_APPEND(registration_qop_str,s_qop_e);       
    }else{
        registration_qop_str.len=0;
        registration_qop_str.s=0;
    }
    
    scscf_record_route_mo.s = pkg_malloc(s_record_route_s.len+s_mo.len+scscf_name_str.len+s_record_route_e.len);
    if (!scscf_record_route_mo.s){
        LOG(L_ERR, "ERR"M_NAME":mod_init: Error allocating %d bytes\n",
            s_record_route_s.len+s_mo.len+scscf_name_str.len+s_record_route_e.len);
        return 0;
    }
    scscf_record_route_mt.s = pkg_malloc(s_record_route_s.len+s_mt.len+scscf_name_str.len+s_record_route_e.len);
    if (!scscf_record_route_mt.s){
        LOG(L_ERR, "ERR"M_NAME":mod_init: Error allocating %d bytes\n",
            s_record_route_s.len+s_mt.len+scscf_name_str.len+s_record_route_e.len);
        return 0;
    }
    
    STR_APPEND(scscf_service_route,s_service_route);
    if (scscf_name_str.len>4 && strncasecmp(scscf_name_str.s,"sip:",4)==0){
        STR_APPEND(scscf_service_route,s_orig);
        memcpy(scscf_service_route.s+scscf_service_route.len,scscf_name_str.s+4,
            scscf_name_str.len-4);
        scscf_service_route.len += scscf_name_str.len-4;
    } else {
        STR_APPEND(scscf_service_route,s_orig);
        STR_APPEND(scscf_service_route,scscf_name_str);
    }
    STR_APPEND(scscf_service_route,s_sr_end);
    scscf_service_route_uri.s = scscf_service_route.s + s_service_route.len;
    scscf_service_route_uri.len = scscf_service_route.len - s_service_route.len - s_sr_end.len;

    sprintf(scscf_registration_min_expires.s,"%.*s%d%.*s",
        s_min_expires_s.len,s_min_expires_s.s,
        registration_min_expires,
        s_min_expires_e.len,s_min_expires_e.s);
    scscf_registration_min_expires.len = strlen(scscf_registration_min_expires.s);

    sprintf(scscf_subscription_min_expires.s,"%.*s%d%.*s",
        s_min_expires_s.len,s_min_expires_s.s,
        subscription_min_expires,
        s_min_expires_e.len,s_min_expires_e.s);
    scscf_subscription_min_expires.len = strlen(scscf_subscription_min_expires.s);

    scscf_record_route_mo.len=0;
    STR_APPEND(scscf_record_route_mo,s_record_route_s);
    if (scscf_name_str.len>4 && strncasecmp(scscf_name_str.s,"sip:",4)==0){
        STR_APPEND(scscf_record_route_mo,s_mo);
        memcpy(scscf_record_route_mo.s+scscf_record_route_mo.len,scscf_name_str.s+4,
            scscf_name_str.len-4);
        scscf_record_route_mo.len += scscf_name_str.len-4;
    } else {
        STR_APPEND(scscf_record_route_mo,s_mo);
        STR_APPEND(scscf_record_route_mo,scscf_name_str);
    }
    STR_APPEND(scscf_record_route_mo,s_record_route_e);
    scscf_record_route_mo_uri.s = scscf_record_route_mo.s + s_record_route_s.len;
    scscf_record_route_mo_uri.len = scscf_record_route_mo.len - s_record_route_s.len - s_record_route_e.len;

    scscf_record_route_mt.len=0;
    STR_APPEND(scscf_record_route_mt,s_record_route_s);
    if (scscf_name_str.len>4 && strncasecmp(scscf_name_str.s,"sip:",4)==0){
        STR_APPEND(scscf_record_route_mt,s_mt);
        memcpy(scscf_record_route_mt.s+scscf_record_route_mt.len,scscf_name_str.s+4,
            scscf_name_str.len-4);
        scscf_record_route_mt.len += scscf_name_str.len-4;
    } else {
        STR_APPEND(scscf_record_route_mt,s_mt);
        STR_APPEND(scscf_record_route_mt,scscf_name_str);
    }
    STR_APPEND(scscf_record_route_mt,s_record_route_e);
    scscf_record_route_mt_uri.s = scscf_record_route_mt.s + s_record_route_s.len;
    scscf_record_route_mt_uri.len = scscf_record_route_mt.len - s_record_route_s.len - s_record_route_e.len;


    return 1;
}

db_con_t* create_scscf_db_connection()
{
    if (scscf_persistency_mode!=WITH_DATABASE_BULK && scscf_persistency_mode!=WITH_DATABASE_CACHE) return NULL;
    if (!scscf_dbf.init) return NULL;

    return scscf_dbf.init(scscf_db_url);
}

static int mod_init(void)
{
    load_tm_f load_tm;
    load_cdp_f load_cdp;
    bind_dlg_mod_f load_dlg;
    str algo;
    
    callback_singleton=shm_malloc(sizeof(int));
    *callback_singleton=0;
    shutdown_singleton=shm_malloc(sizeof(int));
    *shutdown_singleton=0;
    
        
    LOG(L_INFO,"INFO:"M_NAME":mod_init: Initialization of module\n");
    /* fix the parameters */
    scscf_name_str.s = scscf_name;
    scscf_name_str.len = strlen(scscf_name);
    if (!build_record_service_route()) goto error;
    scscf_forced_hss_peer_str.s = scscf_forced_hss_peer;
    scscf_forced_hss_peer_str.len = strlen(scscf_forced_hss_peer);
    
    algo.s = registration_default_algorithm;
    algo.len = strlen(registration_default_algorithm);
    registration_default_algorithm_type = get_algorithm_type(algo); 
    

    #ifdef WITH_IMS_PM
        ims_pm_init(scscf_name_str,ims_pm_node_type, ims_pm_logfile);
        ims_pm_init_scscf();
    #endif /* WITH_IMS_PM */
            
    /* load the send_reply function from sl module */
    sl_reply = find_export("sl_send_reply", 2, 0);
    if (!sl_reply) {
        LOG(L_ERR, "ERR"M_NAME":mod_init: This module requires sl module\n");
        goto error;
    }
    
//  /* bind to the db module */
//  if ( cscf_db_bind( scscf_db_url ) < 0 ) goto error;

    if(scscf_persistency_mode==WITH_DATABASE_BULK || scscf_persistency_mode==WITH_DATABASE_CACHE){
        if (!scscf_db_url) {
            LOG(L_ERR, "ERR:"M_NAME":mod_init: no db_url specified but DB has to be used "
                "(scscf_persistency_mode=%d\n", scscf_persistency_mode);
            return -1;
        }
        if (bind_dbmod(scscf_db_url, &scscf_dbf) < 0) { /* Find database module */
            LOG(L_ERR, "ERR"M_NAME":mod_init: Can't bind database module via url %s\n", scscf_db_url);
            return -1;
        }

        if (!DB_CAPABILITY(scscf_dbf, DB_CAP_ALL)) {
            LOG(L_ERR, "ERR:"M_NAME":mod_init: Database module does not implement all functions needed by the module\n");
            return -1;
        }
        
        scscf_db = create_scscf_db_connection();
        if (!scscf_db) {
            LOG(L_ERR, "ERR:"M_NAME": mod_init: Error while connecting database\n");
            return -1;
        }
        
        /* db lock */
        db_lock = (gen_lock_t*)lock_alloc();
        if(!db_lock){
            LOG(L_ERR, "ERR:"M_NAME": mod_init: No memory left\n");
            return -1;
        }
        lock_init(db_lock);
    
        /* snapshot and step versions */
    
        auth_snapshot_version=(int*)shm_malloc(sizeof(int));
        if(!auth_snapshot_version){
            LOG(L_ERR, "ERR:"M_NAME":mod_init: auth_snapshot_version, no memory left\n");
            return -1;
        }
        *auth_snapshot_version=0;
    
        auth_step_version=(int*)shm_malloc(sizeof(int));
        if(!auth_step_version){
            LOG(L_ERR, "ERR:"M_NAME":mod_init: auth_step_version, no memory left\n");
            return -1;
        }
        *auth_step_version=0;
    
        dialogs_snapshot_version=(int*)shm_malloc(sizeof(int));
        if(!dialogs_snapshot_version){
            LOG(L_ERR, "ERR:"M_NAME":mod_init: dialogs_snapshot_version, no memory left\n");
            return -1;
        }
        *dialogs_snapshot_version=0;
    
        dialogs_step_version=(int*)shm_malloc(sizeof(int));
        if(!dialogs_step_version){
            LOG(L_ERR, "ERR:"M_NAME":mod_init: dialogs_step_version, no memory left\n");
            return -1;
        }
        *dialogs_step_version=0;
    
        registrar_snapshot_version=(int*)shm_malloc(sizeof(int));
        if(!registrar_snapshot_version){
            LOG(L_ERR, "ERR:"M_NAME":mod_init: registrar_snapshot_version, no memory left\n");
            return -1;
        }
        *registrar_snapshot_version=0;
    
        registrar_step_version=(int*)shm_malloc(sizeof(int));
        if(!registrar_step_version){
            LOG(L_ERR, "ERR:"M_NAME":mod_init: registrar_step_version, no memory left\n");
            return -1;
        }
        *registrar_step_version=0;
        
    }
    
    /* bind to the tm module */
    if (!(load_tm = (load_tm_f)find_export("load_tm",NO_SCRIPT,0))) {
        LOG(L_ERR, "ERR"M_NAME":mod_init: Can not import load_tm. This module requires tm module\n");
        goto error;
    }
    if (load_tm(&tmb) == -1)
        goto error;
    /* bind to the cdp module */
    if (!(load_cdp = (load_cdp_f)find_export("load_cdp",NO_SCRIPT,0))) {
        LOG(L_ERR, "ERR"M_NAME":mod_init: Can not import load_cdp. This module requires cdp module\n");
        goto error;
    }
    if (load_cdp(&cdpb) == -1)
        goto error;

    /* bind to the dialog module */
    load_dlg = (bind_dlg_mod_f)find_export("bind_dlg_mod", -1, 0);
    if (!load_dlg) {
        LOG(L_ERR, "ERR"M_NAME":mod_init:  Can not import bind_dlg_mod. This module requires dialog module\n");
        return -1;
    }
    if (load_dlg(&dialogb) != 0) {
        return -1;
    }
    
    
    /* Init the authorization data storage */
    if (!auth_data_init(auth_data_hash_size)) goto error;   
    if (scscf_persistency_mode!=NO_PERSISTENCY){
        load_snapshot_authdata();
        if (register_timer(persistency_timer_authdata,0,scscf_persistency_timer_authdata)<0) goto error;
    }
    

    /* register the authentication vectors timer */
    if (register_timer(reg_await_timer,auth_data,10)<0) goto error;
    
    /* init the registrar storage */
    if (!r_storage_init(registrar_hash_size)) goto error;
    if (scscf_persistency_mode!=NO_PERSISTENCY){
        load_snapshot_registrar();
        if (register_timer(persistency_timer_registrar,0,scscf_persistency_timer_registrar)<0) goto error;
    }

    /* register the registrar timer */
    if (register_timer(registrar_timer,registrar,10)<0) goto error;

    /* init the registrar notifications */
    if (!r_notify_init()) goto error;

    /* register the registrar notifications timer */
    if (register_timer(notification_timer,notification_list,5)<0) goto error;

    /* init the dialog storage */
    if (!s_dialogs_init(scscf_dialogs_hash_size)){
        LOG(L_ERR, "ERR"M_NAME":mod_init: Error initializing the Hash Table for stored dialogs\n");
        goto error;
    }       
    scscf_dialog_count = shm_malloc(sizeof(int));
    *scscf_dialog_count = 0;
    scscf_dialog_count_lock = lock_alloc();
    scscf_dialog_count_lock = lock_init(scscf_dialog_count_lock);

    if (scscf_persistency_mode!=NO_PERSISTENCY){
        load_snapshot_dialogs();
        if (register_timer(persistency_timer_dialogs,0,scscf_persistency_timer_dialogs)<0) goto error;
    }

    /* register the dialog timer */
    if (register_timer(dialog_timer,s_dialogs,60)<0) goto error;


    /* don't register response callback as we always set callback per transactions 
     *  and we're not interested in other responses */
    /*AAAAddResponseHandler(&CxAnswerHandler,0);*/

    
    return 0;
error:
    return -1;
}

extern gen_lock_t* process_lock;        /* lock on the process table */


void close_scscf_db_connection(db_con_t* db)
{
    if (db && scscf_dbf.close) scscf_dbf.close(db);
}

static int mod_child_init(int rank)
{
    LOG(L_INFO,"INFO:"M_NAME":mod_child_init: Initialization of module in child [%d] \n",
        rank);
    /* don't do anything for main process and TCP manager process */
    if ( rank == PROC_MAIN || rank == PROC_TCP_MAIN )
        return 0;
    
//  /* db child init */
//  cscf_db_init( scscf_db_url, 
//      scscf_db_nds_table,
//      scscf_db_scscf_table,
//      scscf_db_capabilities_table);
    
    /*if (scscf_persistency_mode==WITH_DATABASE_BULK || scscf_persistency_mode==WITH_DATABASE_CACHE) { 
        scscf_db = create_scscf_db_connection();
        if (!scscf_db) {
            LOG(L_ERR, "ERR:"M_NAME":mod_child_init(%d): "
                    "Error while connecting database\n", rank);
            return -1;
        }
    }*/
    
    /* init the diameter callback - must be done just once */
    lock_get(process_lock);
        if((*callback_singleton)==0){
            *callback_singleton=1;
            cdpb.AAAAddRequestHandler(CxRequestHandler,NULL);
        }
    lock_release(process_lock);
    /* Init the user data parser */
    if (!parser_init(scscf_user_data_dtd,scscf_user_data_xsd)) return -1;
        
    return 0;
}

static void mod_destroy(void)
{
    int do_destroy=0;
    LOG(L_INFO,"INFO:"M_NAME":mod_destroy: child exit\n");
    lock_get(process_lock);
        if((*shutdown_singleton)==0){
            *shutdown_singleton=1;
            do_destroy=1;
        }
    lock_release(process_lock);
    if (do_destroy){
        if (scscf_persistency_mode!=NO_PERSISTENCY){
            /* First let's snapshot everything */
            make_snapshot_authdata();
            make_snapshot_dialogs();
            make_snapshot_registrar();
        }
        /* Then nuke it all */
        auth_data_destroy();
        parser_destroy();
        r_notify_destroy(); 
        r_storage_destroy();
        s_dialogs_destroy();    
        lock_get(scscf_dialog_count_lock);
        shm_free(scscf_dialog_count);
        lock_destroy(scscf_dialog_count_lock);      
        pkg_free(scscf_service_route.s);
    }
    
    if ( (scscf_persistency_mode==WITH_DATABASE_BULK || scscf_persistency_mode==WITH_DATABASE_CACHE) && scscf_db) {
        DBG("INFO:"M_NAME": ... closing db connection\n");
        close_scscf_db_connection(scscf_db);
    }
    scscf_db = NULL;
    #ifdef WITH_IMS_PM
        ims_pm_destroy();   
    #endif /* WITH_IMS_PM */    
}




int S_trans_in_processing(struct sip_msg* msg, char* str1, char* str2)
{
    unsigned int hash, label;
    if (tmb.t_get_trans_ident(msg,&hash,&label)<0)
        return CSCF_RETURN_FALSE;
    return CSCF_RETURN_TRUE;    
}

---