/* FOR DEBUG PURPOSES */
void list_hash(dpl_id_t * hash, rw_lock_t * ref_lock)
{
dpl_id_p crt_idp;
dpl_node_p rulep;
int i;
if(!hash)
return;
/* lock the data for reading */
lock_start_read( ref_lock );
for(crt_idp = hash; crt_idp; crt_idp = crt_idp->next) {
LM_DBG("DPID: %i, pointer %p\n", crt_idp->dp_id, crt_idp);
for (i = 0; i <= DP_INDEX_HASH_SIZE; i++) {
LM_DBG("BUCKET %d rules:\n", i);
for(rulep = crt_idp->rule_hash[i].first_rule; rulep;
rulep = rulep->next) {
list_rule(rulep);
}
}
}
/* we are done reading -> unref the data */
lock_stop_read( ref_lock );
}
/* get provider pointer from emergency service provider table
* get 3 types of provider, depend on its attribution:
* 0 - source provider
* 1 - VPC provider
* 2 - vsp provider
*/
struct service_provider* get_provider(struct sip_msg *msg, int attr, rw_lock_t *ref_lock ) {
int vsp_addr_len;
char *vsp_addr;
lock_start_read(ref_lock);
struct service_provider* provider = *db_service_provider;
while (provider != NULL) {
LM_DBG("***attr:%d\n ", provider->attribution);
if (provider->attribution == attr ){
if (provider->attribution == 2){
// search ip source
vsp_addr = ip_addr2a(&msg->rcv.src_ip);
vsp_addr_len = strlen(vsp_addr);
if ( (provider->nodeIP.len == vsp_addr_len) && (strncmp(vsp_addr, provider->nodeIP.s, vsp_addr_len) == 0)) {
LM_DBG(" FOUND IP SOURCE\n ");
lock_stop_read(ref_lock);
return provider;
}
}else{
lock_stop_read(ref_lock);
return provider;
}
}
provider = provider->next;
}
lock_stop_read(ref_lock);
return NULL;
}
int lb_update_from_replication( unsigned int group, str *uri,
unsigned int flags)
{
struct lb_dst *dst;
lock_start_read( ref_lock );
for( dst=(*curr_data)->dsts; dst; dst=dst->next ) {
if ( (dst->group == group) &&
(strncmp(dst->uri.s, uri->s, dst->uri.len) == 0)) {
if ((dst->flags&LB_DST_STAT_MASK) != flags) {
/* import the status flags */
dst->flags = ((~LB_DST_STAT_MASK)&dst->flags)|
(LB_DST_STAT_MASK&flags);
/* raise event of status change */
lb_raise_event(dst);
lock_stop_read( ref_lock );
return 0;
}
}
}
lock_stop_read( ref_lock );
return -1;
}
/*FOR DEBUG PURPOSE*/
void list_hash(int h_index)
{
dpl_id_p crt_idp;
dpl_index_p indexp;
dpl_node_p rulep;
/* lock the data for reading */
lock_start_read( ref_lock );
if(!rules_hash[h_index])
goto done;
for(crt_idp=rules_hash[h_index]; crt_idp!=NULL; crt_idp = crt_idp->next){
LM_DBG("DPID: %i, pointer %p\n", crt_idp->dp_id, crt_idp);
for(indexp=crt_idp->first_index; indexp!=NULL;indexp= indexp->next){
LM_DBG("INDEX LEN: %i\n", indexp->len);
for(rulep = indexp->first_rule; rulep!= NULL;rulep = rulep->next){
list_rule(rulep);
}
}
}
done:
/* we are done reading -> unref the data */
lock_stop_read( ref_lock );
}
/* retreives esgwrifrom the list db_esrn_esgwri
* using srid(selectiveRoutingID), resn(routingESN) and npa.
*/
int emergency_routing(char *srid, int resn, int npa, char** esgwri, rw_lock_t *ref_lock ) {
lock_start_read(ref_lock);
struct esrn_routing* esrn_domain = *db_esrn_esgwri;
LM_DBG("SRID = %s \n", srid);
while (esrn_domain != NULL) {
LM_DBG("CMP SRID= %.*s \n", esrn_domain->srid.len, esrn_domain->srid.s);
LM_DBG("CMP RESN= %d \n", esrn_domain->resn);
LM_DBG("CMP NPA = %d \n", esrn_domain->npa);
if (strncmp(esrn_domain->srid.s, srid, esrn_domain->srid.len) == 0) {
if ((esrn_domain->resn == resn)&&(esrn_domain->npa == npa)) {
char* temp = pkg_malloc(sizeof (char) * esrn_domain->esgwri.len + 1);
if (!temp) {
LM_ERR("no more memory\n");
lock_stop_read(ref_lock);
return -1;
}
memcpy(temp, esrn_domain->esgwri.s, esrn_domain->esgwri.len);
temp[esrn_domain->esgwri.len] = 0;
*esgwri = temp;
lock_stop_read(ref_lock);
return 1;
}
}
esrn_domain = esrn_domain->next;
}
lock_stop_read(ref_lock);
return -1;
}
clusterer_node_t* get_clusterer_nodes(int cluster_id)
{
clusterer_node_t *ret_nodes = NULL;
node_info_t *node;
cluster_info_t *cl;
lock_start_read(cl_list_lock);
cl = get_cluster_by_id(cluster_id);
if (!cl) {
LM_ERR("cluster id: %d not found!\n", cluster_id);
lock_stop_read(cl_list_lock);
return NULL;
}
for (node = cl->node_list; node; node = node->next)
if (get_next_hop(node) > 0)
if (add_clusterer_node(&ret_nodes, node) < 0) {
lock_stop_read(cl_list_lock);
LM_ERR("Unable to add node: %d to the returned list of reachable nodes\n",
node->node_id);
free_clusterer_nodes(ret_nodes);
return NULL;
}
lock_stop_read(cl_list_lock);
return ret_nodes;
}
/* lists all domains */
static struct mi_root * tls_list(struct mi_root *cmd_tree, void *param)
{
struct mi_node *root = NULL;
struct mi_root *rpl_tree = NULL;
rpl_tree = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if (rpl_tree == NULL) {
return NULL;
}
if (dom_lock)
lock_start_read(dom_lock);
root = &rpl_tree->node;
if (list_domain(root, tls_client_domains) < 0)
goto error;
if (list_domain(root, tls_server_domains) < 0)
goto error;
if (dom_lock)
lock_stop_read(dom_lock);
return rpl_tree;
error:
if (dom_lock)
lock_stop_read(dom_lock);
if (rpl_tree) free_mi_tree(rpl_tree);
return NULL;
}
void set_dst_state_from_rplcode( int id, int code)
{
struct lb_dst *dst;
lock_start_read( ref_lock );
for( dst=(*curr_data)->dsts ; dst && dst->id!=id ; dst=dst->next);
if (dst==NULL) {
lock_stop_read( ref_lock );
return;
}
if ((code == 200) || check_options_rplcode(code)) {
/* re-enable to DST (if allowed) */
if ( dst->flags&LB_DST_STAT_NOEN_FLAG ) {
lock_stop_read( ref_lock );
return;
}
dst->flags &= ~LB_DST_STAT_DSBL_FLAG;
lock_stop_read( ref_lock );
return;
}
if (code>=400) {
dst->flags |= LB_DST_STAT_DSBL_FLAG;
}
lock_stop_read( ref_lock );
}
static void lb_prob_handler(unsigned int ticks, void* param)
{
lock_start_read( ref_lock );
/* do probing */
lb_do_probing(*curr_data);
lock_stop_read( ref_lock );
}
static struct mi_root* mi_lb_resize(struct mi_root *cmd, void *param)
{
struct mi_root *rpl_tree;
struct lb_dst *dst;
struct mi_node *node;
unsigned int id, size;
str *name;
int n;
for( n=0,node = cmd->node.kids; n<3 && node ; n++,node=node->next );
if (n!=3 || node!=0)
return init_mi_tree( 400, MI_MISSING_PARM_S, MI_MISSING_PARM_LEN);
node = cmd->node.kids;
/* id (param 1) */
if (str2int( &node->value, &id) < 0)
goto bad_syntax;
/* resource (param 2) */
node = node->next;
name = &node->value;
/* id (param 3) */
node = node->next;
if (str2int( &node->value, &size) < 0)
goto bad_syntax;
lock_start_read( ref_lock );
/* get destination */
for( dst=(*curr_data)->dsts ; dst && dst->id!=id ; dst=dst->next);
if (dst==NULL) {
rpl_tree = init_mi_tree( 404, MI_SSTR("Destination ID not found"));
} else {
/* get resource */
for( n=0 ; n<dst->rmap_no ; n++)
if (dst->rmap[n].resource->name.len == name->len &&
memcmp( dst->rmap[n].resource->name.s, name->s, name->len)==0)
break;
if (n==dst->rmap_no) {
rpl_tree = init_mi_tree( 404,
MI_SSTR("Destination has no such resource"));
} else {
dst->rmap[n].max_load = size;
rpl_tree = init_mi_tree( 200, MI_SSTR(MI_OK_S));
}
}
lock_stop_read( ref_lock );
return rpl_tree;
bad_syntax:
return init_mi_tree( 400, MI_SSTR(MI_BAD_PARM_S));
}
/*! \brief
* Timer handler
*/
static void timer(unsigned int ticks, void* param)
{
if (sync_lock)
lock_start_read(sync_lock);
if (synchronize_all_udomains() != 0) {
LM_ERR("synchronizing cache failed\n");
}
if (sync_lock)
lock_stop_read(sync_lock);
}
static int w_load_balance(struct sip_msg *req, char *grp, char *rl, char *al)
{
int ret;
int grp_no;
struct lb_grp_param *lbgp = (struct lb_grp_param *)grp;
pv_value_t val;
struct lb_res_str_list *lb_rl;
struct lb_res_parse *lbp;
pv_elem_t *model;
str dest;
if (lbgp->grp_pv) {
if (pv_get_spec_value( req, (pv_spec_p)lbgp->grp_pv, &val)!=0) {
LM_ERR("failed to get PV value\n");
return -1;
}
if ( (val.flags&PV_VAL_INT)==0 ) {
LM_ERR("PV vals is not integer\n");
return -1;
}
grp_no = val.ri;
} else {
grp_no = lbgp->grp_no;
}
lbp = (struct lb_res_parse *)rl;
if (lbp->type & RES_ELEM) {
model = (pv_elem_p)lbp->param;
if (pv_printf_s(req, model, &dest) || dest.len <= 0) {
LM_ERR("cannot create resource string\n");
return -1;
}
lb_rl = parse_resources_list(dest.s, 0);
if (!lb_rl) {
LM_ERR("cannot create resource list\n");
return -1;
}
} else
lb_rl = (struct lb_res_str_list *)lbp->param;
lock_start_read( ref_lock );
/* do lb */
ret = do_load_balance(req, grp_no, lb_rl,
(unsigned int)(long)al, *curr_data);
lock_stop_read( ref_lock );
if (lbp->type & RES_ELEM)
pkg_free(lb_rl);
if (ret<0)
return ret;
return 1;
}
/*
* find client domain
* return 0 if virtual domain not found
*/
struct tls_domain *tls_find_client_domain(struct ip_addr *ip, unsigned short port)
{
struct tls_domain *dom;
struct usr_avp *avp;
int_str val;
avp = NULL;
if (tls_client_domain_avp > 0)
avp = search_first_avp(0, tls_client_domain_avp, &val, 0);
else
LM_DBG("name based TLS client domain matching is disabled\n");
if (dom_lock)
lock_start_read(dom_lock);
if (!avp) {
LM_DBG("no TLS client domain AVP set, looking "
"to match TLS client domain by scoket\n");
dom = tls_find_client_domain_addr(ip, port);
if (dom) {
LM_DBG("found TLS client domain [%s:%d] based on socket\n",
ip_addr2a(&dom->addr), dom->port);
}
} else {
LM_DBG("TLS client domain AVP found = '%.*s'\n",
val.s.len, ZSW(val.s.s));
dom = tls_find_client_domain_name(val.s);
if (dom) {
LM_DBG("found TLS client domain '%.*s' by name\n",
val.s.len, ZSW(val.s.s));
} else {
LM_DBG("TLS client domain not found by name, "
"trying socket based TLS client domain matching\n");
dom = tls_find_client_domain_addr(ip, port);
if (dom) {
LM_DBG("found TLS client domain [%s:%d] based on socket\n",
ip_addr2a(&dom->addr), dom->port);
}
}
}
if (dom && dom->type & TLS_DOMAIN_DB) {
lock_get(dom->lock);
dom->refs++;
lock_release(dom->lock);
}
if (dom_lock)
lock_stop_read(dom_lock);
return dom;
}
static int w_lb_is_dst2(struct sip_msg *msg, char *ip, char *port)
{
int ret;
lock_start_read( ref_lock );
ret = lb_is_dst(*curr_data, msg, (pv_spec_t*)ip, (gparam_t*)port, -1, 0);
lock_stop_read( ref_lock );
if (ret<0)
return ret;
return 1;
}
static struct mi_root * clusterer_list_cap(struct mi_root *cmd_tree, void *param)
{
cluster_info_t *cl;
struct local_cap *cap;
struct mi_root *rpl_tree = NULL;
struct mi_node *node = NULL;
struct mi_node *node_s = NULL;
struct mi_attr* attr;
str val;
static str str_ok = str_init("Ok");
static str str_not_synced = str_init("not synced");
rpl_tree = init_mi_tree(200, MI_OK_S, MI_OK_LEN);
if (!rpl_tree)
return NULL;
rpl_tree->node.flags |= MI_IS_ARRAY;
lock_start_read(cl_list_lock);
for (cl = *cluster_list; cl; cl = cl->next) {
val.s = int2str(cl->cluster_id, &val.len);
node = add_mi_node_child(&rpl_tree->node, MI_DUP_VALUE|MI_IS_ARRAY,
MI_SSTR("Cluster"), val.s, val.len);
if (!node) goto error;
for (cap = cl->capabilities; cap; cap = cap->next) {
val.s = cap->reg.name.s;
val.len = cap->reg.name.len;
node_s = add_mi_node_child(node, MI_DUP_VALUE|MI_IS_ARRAY,
MI_SSTR("Capability"), val.s, val.len);
if (!node_s) goto error;
lock_get(cl->lock);
val.s = int2str((cap->flags & CAP_STATE_OK) ? 1 : 0, &val.len);
lock_release(cl->lock);
attr = add_mi_attr(node_s, MI_DUP_VALUE, MI_SSTR("State"),
(cap->flags & CAP_STATE_OK) ? str_ok.s : str_not_synced.s,
(cap->flags & CAP_STATE_OK) ? str_ok.len : str_not_synced.len);
if (!attr) goto error;
}
}
lock_stop_read(cl_list_lock);
return rpl_tree;
error:
lock_stop_read(cl_list_lock);
if (rpl_tree) free_mi_tree(rpl_tree);
return NULL;
}
static int w_lb_disable_dst(struct sip_msg *req)
{
int ret;
lock_start_read(ref_lock);
/* do lb */
ret = do_lb_disable_dst(req, *curr_data, lb_prob_verbose);
lock_stop_read(ref_lock);
if( ret < 0 )
return ret;
return 1;
}
static int w_lb_reset(struct sip_msg *req)
{
int ret;
lock_start_read(ref_lock);
/* do lb */
ret = do_lb_reset(req, *curr_data);
lock_stop_read(ref_lock);
if( ret < 0 )
return ret;
return 1;
}
static int send_to(int cluster_id, int proto)
{
table_entry_value_t *value;
str send_buffer;
unsigned long ctime = time(0);
int ok = -1;
if (proto == PROTO_BIN)
bin_get_buffer(&send_buffer);
lock_start_read(ref_lock);
value = clusterer_find_nodes(cluster_id, proto);
for (; value; value = value->next) {
ok = 0;
if (value->state == 1) {
if (value->prev_no_tries != -1 &&
value->no_tries > 0 &&
value->prev_no_tries == value->no_tries) {
value->no_tries = 0;
}
value->prev_no_tries = value->no_tries;
}
if (value->state == 2) {
if ((ctime - value->last_attempt) >= value->duration) {
value->last_attempt = ctime;
value->state = 1;
value->no_tries = 0;
}
}
if (value->state == 1) {
if (proto == PROTO_BIN) {
if (msg_send(NULL, PROTO_BIN, &value->addr, 0,
send_buffer.s, send_buffer.len, 0) != 0) {
LM_ERR("cannot send message\n");
temp_disable_machine(value);
}
}
}
}
lock_stop_read(ref_lock);
return ok;
}
void receive_lb_binary_packet(bin_packet_t *packet)
{
LM_DBG("received a binary packet [%d]!\n", packet->type);
if(get_bin_pkg_version(packet) != BIN_VERSION) {
LM_ERR("incompatible bin protocol version\n");
return;
}
if (packet->type == REPL_LB_STATUS_UPDATE) {
lock_start_read(ref_lock);
replicate_lb_status_update(packet, *curr_data);
lock_stop_read(ref_lock);
} else {
LM_ERR("invalid load_balancer binary packet type: %d\n", packet->type);
}
}
static void lb_update_max_loads(unsigned int ticks, void *param)
{
struct lb_dst *dst;
int ri, old, psz;
LM_DBG("updating max loads...\n");
lock_start_write(ref_lock);
for (dst = (*curr_data)->dsts; dst; dst = dst->next) {
if (!dst->fs_sock)
continue;
lock_start_read(dst->fs_sock->stats_lk);
for (ri = 0; ri < dst->rmap_no; ri++) {
if (dst->rmap[ri].fs_enabled) {
psz = lb_dlg_binds.get_profile_size(
dst->rmap[ri].resource->profile, &dst->profile_id);
old = dst->rmap[ri].max_load;
/*
* The normal case. OpenSIPS sees, at _most_, the same number
* of sessions as FreeSWITCH does. Any differences must be
* subtracted from the remote "max sessions" value
*/
if (psz < dst->fs_sock->stats.max_sess) {
dst->rmap[ri].max_load =
(dst->fs_sock->stats.id_cpu / (float)100) *
(dst->fs_sock->stats.max_sess -
(dst->fs_sock->stats.sess - psz));
} else {
dst->rmap[ri].max_load =
(dst->fs_sock->stats.id_cpu / (float)100) *
dst->fs_sock->stats.max_sess;
}
LM_DBG("load update on FS (%p) %s:%d: "
"%d -> %d (%d %d %.3f), prof=%d\n",
dst->fs_sock, dst->fs_sock->host.s, dst->fs_sock->port,
old, dst->rmap[ri].max_load, dst->fs_sock->stats.sess,
dst->fs_sock->stats.max_sess,
dst->fs_sock->stats.id_cpu, psz);
}
}
lock_stop_read(dst->fs_sock->stats_lk);
}
lock_stop_write(ref_lock);
}
int cl_get_my_index(int cluster_id, str *capability, int *nr_nodes)
{
int i, j, tmp;
int sorted[MAX_NO_NODES];
node_info_t *node;
cluster_info_t *cl;
struct remote_cap *cap;
lock_start_read(cl_list_lock);
cl = get_cluster_by_id(cluster_id);
if (!cl) {
LM_ERR("cluster id: %d not found!\n", cluster_id);
lock_stop_read(cl_list_lock);
return -1;
}
*nr_nodes = 0;
for (node = cl->node_list; node; node = node->next)
if (get_next_hop(node) > 0) {
lock_get(node->lock);
for (cap = node->capabilities; cap; cap = cap->next)
if (!str_strcmp(capability, &cap->name))
break;
if (cap && cap->flags & CAP_STATE_OK)
sorted[(*nr_nodes)++] = node->node_id;
lock_release(node->lock);
}
lock_stop_read(cl_list_lock);
/* sort array of reachable node ids */
for (i = 1; i < *nr_nodes; i++) {
tmp = sorted[i];
for (j = i - 1; j >= 0 && sorted[j] > tmp; j = j - 1)
sorted[j+1] = sorted[j];
sorted[j+1] = tmp;
}
for (i = 0; i < *nr_nodes && sorted[i] < current_id; i++) ;
(*nr_nodes)++;
return i;
}
static clusterer_node_t* get_nodes(int cluster_id, int proto)
{
clusterer_node_t* tmp;
clusterer_node_t* nodes = NULL;
table_entry_value_t* head;
unsigned long ctime = time(0);
lock_start_read(ref_lock);
head = clusterer_find_nodes(cluster_id, proto);
for (; head; head = head->next) {
if (head->state == 1) {
if (head->prev_no_tries != -1 &&
head->no_tries > 0 &&
head->prev_no_tries == head->no_tries) {
head->no_tries = 0;
}
head->prev_no_tries = head->no_tries;
}
if (head->state == 2) {
if ((ctime - head->last_attempt) >= head->duration) {
head->last_attempt = ctime;
head->state = 1;
head->no_tries = 0;
}
}
if (head->state == 1 && add_node(&nodes, head, proto) < 0) {
goto error;
}
}
lock_stop_read(ref_lock);
return nodes;
error:
lock_stop_read(ref_lock);
while (nodes) {
tmp = nodes;
nodes = nodes->next;
free_node(tmp);
}
return NULL;
}
void set_dst_state_from_rplcode( int id, int code)
{
struct lb_dst *dst;
int old_flags;
lock_start_read( ref_lock );
for( dst=(*curr_data)->dsts ; dst && dst->id!=id ; dst=dst->next);
if (dst==NULL) {
lock_stop_read( ref_lock );
return;
}
if ((code == 200) || check_options_rplcode(code)) {
/* re-enable to DST (if allowed) */
if ( dst->flags&LB_DST_STAT_NOEN_FLAG ) {
lock_stop_read( ref_lock );
return;
}
old_flags = dst->flags;
dst->flags &= ~LB_DST_STAT_DSBL_FLAG;
if (dst->flags != old_flags) {
lb_status_changed(dst);
if (lb_prob_verbose)
LM_INFO("re-enable destination %d <%.*s> after %d reply "
"on probe\n", dst->id, dst->uri.len, dst->uri.s, code);
}
lock_stop_read( ref_lock );
return;
}
if (code>=400) {
old_flags = dst->flags;
dst->flags |= LB_DST_STAT_DSBL_FLAG;
if (dst->flags != old_flags) {
lb_status_changed(dst);
if (lb_prob_verbose)
LM_INFO("disable destination %d <%.*s> after %d reply "
"on probe\n", dst->id, dst->uri.len, dst->uri.s, code);
}
}
lock_stop_read( ref_lock );
}
int clusterer_check(int cluster_id, union sockaddr_union* su, int machine_id, int proto)
{
int rc = 0;
table_entry_value_t *head;
lock_start_read(ref_lock);
head = clusterer_find_nodes(cluster_id, proto);
for (; head; head = head->next) {
if (su_ip_cmp(su, &head->addr) && head->machine_id == machine_id) {
rc = 1;
break;
}
}
lock_stop_read(ref_lock);
return rc;
}
clusterer_node_t *api_get_next_hop(int cluster_id, int node_id)
{
clusterer_node_t *ret = NULL;
node_info_t *dest_node;
cluster_info_t *cluster;
int rc;
lock_start_read(cl_list_lock);
cluster = get_cluster_by_id(cluster_id);
if (!cluster) {
LM_DBG("Cluster id: %d not found!\n", cluster_id);
return NULL;
}
dest_node = get_node_by_id(cluster, node_id);
if (!dest_node) {
LM_DBG("Node id: %d no found!\n", node_id);
return NULL;
}
rc = get_next_hop(dest_node);
if (rc < 0)
return NULL;
else if (rc == 0) {
LM_DBG("No other path to node: %d\n", node_id);
return NULL;
}
lock_get(dest_node->lock);
if (add_clusterer_node(&ret, dest_node->next_hop) < 0) {
LM_ERR("Failed to allocate next hop\n");
return NULL;
}
lock_release(dest_node->lock);
lock_stop_read(cl_list_lock);
return ret;
}
static int w_lb_is_dst4(struct sip_msg *msg,char *ip,char *port,char *grp,
char *active)
{
int ret, group;
if (fixup_get_ivalue(msg, (gparam_p)grp, &group) != 0) {
LM_ERR("Invalid lb group pseudo variable!\n");
return -1;
}
lock_start_read( ref_lock );
ret = lb_is_dst(*curr_data, msg, (pv_spec_t*)ip, (gparam_t*)port,
group, active ? (int)*(unsigned int *)active : 0);
lock_stop_read( ref_lock );
if (ret<0)
return ret;
return 1;
}
int cl_get_my_sip_addr(int cluster_id, str *out_addr)
{
cluster_info_t *cl;
int rc;
if (!cl_list_lock) {
LM_ERR("cluster shutdown\n");
memset(out_addr, 0, sizeof *out_addr);
return -1;
}
lock_start_read(cl_list_lock);
cl = get_cluster_by_id(cluster_id);
if (!cl) {
LM_ERR("unknown cluster id: %d\n", cluster_id);
lock_stop_read(cl_list_lock);
memset(out_addr, 0, sizeof *out_addr);
return -1;
}
lock_get(cl->current_node->lock);
if (ZSTR(cl->current_node->sip_addr)) {
memset(out_addr, 0, sizeof *out_addr);
rc = 0;
} else {
if (pkg_str_dup(out_addr, &cl->current_node->sip_addr) != 0) {
LM_ERR("oom\n");
memset(out_addr, 0, sizeof *out_addr);
rc = -1;
} else {
rc = 0;
}
}
lock_release(cl->current_node->lock);
lock_stop_read(cl_list_lock);
return rc;
}
struct mi_root *mi_list_sharing_tags(struct mi_root *cmd_tree, void *param)
{
struct mi_root *rpl_tree= NULL;
struct mi_node *node, *rpl = NULL;
struct mi_attr *attr;
struct dlg_sharing_tag *tag;
str val;
if (!dialog_repl_cluster)
return init_mi_tree(400, MI_SSTR("Dialog replication disabled"));
rpl_tree = init_mi_tree(200, MI_SSTR(MI_OK));
if (rpl_tree==0)
return NULL;
rpl = &rpl_tree->node;
rpl->flags |= MI_IS_ARRAY;
lock_start_read(shtags_lock);
for (tag = *shtags_list; tag; tag = tag->next) {
node = add_mi_node_child(rpl, MI_DUP_VALUE,
MI_SSTR("Tag"), tag->name.s, tag->name.len);
if (!node) goto error;
val.s = int2str(tag->state, &val.len);
attr = add_mi_attr(node, MI_DUP_VALUE,
MI_SSTR("State"), val.s, val.len);
if (!attr) goto error;
}
lock_stop_read(shtags_lock);
return rpl_tree;
error:
lock_stop_read(shtags_lock);
if (rpl_tree) free_mi_tree(rpl_tree);
return NULL;
}
/*
* find server domain with given ip and port
* return default domain if virtual domain not found
*/
struct tls_domain *
tls_find_server_domain(struct ip_addr *ip, unsigned short port)
{
struct tls_domain *p;
if (dom_lock)
lock_start_read(dom_lock);
p = *tls_server_domains;
while (p) {
if ((p->port == port) && ip_addr_cmp(&p->addr, ip)) {
LM_DBG("virtual TLS server domain found\n");
if (p->type & TLS_DOMAIN_DB) {
lock_get(p->lock);
p->refs++;
lock_release(p->lock);
if (dom_lock)
lock_stop_read(dom_lock);
}
return p;
}
p = p->next;
}
lock_get((*tls_default_server_domain)->lock);
(*tls_default_server_domain)->refs++;
lock_release((*tls_default_server_domain)->lock);
if (dom_lock)
lock_stop_read(dom_lock);
LM_DBG("virtual TLS server domain not found, "
"Using default TLS server domain settings\n");
return *tls_default_server_domain;
}
/*! \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();
}
