gfwleak/tango-tsg-service-chaining-engine
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🐞 fix(TSG-14138): 修复页面修改IP后，功能端未修改

Browse Source
This commit is contained in:
wangmenglan
2023-03-14 14:15:29 +08:00
parent 8d820e3213
commit 29ba315489
5 changed files with 242 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
platform/src/health_check.cpp
View File

@@ -26,26 +26,44 @@
struct session_table
{
// rwlock ???;
// handler;
struct session_iterm *root_by_id;
pthread_rwlock_t rwlock;
};
static struct session_table g_handle;
static struct sf_status *g_sf_status = NULL;
struct session_iterm
{
int session_id; // key
uint64_t session_id; // key
struct health_check policy; // value1: deep copy
int is_active; // value2
uint8_t mac[HC_MAC_LEN]; // value3
struct health_check policy; // value1: deep copy
int is_active; // value2
int profile_id; // value3
uint8_t mac[HC_MAC_LEN]; // value4
UT_hash_handle hh1; /* handle for first hash table */
};
struct session_table_addr
{
// handler;
struct node_addr *htable;
};
struct node_addr
{
char address[64]; // key
uint64_t session_id; // session id
int ref_cnt; // reference
UT_hash_handle hh; /* handle for first hash table */
};
static uint64_t g_session_id;
static struct session_table g_handle;
static struct session_table_addr g_handle_addr;
static struct sf_status *g_sf_status = NULL;
int sleep_ms = 300;
char path[BFD_PATHLEN];
char hc_dev_name[HC_DEV_NAME_LEN];
@@ -56,7 +74,18 @@ uint8_t default_gw_mac[HC_MAC_LEN];
static int get_mac_by_addr(char *addr, uint8_t *buf);
static int health_check_session_foreach();
static struct session_iterm *health_check_get_iterm_by_id(int session_id)
static void health_check_ref_inc(struct node_addr *node)
{
node->ref_cnt++;
}
static int health_check_ref_dec(struct node_addr *node)
{
node->ref_cnt--;
return node->ref_cnt;
}
static struct session_iterm *health_check_get_iterm_by_id(uint64_t session_id)
{
struct session_iterm *tmp = NULL;
pthread_rwlock_rdlock(&g_handle.rwlock);
@@ -111,62 +140,130 @@ static void health_check_session_recover_bfd(struct bfd_vtysh_client *client)
client->recover_config = health_check_session_recover_cfg;
}
// return 0 : success
// return -1 : key exist
// struct health_check *policy : need deep copy
int health_check_session_add(int session_id, const struct health_check *policy)
static struct node_addr *health_check_get_node_by_addr(const char *addr)
{
struct node_addr *tmp = NULL;
HASH_FIND_STR(g_handle_addr.htable, addr, tmp);
return tmp;
}
static void health_check_add_node_by_addr(struct node_addr *node, const char *addr, uint64_t session_id)
{
snprintf(node->address, sizeof(node->address), addr);
node->session_id = session_id;
health_check_ref_inc(node);
HASH_ADD_STR(g_handle_addr.htable, address, node);
}
static int health_check_del_node_by_addr(const char *addr)
{
int ret = 0;
struct node_addr *node = NULL;
node = health_check_get_node_by_addr(addr);
if (node == NULL)
return 0;
ret = health_check_ref_dec(node);
if (ret != 0)
return 1;
HASH_DEL(g_handle_addr.htable, node);
free(node);
node = NULL;
return 0;
}
static uint64_t health_check_get_session_id()
{
struct session_iterm *tmp = NULL;
uint64_t tmp_session_id = g_session_id;
while(1) {
g_session_id++;
if (g_session_id == 0)
g_session_id++;
if (tmp_session_id == g_session_id)
return 0;
tmp = health_check_get_iterm_by_id(g_session_id);
if (tmp)
continue;
break;
}
return g_session_id;
}
// return >0 : session id
// return 0 : fail
// struct health_check *policy : need deep copy
uint64_t health_check_session_add(int profile_id, const struct health_check *policy)
{
int ret = 0;
uint64_t session_id = 0;
struct bfd_vtysh_client client;
struct node_addr *node = NULL;
struct session_iterm *tmp = NULL;
tmp = health_check_get_iterm_by_id(session_id);
if (tmp) {
LOG_DEBUG("health check session table insert: key %d exists", session_id);
return -1;
session_id = health_check_get_session_id();
if (session_id == 0) {
LOG_ERROR("health check get session id failed!");
return 0;
}
tmp = (struct session_iterm *)calloc(1, sizeof(struct session_iterm));
assert(tmp);
if (policy->method == HEALTH_CHECK_METHOD_BFD) {
health_check_session_init_bfd_client(&client);
bfd_vtysh_connect(&client);
ret = bfd_vtysh_add_dev(&client, policy->address, policy->retires, policy->interval_ms);
if (ret != 0) {
LOG_ERROR("bfd vtysh add dev address [%s] failed!", policy->address);
}
bfd_vtysh_close(&client);
}
memset(tmp, 0, sizeof(*tmp));
tmp->session_id = session_id;
tmp->profile_id = profile_id;
memcpy(&tmp->policy, policy, sizeof(struct health_check));
pthread_rwlock_wrlock(&g_handle.rwlock);
HASH_ADD(hh1, g_handle.root_by_id, session_id, sizeof(tmp->session_id), tmp);
pthread_rwlock_unlock(&g_handle.rwlock);
LOG_DEBUG("health check session table insert: key %d success", session_id);
return 0;
if (policy->method == HEALTH_CHECK_METHOD_BFD) {
node = health_check_get_node_by_addr(policy->address);
if (node) {
health_check_ref_inc(node);
}
else {
node = (struct node_addr *)calloc(1, sizeof(struct node_addr));
assert(node);
health_check_add_node_by_addr(node, policy->address, session_id);
health_check_session_init_bfd_client(&client);
bfd_vtysh_connect(&client);
ret = bfd_vtysh_add_dev(&client, policy->address, policy->retires, policy->interval_ms);
if (ret != 0)
LOG_ERROR("bfd vtysh add dev address [%s] failed!", policy->address);
bfd_vtysh_close(&client);
}
}
LOG_DEBUG("health check session table insert: session id [%lu] success", session_id);
return session_id;
}
// return 0 : success
// return -1 : key not exist
int health_check_session_del(int session_id)
int health_check_session_del(uint64_t session_id, int profile_id)
{
int ret = 0;
struct bfd_vtysh_client client;
struct session_iterm *tmp = NULL;
sf_status_delete(g_sf_status, session_id);
sf_status_delete(g_sf_status, profile_id);
tmp = health_check_get_iterm_by_id(session_id);
if (!tmp) {
LOG_DEBUG("health check session table delete: key %d not exists", session_id);
LOG_DEBUG("health check session table delete: session id [%lu] not exists", session_id);
return -1;
}
if (tmp->policy.method == HEALTH_CHECK_METHOD_BFD) {
ret = health_check_del_node_by_addr(tmp->policy.address);
if (ret == 1)
goto end;
health_check_session_init_bfd_client(&client);
bfd_vtysh_connect(&client);
ret = bfd_vtysh_del_dev(&client, tmp->policy.address);
@@ -176,20 +273,21 @@ int health_check_session_del(int session_id)
bfd_vtysh_close(&client);
}
end:
pthread_rwlock_wrlock(&g_handle.rwlock);
HASH_DELETE(hh1, g_handle.root_by_id, tmp);
pthread_rwlock_unlock(&g_handle.rwlock);
free(tmp);
tmp = NULL;
LOG_DEBUG("health check session table delete: key %d success", session_id);
LOG_DEBUG("health check session table delete: session id [%lu] success", session_id);
return 0;
}
// return 1 : active
// return 0 : inactive
// return -1 : key not exist
int health_check_session_get_status(int session_id)
int health_check_session_get_status(uint64_t session_id)
{
int status = 0;
struct session_iterm *tmp = NULL;
@@ -197,27 +295,27 @@ int health_check_session_get_status(int session_id)
pthread_rwlock_rdlock(&g_handle.rwlock);
HASH_FIND(hh1, g_handle.root_by_id, &session_id, sizeof(session_id), tmp);
if (!tmp) {
LOG_DEBUG("health check session table get status: key %d not exists", session_id);
LOG_DEBUG("health check session table get status: session id [%lu] not exists", session_id);
pthread_rwlock_unlock(&g_handle.rwlock);
return -1;
}
status = tmp->is_active;
pthread_rwlock_unlock(&g_handle.rwlock);
LOG_DEBUG("health check session get status: %d", status);
LOG_DEBUG("health check session id[%lu] get status [%d]", session_id, status);
return status;
}
// return 0 : success
// return -1 : key not exist
int health_check_session_set_status(int session_id, int is_active)
int health_check_session_set_status(uint64_t session_id, int is_active)
{
struct session_iterm *tmp = NULL;
pthread_rwlock_wrlock(&g_handle.rwlock);
HASH_FIND(hh1, g_handle.root_by_id, &session_id, sizeof(session_id), tmp);
if (!tmp) {
LOG_DEBUG("health check session table get status: key %d not exists", session_id);
LOG_DEBUG("health check session table set status: session id [%lu] not exists", session_id);
pthread_rwlock_unlock(&g_handle.rwlock);
return -1;
}
@@ -245,7 +343,7 @@ static int get_mac_by_addr(char *addr, uint8_t *buf)
saved_errno = errno;
ret = ioctl(sfd, SIOCGARP, &arp_req);
if (ret < 0) {
LOG_ERROR("Get ARP entry failed : %s\n", strerror(errno));
LOG_ERROR("Get IP [%s] MAC failed : %s", addr, strerror(errno));
return -1;
}
errno = saved_errno;
@@ -255,8 +353,8 @@ static int get_mac_by_addr(char *addr, uint8_t *buf)
else
memcpy(buf, default_gw_mac, HC_MAC_LEN);
LOG_DEBUG("MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
LOG_DEBUG("IP:%s, MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
addr, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
return 0;
}
@@ -298,11 +396,11 @@ static void *_health_check_session_foreach(void *arg)
node->is_active = is_active;
if (node->is_active == 1) {
get_mac_by_addr(node->policy.address, node->mac);
sf_status_update(g_sf_status, node->session_id, 1, 0);
sf_status_update(g_sf_status, node->profile_id, 1, 0);
}
else {
memset(node->mac, 0, sizeof(node->mac));
sf_status_update(g_sf_status, node->session_id, 0, 0);
sf_status_update(g_sf_status, node->profile_id, 0, 0);
}
}
if (sleep_ms > node->policy.interval_ms)
@@ -352,7 +450,7 @@ static int health_check_session_foreach()
// return 0 : success
// return -1 : key not exist
int health_check_session_get_mac(int session_id, char *mac_buff)
int health_check_session_get_mac(uint64_t session_id, char *mac_buff)
{
uint8_t *p = NULL;
struct session_iterm *tmp = NULL;
@@ -361,7 +459,7 @@ int health_check_session_get_mac(int session_id, char *mac_buff)
pthread_rwlock_rdlock(&g_handle.rwlock);
HASH_FIND(hh1, g_handle.root_by_id, &session_id, sizeof(session_id), tmp);
if (!tmp) {
LOG_DEBUG("health check session table get status: key %d not exists", session_id);
LOG_DEBUG("health check session get mac: session id [%lu] not exists", session_id);
pthread_rwlock_unlock(&g_handle.rwlock);
return -1;
}
@@ -373,7 +471,7 @@ int health_check_session_get_mac(int session_id, char *mac_buff)
}
snprintf(mac_buff, 18, "%02x:%02x:%02x:%02x:%02x:%02x", p[0], p[1], p[2], p[3], p[4], p[5]);
pthread_rwlock_unlock(&g_handle.rwlock);
LOG_DEBUG("health check session get mac: %s", mac_buff);
LOG_DEBUG("health check session id [%lu] get mac [%s]", session_id, mac_buff);
return 0;
}