void receive_dlg_binary_packet(int packet_type, struct receive_info *ri, void *att)
{
int rc;
char *ip;
unsigned short port;
int server_id;
rc = bin_pop_int(&server_id);
if (rc < 0)
return;
LM_DBG("Received a binary packet!\n");
if(get_bin_pkg_version() != BIN_VERSION){
LM_ERR("incompatible bin protocol version\n");
return;
}
if (!accept_replicated_dlg) {
get_su_info(&ri->src_su.s, ip, port);
LM_WARN("Unwanted dialog packet received from %s:%hu (type=%d)\n",
ip, port, packet_type);
return;
}
if(!clusterer_api.check(accept_replicated_dlg, &ri->src_su, server_id, ri->proto))
return;
switch (packet_type) {
case REPLICATION_DLG_CREATED:
LM_DBG("AAAA dlg_replicated_create\n");
rc = dlg_replicated_create(NULL, NULL, NULL, 1);
if_update_stat(dlg_enable_stats, create_recv, 1);
break;
case REPLICATION_DLG_UPDATED:
LM_DBG("AAAA dlg_replicated_update\n");
rc = dlg_replicated_update();
if_update_stat(dlg_enable_stats, update_recv, 1);
break;
case REPLICATION_DLG_DELETED:
LM_DBG("AAAA dlg_replicated_deleted\n");
rc = dlg_replicated_delete();
if_update_stat(dlg_enable_stats, delete_recv, 1);
break;
default:
rc = -1;
get_su_info(&ri->src_su.s, ip, port);
LM_WARN("Invalid dialog binary packet command: %d (from %s:%hu)\n",
packet_type, ip, port);
}
if (rc != 0)
LM_ERR("Failed to process a binary packet!\n");
}
/**
* receive_binary_packet (callback) - receives a cmd_type, specifying the
* purpose of the data encoded in the received UDP packet
*/
void receive_binary_packet(int packet_type, struct receive_info *ri)
{
int rc;
char *ip;
unsigned short port;
LM_DBG("Received a binary packet!\n");
if(get_bin_pkg_version() != BIN_VERSION){
LM_ERR("incompatible bin protocol version\n");
return;
}
if (accept_repl_profiles && packet_type == REPLICATION_DLG_PROFILE) {
/* TODO: handle this */
dlg_replicated_profiles(ri);
return;
}
if (!accept_replicated_dlg) {
get_su_info(&ri->src_su.s, ip, port);
LM_WARN("Unwanted dialog packet received from %s:%hu (type=%d)\n",
ip, port, packet_type);
return;
}
switch (packet_type) {
case REPLICATION_DLG_CREATED:
rc = dlg_replicated_create(NULL, NULL, NULL, 1);
if_update_stat(dlg_enable_stats, create_recv, 1);
break;
case REPLICATION_DLG_UPDATED:
rc = dlg_replicated_update();
if_update_stat(dlg_enable_stats, update_recv, 1);
break;
case REPLICATION_DLG_DELETED:
rc = dlg_replicated_delete();
if_update_stat(dlg_enable_stats, delete_recv, 1);
break;
default:
rc = -1;
get_su_info(&ri->src_su.s, ip, port);
LM_WARN("Invalid dialog binary packet command: %d (from %s:%hu)\n",
packet_type, ip, port);
}
if (rc != 0)
LM_ERR("Failed to process a binary packet!\n");
}
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);
}
}
void rl_rcv_bin(int packet_type, struct receive_info *ri)
{
rl_algo_t algo;
int limit;
int counter;
str name;
int index;
char *ip;
unsigned short port;
rl_pipe_t **pipe;
unsigned int hash_idx;
time_t now;
if(get_bin_pkg_version() != BIN_VERSION){
LM_ERR("incompatible bin protocol version\n");
return;
}
if (packet_type != RL_PIPE_COUNTER)
return;
/* match the server */
for (index = 0; index < rl_dests_nr; index++) {
if (su_cmp(&ri->src_su, &rl_dests[index].to))
break;
}
if (index == rl_dests_nr) {
get_su_info(&ri->src_su.s, ip, port);
LM_WARN("received bin packet from unknown source: %s:%hu\n",
ip, port);
return;
}
now = time(0);
*rl_dests[index].last_msg = now;
for (;;) {
if (bin_pop_str(&name) == 1)
break; /* pop'ed all pipes */
if (bin_pop_int(&algo) < 0) {
LM_ERR("cannot pop pipe's algorithm\n");
return;
}
if (bin_pop_int(&limit) < 0) {
LM_ERR("cannot pop pipe's limit\n");
return;
}
if (bin_pop_int(&counter) < 0) {
LM_ERR("cannot pop pipe's counter\n");
return;
}
hash_idx = RL_GET_INDEX(name);
RL_GET_LOCK(hash_idx);
/* try to get the value */
pipe = RL_GET_PIPE(hash_idx, name);
if (!pipe) {
LM_ERR("cannot get the index\n");
goto release;
}
if (!*pipe) {
/* if the pipe does not exist, alocate it in case we need it later */
*pipe = shm_malloc(sizeof(rl_pipe_t) +
rl_dests_nr * sizeof(rl_repl_counter_t));
if (!*pipe) {
LM_ERR("no more shm memory\n");
goto release;
}
memset(*pipe, 0, sizeof(rl_pipe_t) +
rl_dests_nr * sizeof(rl_repl_counter_t));
(*pipe)->dsts = (rl_repl_counter_t *)((*pipe) + 1);
LM_DBG("Pipe %.*s doesn't exist, but was created %p\n",
name.len, name.s, *pipe);
(*pipe)->algo = algo;
(*pipe)->limit = limit;
} else {
LM_DBG("Pipe %.*s found: %p - last used %lu\n",
name.len, name.s, *pipe, (*pipe)->last_used);
if ((*pipe)->algo != algo)
LM_WARN("algorithm %d different from the initial one %d for "
"pipe %.*s", algo, (*pipe)->algo, name.len, name.s);
if ((*pipe)->limit != limit)
LM_WARN("limit %d different from the initial one %d for "
"pipe %.*s", limit, (*pipe)->limit, name.len, name.s);
}
/* set the last used time */
(*pipe)->last_used = time(0);
/* set the destination's counter */
(*pipe)->dsts[index].counter = counter;
(*pipe)->dsts[index].update = now;
RL_RELEASE_LOCK(hash_idx);
}
return;
release:
RL_RELEASE_LOCK(hash_idx);
}
void rl_rcv_bin(int packet_type, struct receive_info *ri, int server_id)
{
rl_algo_t algo;
int limit;
int counter;
str name;
char *ip;
unsigned short port;
rl_pipe_t **pipe;
unsigned int hash_idx;
time_t now;
rl_repl_counter_t *destination;
if (packet_type == SERVER_TEMP_DISABLED) {
get_su_info(&ri->src_su.s, ip, port);
LM_WARN("server: %s:%hu temporary disabled\n", ip, port);
return;
}
if (packet_type == SERVER_TIMEOUT) {
LM_WARN("server with clustererer id %d timeout\n", server_id);
return;
}
if(get_bin_pkg_version() != BIN_VERSION){
LM_ERR("incompatible bin protocol version\n");
return;
}
if (packet_type != RL_PIPE_COUNTER)
return;
if (packet_type != RL_PIPE_COUNTER)
return;
now = time(0);
for (;;) {
if (bin_pop_str(&name) == 1)
break; /* pop'ed all pipes */
if (bin_pop_int(&algo) < 0) {
LM_ERR("cannot pop pipe's algorithm\n");
return;
}
if (bin_pop_int(&limit) < 0) {
LM_ERR("cannot pop pipe's limit\n");
return;
}
if (bin_pop_int(&counter) < 0) {
LM_ERR("cannot pop pipe's counter\n");
return;
}
hash_idx = RL_GET_INDEX(name);
RL_GET_LOCK(hash_idx);
/* try to get the value */
pipe = RL_GET_PIPE(hash_idx, name);
if (!pipe) {
LM_ERR("cannot get the index\n");
goto release;
}
if (!*pipe) {
/* if the pipe does not exist, alocate it in case we need it later */
*pipe = shm_malloc(sizeof(rl_pipe_t));
if (!*pipe) {
LM_ERR("no more shm memory\n");
goto release;
}
memset(*pipe, 0, sizeof(rl_pipe_t));
LM_DBG("Pipe %.*s doesn't exist, but was created %p\n",
name.len, name.s, *pipe);
(*pipe)->algo = algo;
(*pipe)->limit = limit;
} else {
LM_DBG("Pipe %.*s found: %p - last used %lu\n",
name.len, name.s, *pipe, (*pipe)->last_used);
if ((*pipe)->algo != algo)
LM_WARN("algorithm %d different from the initial one %d for "
"pipe %.*s", algo, (*pipe)->algo, name.len, name.s);
if ((*pipe)->limit != limit)
LM_WARN("limit %d different from the initial one %d for "
"pipe %.*s", limit, (*pipe)->limit, name.len, name.s);
}
/* set the last used time */
(*pipe)->last_used = time(0);
/* set the destination's counter */
destination = find_destination(*pipe, server_id);
destination->counter = counter;
destination->update = now;
RL_RELEASE_LOCK(hash_idx);
}
return;
release:
RL_RELEASE_LOCK(hash_idx);
}
