int dbt_init_cache() { if(!_cachesem) { /* init locks */ _cachesem = lock_alloc(); if(!_cachesem) { LOG(L_CRIT,"dbtext:dbt_init_cache: could not alloc a lock\n"); return -1; } if (lock_init(_cachesem)==0) { LOG(L_CRIT,"dbtext:dbt_init_cache: could not intialize a lock\n"); lock_dealloc(_cachesem); return -1; } } /* init pointer to caches list */ if (!_cachedb) { _cachedb = shm_malloc( sizeof(dbt_cache_p) ); if (!_cachedb) { LOG(L_CRIT,"dbtext:dbt_init_cache: no enough shm mem\n"); lock_dealloc(_cachesem); return -1; } *_cachedb = NULL; } return 0; }
int wsconn_init(void) { wsconn_lock = lock_alloc(); if (wsconn_lock == NULL) { LM_ERR("allocating lock\n"); goto error; } if (lock_init(wsconn_lock) == 0) { LM_ERR("initialising lock\n"); goto error; } wsstat_lock = lock_alloc(); if (wsstat_lock == NULL) { LM_ERR("allocating lock\n"); goto error; } if (lock_init(wsstat_lock) == NULL) { LM_ERR("initialising lock\n"); goto error; } wsconn_id_hash = (ws_connection_t **) shm_malloc(TCP_ID_HASH_SIZE * sizeof(ws_connection_t*)); if (wsconn_id_hash == NULL) { LM_ERR("allocating WebSocket hash-table\n"); goto error; } memset((void *) wsconn_id_hash, 0, TCP_ID_HASH_SIZE * sizeof(ws_connection_t *)); wsconn_used_list = (ws_connection_used_list_t *) shm_malloc( sizeof(ws_connection_used_list_t)); if (wsconn_used_list == NULL) { LM_ERR("allocating WebSocket used list\n"); goto error; } memset((void *) wsconn_used_list, 0, sizeof(ws_connection_used_list_t)); return 0; error: if (wsconn_lock) lock_dealloc((void *) wsconn_lock); if (wsstat_lock) lock_dealloc((void *) wsstat_lock); wsconn_lock = wsstat_lock = NULL; if (wsconn_id_hash) shm_free(wsconn_id_hash); if (wsconn_used_list) shm_free(wsconn_used_list); wsconn_id_hash = NULL; wsconn_used_list = NULL; return -1; }
int init_tcp() { /* init lock */ tcpconn_lock=lock_alloc(); if (tcpconn_lock==0){ LOG(L_CRIT, "ERROR: init_tcp: could not alloc lock\n"); goto error; } if (lock_init(tcpconn_lock)==0){ LOG(L_CRIT, "ERROR: init_tcp: could not init lock\n"); lock_dealloc((void*)tcpconn_lock); tcpconn_lock=0; goto error; } /* init globals */ connection_id=(int*)shm_malloc(sizeof(int)); if (connection_id==0){ LOG(L_CRIT, "ERROR: init_tcp: could not alloc globals\n"); lock_destroy(tcpconn_lock); lock_dealloc((void*)tcpconn_lock); tcpconn_lock=0; goto error; } *connection_id=1; /* alloc hashtables*/ tcpconn_addr_hash=(struct tcp_connection**)shm_malloc(TCP_ADDR_HASH_SIZE* sizeof(struct tcp_connection*)); if (tcpconn_addr_hash==0){ LOG(L_CRIT, "ERROR: init_tcp: could not alloc address hashtable\n"); shm_free(connection_id); connection_id=0; lock_destroy(tcpconn_lock); lock_dealloc((void*)tcpconn_lock); tcpconn_lock=0; goto error; } tcpconn_id_hash=(struct tcp_connection**)shm_malloc(TCP_ID_HASH_SIZE* sizeof(struct tcp_connection*)); if (tcpconn_id_hash==0){ LOG(L_CRIT, "ERROR: init_tcp: could not alloc id hashtable\n"); shm_free(connection_id); connection_id=0; shm_free(tcpconn_addr_hash); tcpconn_addr_hash=0; lock_destroy(tcpconn_lock); lock_dealloc((void*)tcpconn_lock); tcpconn_lock=0; goto error; } /* init hashtables*/ memset((void*)tcpconn_addr_hash, 0, TCP_ADDR_HASH_SIZE * sizeof(struct tcp_connection*)); memset((void*)tcpconn_id_hash, 0, TCP_ID_HASH_SIZE * sizeof(struct tcp_connection*)); return 0; error: return -1; }
/** * Destroys the session related structures. */ int cdp_sessions_destroy() { int i; cdp_session_t *n,*x; if (session_lock){ lock_get(session_lock); lock_destroy(session_lock); lock_dealloc((void*)session_lock); session_lock=0; } for(i=0;i<sessions_hash_size;i++){ AAASessionsLock(i); for(x = sessions[i].head; x; x = n){ n = x->next; free_session(x); } lock_destroy(sessions[i].lock); lock_dealloc((void*)sessions[i].lock); } shm_free(sessions); shm_free(session_id1); shm_free(session_id2); return 1; }
int dbt_init_cache(void) { int i, j; if(!_dbt_cachesem) { /* init locks */ _dbt_cachesem = lock_alloc(); if(!_dbt_cachesem) { LM_CRIT("could not alloc a lock\n"); return -1; } if (lock_init(_dbt_cachesem)==0) { LM_CRIT("could not initialize a lock\n"); lock_dealloc(_dbt_cachesem); return -1; } } /* init pointer to caches list */ if (!_dbt_cachedb) { _dbt_cachedb = shm_malloc( sizeof(dbt_cache_p) ); if (!_dbt_cachedb) { LM_CRIT("no enough shm mem\n"); lock_dealloc(_dbt_cachesem); return -1; } *_dbt_cachedb = NULL; } /* init tables' hash table */ if (!_dbt_cachetbl) { _dbt_cachetbl = (dbt_tbl_cachel_p)shm_malloc(DBT_CACHETBL_SIZE* sizeof(dbt_tbl_cachel_t)); if(_dbt_cachetbl==NULL) { LM_CRIT("no enough shm mem\n"); lock_dealloc(_dbt_cachesem); shm_free(_dbt_cachedb); return -1; } memset(_dbt_cachetbl, 0, DBT_CACHETBL_SIZE*sizeof(dbt_tbl_cachel_t)); for(i=0; i<DBT_CACHETBL_SIZE; i++) { if (lock_init(&_dbt_cachetbl[i].sem)==0) { LM_CRIT("cannot init tables' sem's\n"); for(j=i-1; j>=0; j--) lock_destroy(&_dbt_cachetbl[j].sem); lock_dealloc(_dbt_cachesem); shm_free(_dbt_cachedb); return -1; } } } return 0; }
void destroy_timer() { struct itimerval it; /* disable timer */ memset(&it, 0, sizeof(it)); setitimer(ITIMER_REAL, &it, 0); set_sig_h(SIGALRM, SIG_IGN); if (timer_lock){ lock_destroy(timer_lock); lock_dealloc(timer_lock); timer_lock=0; } if (ticks){ #ifdef SHM_MEM shm_free(ticks); #else pkg_free(ticks); #endif ticks=0; } if (timer_lst){ #ifdef SHM_MEM shm_free(timer_lst); #else pkg_free(timer_lst); #endif timer_lst=0; } if (running_timer){ shm_free((void*)running_timer); running_timer=0; } #ifdef USE_SLOW_TIMER if (slow_timer_lock){ lock_destroy(slow_timer_lock); lock_dealloc(slow_timer_lock); slow_timer_lock=0; } if (slow_timer_lists){ shm_free((void*)slow_timer_lists); slow_timer_lists=0; } if (t_idx){ shm_free((void*)t_idx); t_idx=0; } if (s_idx){ shm_free((void*)s_idx); s_idx=0; } if(running_timer2){ shm_free((void*)running_timer2); running_timer2=0; } #endif }
void free_info(cluster_info_t *cl_list) { cluster_info_t *tmp_cl; node_info_t *info, *tmp_info; struct local_cap *cl_cap, *tmp_cl_cap; struct remote_cap *cap, *tmp_cap; while (cl_list != NULL) { tmp_cl = cl_list; cl_list = cl_list->next; info = tmp_cl->node_list; while (info != NULL) { if (info->url.s) shm_free(info->url.s); if (info->sip_addr.s) shm_free(info->sip_addr.s); if (info->description.s) shm_free(info->description.s); if (info->lock) { lock_destroy(info->lock); lock_dealloc(info->lock); } cap = info->capabilities; while (cap != NULL) { tmp_cap = cap; cap = cap->next; shm_free(tmp_cap); } tmp_info = info; info = info->next; shm_free(tmp_info); } cl_cap = tmp_cl->capabilities; while (cl_cap != NULL) { tmp_cl_cap = cl_cap; cl_cap = cl_cap->next; shm_free(tmp_cl_cap); } if (tmp_cl->lock) { lock_destroy(tmp_cl->lock); lock_dealloc(tmp_cl->lock); } shm_free(tmp_cl); } }
/* free all resources used by insert buffering */ void destroy_query_list(void) { query_list_t *it; for (it=*query_list;it;it=it->next) { lock_destroy(it->lock); lock_dealloc(it->lock); shm_free(it); } lock_destroy(ql_lock); lock_dealloc(ql_lock); }
static void destroy(void) { struct secret *secret_struct; if (secret_list != NULL) { SECRET_UNLOCK; SECRET_LOCK; while (secret_list != NULL) { secret_struct = secret_list; secret_list = secret_struct->next; if (secret_struct->secret_key.s != NULL) { shm_free(secret_struct->secret_key.s); } shm_free(secret_struct); } SECRET_UNLOCK; } if (autheph_secret_lock != NULL) { lock_destroy(autheph_secret_lock); lock_dealloc((void *) autheph_secret_lock); } }
void sca_hash_table_free( sca_hash_table *ht ) { sca_hash_entry *e, *e_tmp; unsigned int i; if ( ht == NULL ) { return; } for ( i = 0; i < ht->size; i++ ) { if ( ht->slots[ i ].entries == NULL ) { continue; } sca_hash_table_lock_index( ht, i ); for ( e = ht->slots[ i ].entries; e != NULL; e = e_tmp ) { e_tmp = e->next; e->free_entry( e->value ); shm_free( e ); } sca_hash_table_unlock_index( ht, i ); lock_destroy( &ht->slots[ i ].lock ); lock_dealloc( &ht->slots[ i ].lock ); } shm_free( ht->slots ); shm_free( ht ); }
/** * Destroys the worker structures. */ void worker_destroy() { int i; // LOG(L_CRIT,"-1-\n"); /* lock_get(tasks->lock);*/ for(i=0;i<tasks->max;i++){ if (tasks->queue[i].msg) AAAFreeMessage(&(tasks->queue[i].msg)); } // LOG(L_CRIT,"-2-\n"); shm_free(tasks->queue); lock_destroy(tasks->lock); lock_dealloc((void*)tasks->lock); // LOG(L_CRIT,"-3-\n"); //lock_release(tasks->empty); semctl(tasks->empty, 0, IPC_RMID, cdp_semun_destroy); // LOG(L_CRIT,"-4-\n"); semctl(tasks->full, 0, IPC_RMID, cdp_semun_destroy); shm_free(tasks); while(callbacks->head) cb_remove(callbacks->head); shm_free(callbacks); }
int dbg_init_mypid(void) { if(_dbg_pid_list==NULL) return -1; if(process_no>=_dbg_pid_no) return -1; _dbg_pid_list[process_no].pid = (unsigned int)my_pid(); if(_dbg_breakpoint==1) _dbg_pid_list[process_no].set |= DBG_ABKPOINT_ON; if(_dbg_cfgtrace==1) _dbg_pid_list[process_no].set |= DBG_CFGTRACE_ON; if(_dbg_reset_msgid==1) { LM_DBG("[%d] create locks\n", process_no); _dbg_pid_list[process_no].lock = lock_alloc(); if(_dbg_pid_list[process_no].lock==NULL) { LM_ERR("cannot allocate the lock\n"); return -1; } if(lock_init(_dbg_pid_list[process_no].lock)==NULL) { LM_ERR("cannot init the lock\n"); lock_dealloc(_dbg_pid_list[process_no].lock); return -1; } } return 0; }
void free_cc_data(struct cc_data *data) { struct cc_flow *flow, *f_flow; struct cc_agent *agent,*f_agent; int i; if (data) { /* lock */ if (data->lock) { lock_destroy( data->lock ); lock_dealloc( data->lock ); } if (data->call_locks) { lock_set_destroy( data->call_locks ); lock_set_dealloc( data->call_locks ); } /* flows */ for( flow=data->flows ; flow ; ) { f_flow = flow; flow = flow->next; free_cc_flow( f_flow ); } /* agents */ for(i = 0; i< 2; i++) { for( agent=data->agents[i] ; agent ; ) { f_agent = agent; agent = agent->next; free_cc_agent( f_agent ); } } shm_free(data); } }
void destroy_async_lock(void) { if (xr_lock) { lock_destroy(xr_lock); lock_dealloc(xr_lock); } }
/* * destroy function */ static void destroy(void) { LM_DBG("start\n"); if(rls_table) { if(rls_db) rlsubs_table_update(0, 0); pres_destroy_shtable(rls_table, hash_size); } if(rls_db && rls_dbf.close) rls_dbf.close(rls_db); if(rlpres_db && rlpres_dbf.close) rlpres_dbf.close(rlpres_db); if(rls_xcap_db && rls_xcap_dbf.close) rls_xcap_dbf.close(rls_xcap_db); if (rls_update_subs_lock != NULL) { lock_destroy(rls_update_subs_lock); lock_dealloc(rls_update_subs_lock); } if (rls_notifier_id != NULL) shm_free(rls_notifier_id); }
void free_lb_data(struct lb_data *data) { struct lb_resource *lbr1, *lbr2; struct lb_dst *lbd1, *lbd2; if (data==NULL) return; /* free resources */ for( lbr1=data->resources ; lbr1 ; ) { lbr2 = lbr1; lbr1 = lbr1->next; if (lbr2->dst_bitmap) shm_free(lbr2->dst_bitmap); if (lbr2->lock) { lock_destroy( lbr2->lock ); lock_dealloc( lbr2->lock ); } shm_free(lbr2); } /* free destinations */ for( lbd1=data->dsts ; lbd1 ; ) { lbd2 = lbd1; lbd1 = lbd1->next; shm_free(lbd2); } shm_free(data); return; }
/*! * \brief Initialize the ro_session timer handler * Initialize the ro_session timer handler, allocate the lock and a global * timer in shared memory. The global timer handler will be set on success. * \param hdl ro_session timer handler * \return 0 on success, -1 on failure */ int init_ro_timer(ro_timer_handler hdl) { roi_timer = (struct ro_timer*) shm_malloc(sizeof (struct ro_timer)); if (roi_timer == 0) { LM_ERR("no more shm mem\n"); return -1; } memset(roi_timer, 0, sizeof (struct ro_timer)); roi_timer->first.next = roi_timer->first.prev = &(roi_timer->first); roi_timer->lock = lock_alloc(); if (roi_timer->lock == 0) { LM_ERR("failed to alloc lock\n"); goto error0; } if (lock_init(roi_timer->lock) == 0) { LM_ERR("failed to init lock\n"); goto error1; } timer_hdl = hdl; return 0; error1: lock_dealloc(roi_timer->lock); error0: shm_free(roi_timer); roi_timer = 0; return -1; }
static void free_shared_memory(void) { int i; if (pcres) { for(i=0; i<*num_pcres; i++) { if (pcres[i]) { shm_free(pcres[i]); } } shm_free(pcres); } if (num_pcres) { shm_free(num_pcres); } if (pcres_addr) { shm_free(pcres_addr); } if (reload_lock) { lock_destroy(reload_lock); lock_dealloc(reload_lock); } }
void destroy_black_lists(void) { unsigned int i; struct bl_rule *p, *q; if (no_shm) return; for(i = 0 ; i < used_heads ; i++){ if (blst_heads[i].lock) { lock_destroy(blst_heads[i].lock); lock_dealloc(blst_heads[i].lock); } for( p=blst_heads[i].first ; p ; ) { q = p; p = p->next; shm_free(q); } if (blst_heads[i].name.s) shm_free(blst_heads[i].name.s); blst_heads[i].first = blst_heads[i].last = NULL; } shm_free(blst_heads); }
void mohq_lock_destroy (mohq_lock *plock) { lock_destroy (plock->plock); lock_dealloc (plock->plock); return; }
void mod_destroy(void) { unsigned int i; if (rl_htable.maps) { for (i = 0; i < rl_htable.size; i++) map_destroy(rl_htable.maps[i], 0); shm_free(rl_htable.maps); rl_htable.maps = 0; rl_htable.size = 0; } if (rl_htable.locks) { lock_set_destroy(rl_htable.locks); lock_set_dealloc(rl_htable.locks); rl_htable.locks = 0; rl_htable.locks_no = 0; } if (rl_lock) { lock_destroy(rl_lock); lock_dealloc(rl_lock); } RL_SHM_FREE(rl_network_count); RL_SHM_FREE(rl_network_load); RL_SHM_FREE(rl_load_value); RL_SHM_FREE(pid_kp); RL_SHM_FREE(pid_ki); RL_SHM_FREE(pid_kd); RL_SHM_FREE(pid_setpoint); RL_SHM_FREE(drop_rate); RL_SHM_FREE(rl_feedback_limit); if (db_url.s && db_url.len) destroy_cachedb(); }
void destroy_dispatcher(dispatcher_t* disp) { lock_destroy(disp->lock); lock_dealloc(disp->lock); sem_destroy(&disp->sem); shm_free(disp); }
/* destroys the TCP data */ void tcp_destroy(void) { int part; if (tcp_parts[0].tcpconn_id_hash) /* force close/expire for all active tcpconns*/ __tcpconn_lifetime(1); if (connection_id){ shm_free(connection_id); connection_id=0; } for ( part=0 ; part<TCP_PARTITION_SIZE ; part++ ) { if (tcp_parts[part].tcpconn_id_hash){ shm_free(tcp_parts[part].tcpconn_id_hash); tcp_parts[part].tcpconn_id_hash=0; } if (tcp_parts[part].tcpconn_aliases_hash){ shm_free(tcp_parts[part].tcpconn_aliases_hash); tcp_parts[part].tcpconn_aliases_hash=0; } if (tcp_parts[part].tcpconn_lock){ lock_destroy(tcp_parts[part].tcpconn_lock); lock_dealloc((void*)tcp_parts[part].tcpconn_lock); tcp_parts[part].tcpconn_lock=0; } } }
int init_dlg_ping_timer(void) { ping_timer = (struct dlg_ping_timer*)shm_malloc(sizeof(struct dlg_timer)); if (ping_timer==0) { LM_ERR("no more shm mem\n"); return -1; } memset(ping_timer,0,sizeof(struct dlg_ping_timer)); ping_timer->lock = lock_alloc(); if (ping_timer->lock == 0) { LM_ERR("failed to alloc lock\n"); goto error0; } if (lock_init(ping_timer->lock) == 0) { LM_ERR("failed to init lock\n"); goto error1; } return 0; error1: lock_dealloc(ping_timer->lock); error0: shm_free(ping_timer); ping_timer=0; return -1; }
void free_saved_transaction_global_data(saved_transaction_t* data) { if (!data) return; lock_dealloc(data->lock); lock_destroy(data->lock); shm_free(data); }
static void destroy_shmlock(void) { if (lock) { lock_destroy(lock); lock_dealloc((void *)lock); lock = NULL; } }
static void destroy_shmlock(void) { if (conf_lock) { lock_destroy(conf_lock); lock_dealloc((void *)conf_lock); conf_lock = NULL; } }
void destroy_kill() { /* if disabled ... */ if (time_to_kill==0) return; lock_destroy(kill_lock); lock_dealloc(kill_lock); return; }
/** * Destroys the session related structures. */ int session_destroy() { lock_get(session_lock); lock_destroy(session_lock); lock_dealloc((void*)session_lock); shm_free(session_id1); shm_free(session_id2); return 1; }
void wsconn_destroy(void) { int h; if (wsconn_used_list) { shm_free(wsconn_used_list); wsconn_used_list = NULL; } if (wsconn_id_hash) { WSCONN_UNLOCK; WSCONN_LOCK; for (h = 0; h < TCP_ID_HASH_SIZE; h++) { ws_connection_t *wsc = wsconn_id_hash[h]; while (wsc) { ws_connection_t *next = wsc->id_next; _wsconn_rm(wsc); wsc = next; } } WSCONN_UNLOCK; shm_free(wsconn_id_hash); wsconn_id_hash = NULL; } if (wsconn_lock) { lock_destroy(wsconn_lock); lock_dealloc((void *) wsconn_lock); wsconn_lock = NULL; } if (wsstat_lock) { lock_destroy(wsstat_lock); lock_dealloc((void *) wsstat_lock); wsstat_lock = NULL; } }