/* destroy function */
static void destroy(void)
{
struct module_list *tmp;
/* close DB connection */
if (db_hdl) {
dr_dbf.close(db_hdl);
db_hdl = NULL;
}
/* destroy data */
if (tdata) {
if (*tdata)
free_data(*tdata);
shm_free(tdata);
tdata = NULL;
}
while (clusterer_modules) {
tmp = clusterer_modules;
clusterer_modules = clusterer_modules->next;
shm_free(tmp);
}
/* destroy lock */
if (ref_lock) {
lock_destroy_rw(ref_lock);
ref_lock = NULL;
}
}
static void destroy(void)
{
if (db_hdl) {
/* close DB connection */
dr_dbf.close(db_hdl);
db_hdl = NULL;
}
/* destroy data */
if (cluster_list) {
if (*cluster_list)
free_info(*cluster_list);
shm_free(cluster_list);
cluster_list = NULL;
}
/* destroy lock */
if (cl_list_lock) {
lock_destroy_rw(cl_list_lock);
cl_list_lock = NULL;
}
/* free generic message receiving events events */
gen_rcv_evs_destroy();
}
void destroy_data(void)
{
dp_connection_list_t *el, *next;
LM_DBG("Destroying data\n");
for (el = dp_conns; el && (next = el->next, 1); el = next) {
destroy_hash(&el->hash[0]);
destroy_hash(&el->hash[1]);
lock_destroy_rw(el->ref_lock);
shm_free(el);
}
}
void free_timer_table(void)
{
enum lists i;
if (timertable) {
/* the mutexs for sync the lists are released*/
for ( i=0 ; i<timer_sets*NR_OF_TIMER_LISTS ; i++ )
release_timerlist_lock( &timertable->timers[i] );
for ( i=0 ; i<timer_sets ; i++ )
lock_destroy_rw( timertable[i].ex_lock );
shm_free(timertable);
}
}
static void mod_destroy(void)
{
/*destroy shared memory*/
if(default_par2){
shm_free(default_par2);
default_par2 = NULL;
}
if(attr_pvar){
shm_free(attr_pvar);
attr_pvar = NULL;
}
destroy_data();
if (ref_lock) {
lock_destroy_rw( ref_lock );
ref_lock = 0;
}
}
static void mod_destroy(void)
{
/* destroy data */
if ( curr_data) {
if (*curr_data)
free_lb_data( *curr_data );
shm_free( curr_data );
curr_data = 0;
}
/* destroy lock */
if (ref_lock) {
lock_destroy_rw( ref_lock );
ref_lock = 0;
}
/* destroy blacklist structures */
destroy_lb_bls();
}
static void mod_destroy(void)
{
LM_DBG("cleaning up\n");
if (_ptree!=NULL)
{
if (*_ptree!=NULL)
pdt_free_tree(*_ptree);
shm_free(_ptree);
}
if (db_con!=NULL && pdt_dbf.close!=NULL)
pdt_dbf.close(db_con);
/* destroy lock */
if (pdt_lock)
{
lock_destroy_rw( pdt_lock );
pdt_lock = 0;
}
}
/*
* called from main.c when opensips exits (main process)
*/
static void mod_destroy(void)
{
struct tls_domain *d;
LM_DBG("entered\n");
if (dom_lock) {
lock_destroy_rw(dom_lock);
dom_lock = 0;
}
d = tls_server_domains;
while (d) {
if (d->ctx)
SSL_CTX_free(d->ctx);
lock_destroy(d->lock);
lock_dealloc(d->lock);
d = d->next;
}
d = tls_client_domains;
while (d) {
if (d->ctx)
SSL_CTX_free(d->ctx);
lock_destroy(d->lock);
lock_dealloc(d->lock);
d = d->next;
}
if (tls_default_server_domain.ctx) {
SSL_CTX_free(tls_default_server_domain.ctx);
}
if (tls_default_client_domain.ctx) {
SSL_CTX_free(tls_default_client_domain.ctx);
}
tls_free_domains();
/* TODO - destroy static locks */
/* library destroy */
ERR_free_strings();
/*SSL_free_comp_methods(); - this function is not on std. openssl*/
EVP_cleanup();
CRYPTO_cleanup_all_ex_data();
return;
}
/*! \brief
* Module destroy function
*/
static void destroy(void)
{
/* we need to sync DB in order to flush the cache */
if (ul_dbh) {
ul_unlock_locks();
if (sync_lock)
lock_start_read(sync_lock);
if (synchronize_all_udomains() != 0) {
LM_ERR("flushing cache failed\n");
}
if (sync_lock) {
lock_stop_read(sync_lock);
lock_destroy_rw(sync_lock);
sync_lock = 0;
}
ul_dbf.close(ul_dbh);
}
free_all_udomains();
ul_destroy_locks();
/* free callbacks list */
destroy_ulcb_list();
}
static int mod_init(void)
{
int heartbeats_timer_interval;
cluster_info_t *cl;
LM_INFO("Clusterer module - initializing\n");
db_table.len = strlen(db_table.s);
id_col.len = strlen(id_col.s);
cluster_id_col.len = strlen(cluster_id_col.s);
node_id_col.len = strlen(node_id_col.s);
url_col.len = strlen(url_col.s);
state_col.len = strlen(state_col.s);
no_ping_retries_col.len = strlen(no_ping_retries_col.s);
priority_col.len = strlen(priority_col.s);
sip_addr_col.len = strlen(sip_addr_col.s);
flags_col.len = strlen(flags_col.s);
description_col.len = strlen(description_col.s);
/* only allow the DB URL to be skipped in "P2P discovery" mode */
init_db_url(clusterer_db_url, db_mode == 0);
if (current_id < 1) {
LM_CRIT("Invalid 'my_node_id' parameter\n");
return -1;
}
if (ping_interval <= 0) {
LM_WARN("Invalid ping_interval parameter, using default value\n");
ping_interval = DEFAULT_PING_INTERVAL;
}
if (node_timeout < 0) {
LM_WARN("Invalid node_timeout parameter, using default value\n");
node_timeout = DEFAULT_NODE_TIMEOUT;
}
if (ping_timeout <= 0) {
LM_WARN("Invalid ping_timeout parameter, using default value\n");
ping_timeout = DEFAULT_PING_TIMEOUT;
}
/* create & init lock */
if ((cl_list_lock = lock_init_rw()) == NULL) {
LM_CRIT("Failed to init lock\n");
return -1;
}
/* data pointer in shm */
if (cluster_list == NULL) {
cluster_list = shm_malloc(sizeof *cluster_list);
if (!cluster_list) {
LM_CRIT("No more shm memory\n");
goto error;
}
*cluster_list = NULL;
} else {
/* sanity check of my_node_id if node_id also set in a my_node_info param */
for (cl = *cluster_list; cl; cl = cl->next)
if (cl->current_node->node_id != current_id) {
LM_ERR("Bad 'my_node_id' parameter, value: %d different than"
" the node_id property in the 'my_node_info' parameter\n", current_id);
goto error;
}
}
if (db_mode) {
/* bind to the mysql module */
if (db_bind_mod(&clusterer_db_url, &dr_dbf)) {
LM_CRIT("Cannot bind to database module! "
"Did you forget to load a database module ?\n");
goto error;
}
if (!DB_CAPABILITY(dr_dbf, DB_CAP_QUERY)) {
LM_CRIT("Given SQL DB does not provide query types needed by this module!\n");
goto error;
}
/* init DB connection */
if ((db_hdl = dr_dbf.init(&clusterer_db_url)) == 0) {
LM_ERR("cannot initialize database connection\n");
goto error;
}
if (load_db_info(&dr_dbf, db_hdl, &db_table, cluster_list) < 0) {
LM_ERR("Failed to load info from DB\n");
goto error;
}
}
/* register timer */
heartbeats_timer_interval = gcd(ping_interval*1000, ping_timeout);
heartbeats_timer_interval = gcd(heartbeats_timer_interval, node_timeout*1000);
if (heartbeats_timer_interval % 1000 == 0) {
if (register_timer("clstr-heartbeats-timer", heartbeats_timer_handler,
NULL, heartbeats_timer_interval/1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("Unable to register clusterer heartbeats timer\n");
goto error;
}
} else {
if (register_utimer("clstr-heartbeats-utimer", heartbeats_utimer_handler,
NULL, heartbeats_timer_interval*1000, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("Unable to register clusterer heartbeats timer\n");
goto error;
}
}
if (bin_register_cb(&cl_internal_cap, bin_rcv_cl_packets, NULL) < 0) {
LM_CRIT("Cannot register clusterer binary packet callback!\n");
goto error;
}
if (bin_register_cb(&cl_extra_cap, bin_rcv_cl_extra_packets, NULL) < 0) {
LM_CRIT("Cannot register extra clusterer binary packet callback!\n");
goto error;
}
/* create generic message receiving events */
if (gen_rcv_evs_init() < 0) {
LM_ERR("cannot create cluster message received event\n");
return -1;
}
return 0;
error:
lock_destroy_rw(cl_list_lock);
cl_list_lock = NULL;
if (cluster_list) {
shm_free(cluster_list);
cluster_list = 0;
}
return -1;
}
/* initialize function */
static int mod_init(void)
{
LM_INFO("Cluster-Info - initializing\n");
/* check the module params */
init_db_url(clusterer_db_url, 0 /*cannot be null*/);
if (server_id < 1) {
LM_ERR("invalid machine id\n");
return -1;
}
if (persistent_state < 0 || persistent_state > 1) {
LM_WARN("invalid value for persistent state - presistence disabled\n");
persistent_state = 0;
}
db_table.len = strlen(db_table.s);
cluster_id_col.len = strlen(cluster_id_col.s);
machine_id_col.len = strlen(machine_id_col.s);
id_col.len = strlen(id_col.s);
state_col.len = strlen(state_col.s);
url_col.len = strlen(url_col.s);
description_col.len = strlen(description_col.s);
last_attempt_col.len = strlen(last_attempt_col.s);
duration_col.len = strlen(duration_col.s);
failed_attempts_col.len = strlen(failed_attempts_col.s);
no_tries_col.len = strlen(no_tries_col.s);
/* create & init lock */
if ((ref_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
goto error;
}
/* data pointer in shm */
tdata = shm_malloc(sizeof *tdata);
if (!tdata) {
LM_CRIT("failed to get shm mem for data ptr\n");
goto error;
}
*tdata = NULL;
/* bind to the mysql module */
if (db_bind_mod(&clusterer_db_url, &dr_dbf)) {
LM_CRIT("cannot bind to database module! "
"Did you forget to load a database module ?\n");
goto error;
}
if (!DB_CAPABILITY(dr_dbf, DB_CAP)) {
LM_CRIT("given SQL DB does not provide query types needed by this module!\n");
goto error;
}
/* register timer */
if (persistent_state) {
/* register function to flush changes in state */
if (register_timer("update database", update_db_handler,
NULL, prob_interval, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("unable to synchronize with the database\n");
goto error;
}
}
if (register_timer("update servers", update_nodes_handler,
NULL, prob_interval, TIMER_FLAG_DELAY_ON_DELAY) < 0) {
LM_CRIT("unable to update status for incoming clients\n");
goto error;
}
/* everything is OK */
return 0;
error:
if (ref_lock) {
lock_destroy_rw(ref_lock);
ref_lock = 0;
}
if (tdata) {
shm_free(tdata);
tdata = 0;
}
return -1;
}
/**
* init module function
*/
static int mod_init(void)
{
LM_INFO("initializing...\n");
init_db_url( db_url , 0 /*cannot be null*/);
db_table.len = strlen(db_table.s);
sdomain_column.len = strlen(sdomain_column.s);
prefix_column.len = strlen(prefix_column.s);
domain_column.len = strlen(domain_column.s);
prefix.len = strlen(prefix.s);
pdt_char_list.len = strlen(pdt_char_list.s);
if(pdt_char_list.len<=0)
{
LM_ERR("invalid pdt char list\n");
return -1;
}
LM_INFO("pdt_char_list=%s \n",pdt_char_list.s);
/* binding to mysql module */
if(db_bind_mod(&db_url, &pdt_dbf))
{
LM_ERR("database module not found\n");
return -1;
}
if (!DB_CAPABILITY(pdt_dbf, DB_CAP_ALL))
{
LM_ERR("database module does not "
"implement all functions needed by the module\n");
return -1;
}
/* open a connection with the database */
db_con = pdt_dbf.init(&db_url);
if(db_con==NULL)
{
LM_ERR("failed to connect to the database\n");
return -1;
}
if (pdt_dbf.use_table(db_con, &db_table) < 0)
{
LM_ERR("failed to use_table\n");
goto error1;
}
LM_DBG("database connection opened successfully\n");
/* create & init lock */
if ((pdt_lock = lock_init_rw()) == NULL) {
LM_CRIT("failed to init lock\n");
goto error1;
}
/* tree pointer in shm */
_ptree = (pdt_tree_t**)shm_malloc( sizeof(pdt_tree_t*) );
if (_ptree==0) {
LM_ERR("out of shm mem for pdtree\n");
goto error1;
}
*_ptree=0;
/* loading all information from database */
if(pdt_load_db()!=0)
{
LM_ERR("cannot load info from database\n");
goto error1;
}
pdt_dbf.close(db_con);
db_con = 0;
#if 0
pdt_print_tree(*_ptree);
#endif
/* success code */
return 0;
error1:
if (pdt_lock)
{
lock_destroy_rw( pdt_lock );
pdt_lock = 0;
}
if(_ptree!=0)
shm_free(_ptree);
if(db_con!=NULL)
{
pdt_dbf.close(db_con);
db_con = 0;
}
return -1;
}
