388 lines
9.1 KiB
C
388 lines
9.1 KiB
C
#include "tvs_http_client.h"
|
||
#include "tvs_http_manager.h"
|
||
|
||
#include "mongoose.h"
|
||
|
||
#define TVS_LOG_DEBUG_MODULE "DNS"
|
||
#include "tvs_log.h"
|
||
#include "tvs_config.h"
|
||
#include "tvs_echo.h"
|
||
#include "tvs_ip_provider.h"
|
||
#include "tvs_dns.h"
|
||
#include "tvs_threads.h"
|
||
#include "os/os_api.h"
|
||
|
||
#define HTTP_DNS_PATH "http://119.29.29.29:80/d?dn="
|
||
|
||
static long g_last_dns_time = 0;
|
||
|
||
static int g_http_dns_ip = 0;
|
||
static int g_system_dns_ip = 0;
|
||
|
||
static int g_http_dns_ip_tmp = 0;
|
||
static int g_system_dns_ip_tmp = 0;
|
||
|
||
// 兜底IP
|
||
#define BACKUP_IP "183.3.225.67"
|
||
|
||
|
||
static int g_tvs_dns_pid = NULL;
|
||
static void *g_tvs_dns_mutex = NULL;
|
||
static int g_tvs_dns_start;
|
||
|
||
#define DNS_REFRESH_TIMER 40 // 更新DNS的时间间隔
|
||
|
||
|
||
typedef struct {
|
||
int ip_addr;
|
||
} tvs_http_dns_param;
|
||
|
||
TVS_LOCKER_DEFINE
|
||
|
||
extern void tvs_dns_fetch_all();
|
||
|
||
void tvs_dns_retry_dns(tvs_http_client_callback_exit_loop should_exit_func,
|
||
tvs_http_client_callback_should_cancel should_cancel_func, void *exit_param)
|
||
{
|
||
long cur_time = os_wrapper_get_time_ms();
|
||
if (g_last_dns_time == 0 || cur_time - g_last_dns_time > 600 * 1000) {
|
||
TVS_LOG_PRINTF("dns timeout, begin\n");
|
||
|
||
g_last_dns_time = cur_time;
|
||
// 超时，重新获取一次dns
|
||
tvs_dns_fetch_all(should_exit_func, should_cancel_func, exit_param);
|
||
}
|
||
}
|
||
|
||
void tvs_http_dns_callback_on_connect(void *connection, int error_code, tvs_http_client_param *param)
|
||
{
|
||
//TVS_LOG_PRINTF("send iplist connect\n");
|
||
}
|
||
|
||
void tvs_http_dns_callback_on_response(void *connection, int ret_code, const char *response, int response_len, tvs_http_client_param *param)
|
||
{
|
||
if (ret_code == 200) {
|
||
|
||
unsigned int a, b, c, d = 0;
|
||
if (response_len > 0 && response != NULL) {
|
||
char *ip_str = malloc(response_len + 1);
|
||
if (ip_str == NULL) {
|
||
TVS_LOG_PRINTF("get resonse ip OOM\n");
|
||
return;
|
||
}
|
||
|
||
memset(ip_str, 0, response_len + 1);
|
||
strncpy(ip_str, response, response_len);
|
||
|
||
if (sscanf(ip_str, "%u.%u.%u.%u", &a, &b, &c, &d) == 4) {
|
||
tvs_http_dns_param *dns_param = (tvs_http_dns_param *)param->user_data;
|
||
dns_param->ip_addr =
|
||
mg_htonl(((uint32_t) a << 24) | ((uint32_t) b << 16) | c << 8 | d);
|
||
//TVS_LOG_PRINTF("get resonse ip %s, %d\n", response, dns_param->ip_addr);
|
||
}
|
||
|
||
free(ip_str);
|
||
}
|
||
|
||
} else {
|
||
TVS_LOG_PRINTF("get resonse err %d - %.*s\n", ret_code, response_len, response);
|
||
}
|
||
}
|
||
|
||
void tvs_http_dns_callback_on_close(void *connection, int by_server, tvs_http_client_param *param) { }
|
||
|
||
int tvs_http_dns_callback_on_send_request(void *connection, const char *path, const char *host, const char *extra_header, const char *payload, tvs_http_client_param *param)
|
||
{
|
||
tvs_http_send_normal_get_request((struct mg_connection *)connection, path, strlen(path), host, strlen(host));
|
||
return 0;
|
||
}
|
||
|
||
bool tvs_http_dns_callback_on_loop(void *connection, tvs_http_client_param *param)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
int tvs_http_dns_start(const char *host,
|
||
tvs_http_client_callback_exit_loop should_exit_func,
|
||
tvs_http_client_callback_should_cancel should_cancel_func,
|
||
void *exit_param,
|
||
int *ip_addr)
|
||
{
|
||
if (host == NULL || strlen(host) <= 0) {
|
||
TVS_LOG_PRINTF("%s -- invalid host\n", __func__);
|
||
return -1;
|
||
}
|
||
int max_buf_len = 200;
|
||
char *http_dns_url = malloc(max_buf_len);
|
||
if (NULL == http_dns_url) {
|
||
TVS_LOG_PRINTF("%s -- OOM\n", __func__);
|
||
return -1;
|
||
}
|
||
|
||
memset(http_dns_url, 0, max_buf_len);
|
||
|
||
sprintf(http_dns_url, "%s%s", HTTP_DNS_PATH, host);
|
||
|
||
//TVS_LOG_PRINTF("send http dns url %s\n", http_dns_url);
|
||
|
||
tvs_http_client_callback cb = { 0 };
|
||
cb.cb_on_close = tvs_http_dns_callback_on_close;
|
||
cb.cb_on_connect = tvs_http_dns_callback_on_connect;
|
||
cb.cb_on_loop = tvs_http_dns_callback_on_loop;
|
||
cb.cb_on_request = tvs_http_dns_callback_on_send_request;
|
||
cb.cb_on_response = tvs_http_dns_callback_on_response;
|
||
cb.exit_loop = should_exit_func;
|
||
cb.should_cancel = should_cancel_func;
|
||
cb.exit_loop_param = exit_param;
|
||
|
||
tvs_http_client_config config = { 0 };
|
||
tvs_http_client_param http_param = { 0 };
|
||
tvs_http_dns_param http_dns_param = { 0 };
|
||
|
||
int ret = tvs_http_client_request_with_forceip(http_dns_url, NULL, NULL, &http_dns_param, &config, &cb, &http_param, false, 0);
|
||
|
||
if (http_dns_url != NULL) {
|
||
free(http_dns_url);
|
||
}
|
||
|
||
*ip_addr = http_dns_param.ip_addr;
|
||
TVS_LOG_PRINTF("send http dns result %d\n", *ip_addr);
|
||
|
||
return ret;
|
||
}
|
||
|
||
extern int mg_resolve2(const char *host, struct in_addr *ina);
|
||
|
||
int tvs_resolve(const char *host, int *ina)
|
||
{
|
||
return mg_resolve2(host, (struct in_addr *)ina);
|
||
}
|
||
|
||
int tvs_dns_system_start(const char *host)
|
||
{
|
||
int ipaddr = 0;
|
||
tvs_resolve(host, &ipaddr);
|
||
|
||
return ipaddr;
|
||
}
|
||
|
||
void tvs_dns_fetch_all(tvs_http_client_callback_exit_loop should_exit_func,
|
||
tvs_http_client_callback_should_cancel should_cancel_func, void *exit_param)
|
||
{
|
||
const char *host = tvs_config_get_current_host();
|
||
int ipaddr = 0;
|
||
tvs_http_dns_start(host, should_exit_func, should_cancel_func, exit_param, &ipaddr);
|
||
TVS_LOG_PRINTF("tvs_dns_fetch_all http dns %d \n", ipaddr);
|
||
if (ipaddr != 0) {
|
||
do_lock();
|
||
g_http_dns_ip = ipaddr;
|
||
|
||
g_http_dns_ip_tmp = g_http_dns_ip;
|
||
TVS_LOG_PRINTF("get http dns %d - %s\n", ipaddr, inet_ntoa(*(struct in_addr *)&ipaddr));
|
||
do_unlock();
|
||
}
|
||
|
||
ipaddr = tvs_dns_system_start(host);
|
||
|
||
if (ipaddr != 0) {
|
||
do_lock();
|
||
if (g_http_dns_ip != ipaddr) {
|
||
g_system_dns_ip = ipaddr;
|
||
TVS_LOG_PRINTF("get system dns %d - %s\n", ipaddr, inet_ntoa(*(struct in_addr *)&ipaddr));
|
||
} else {
|
||
g_system_dns_ip = 0;
|
||
}
|
||
|
||
g_system_dns_ip_tmp = g_system_dns_ip;
|
||
|
||
do_unlock();
|
||
}
|
||
}
|
||
|
||
bool tvs_http_dns_check_start()
|
||
{
|
||
return true;
|
||
}
|
||
|
||
bool tvs_http_dns_remove_ip(int ip_addr)
|
||
{
|
||
if (ip_addr == 0) {
|
||
return false;
|
||
}
|
||
do_lock();
|
||
|
||
if (g_http_dns_ip_tmp == ip_addr) {
|
||
g_http_dns_ip_tmp = 0;
|
||
}
|
||
|
||
do_unlock();
|
||
|
||
return true;
|
||
}
|
||
|
||
int tvs_http_dns_get_count()
|
||
{
|
||
return 1;
|
||
}
|
||
|
||
int tvs_system_dns_get_count()
|
||
{
|
||
return 1;
|
||
}
|
||
|
||
int tvs_http_dns_get_next_ip(int index)
|
||
{
|
||
if (index != 0) {
|
||
return 0;
|
||
}
|
||
|
||
do_lock();
|
||
|
||
int ip = g_http_dns_ip_tmp;
|
||
|
||
do_unlock();
|
||
|
||
return ip;
|
||
}
|
||
|
||
bool tvs_system_dns_check_start()
|
||
{
|
||
return true;
|
||
}
|
||
|
||
|
||
int tvs_system_dns_get_next_ip(int index)
|
||
{
|
||
if (index != 0) {
|
||
return 0;
|
||
}
|
||
|
||
do_lock();
|
||
|
||
int ip = g_system_dns_ip_tmp;
|
||
|
||
do_unlock();
|
||
|
||
return ip;
|
||
}
|
||
|
||
bool tvs_system_dns_remove_ip(int ip_addr)
|
||
{
|
||
if (ip_addr == 0) {
|
||
return false;
|
||
}
|
||
do_lock();
|
||
|
||
if (g_system_dns_ip_tmp == ip_addr) {
|
||
g_system_dns_ip_tmp = 0;
|
||
}
|
||
|
||
do_unlock();
|
||
|
||
return true;
|
||
}
|
||
|
||
static void dns_thread_func(tvs_thread_handle_t *thread_handle_t);
|
||
|
||
int tvs_dns_init()
|
||
{
|
||
TVS_LOCKER_INIT
|
||
|
||
return 0;
|
||
}
|
||
|
||
int tvs_dns_uninit()
|
||
{
|
||
|
||
TVS_LOCKER_UNINIT
|
||
|
||
return 0;
|
||
}
|
||
|
||
void tvs_dns_get_first_ip()
|
||
{
|
||
// 首次连接，获取DNS IP，不进行echo校验，直接设置为valid ip
|
||
tvs_dns_fetch_all(NULL, NULL, NULL);
|
||
|
||
do_lock();
|
||
int ip = g_http_dns_ip == 0 ? g_system_dns_ip : g_http_dns_ip;
|
||
do_unlock();
|
||
|
||
if (ip != 0) {
|
||
tvs_ip_provider_set_valid_ip(ip, true);
|
||
} else {
|
||
// 如果系统dns和http dns都没有，那么使用兜底IP
|
||
tvs_ip_provider_set_valid_ip_ex(BACKUP_IP, true);
|
||
}
|
||
}
|
||
|
||
static void dns_thread_func(tvs_thread_handle_t *thread_handle_t)
|
||
{
|
||
tvs_dns_fetch_all(NULL, NULL, NULL);
|
||
|
||
int validip = 0;
|
||
|
||
do_lock();
|
||
int http_ip = g_http_dns_ip;
|
||
int system_ip = g_system_dns_ip;
|
||
do_unlock();
|
||
|
||
bool ret = tvs_echo_start(http_ip);
|
||
|
||
if (!ret) {
|
||
ret = tvs_echo_start(system_ip);
|
||
if (ret) {
|
||
validip = system_ip;
|
||
}
|
||
} else {
|
||
validip = http_ip;
|
||
}
|
||
|
||
if (validip != 0) {
|
||
tvs_ip_provider_set_valid_ip(validip, true);
|
||
}
|
||
}
|
||
|
||
|
||
static void tvs_dns_timer_func(void *param)
|
||
{
|
||
while (g_tvs_dns_start) {
|
||
dns_thread_func(NULL);
|
||
os_wrapper_wait_signal(g_tvs_dns_mutex, DNS_REFRESH_TIMER * 60 * 1000);
|
||
}
|
||
}
|
||
|
||
static void tvs_dns_refresh_start()
|
||
{
|
||
if (!g_tvs_dns_pid) {
|
||
if (!g_tvs_dns_mutex) {
|
||
g_tvs_dns_mutex = os_wrapper_create_signal_mutex(0);
|
||
}
|
||
g_tvs_dns_start = 1;
|
||
thread_fork("tvs_dns_thread", 20, 1024, 0, &g_tvs_dns_pid, tvs_dns_timer_func, NULL);
|
||
}
|
||
}
|
||
|
||
void tvs_dns_refresh_stop()
|
||
{
|
||
if (g_tvs_dns_pid) {
|
||
g_tvs_dns_start = 0;
|
||
os_wrapper_post_signal(g_tvs_dns_mutex);
|
||
thread_kill(&g_tvs_dns_pid, KILL_WAIT);
|
||
g_tvs_dns_pid = 0;
|
||
os_wrapper_delete_signal_mutex(&g_tvs_dns_mutex);
|
||
}
|
||
|
||
}
|
||
|
||
void tvs_dns_on_network_changed(bool connected)
|
||
{
|
||
TVS_LOG_PRINTF("network changed,dns:%d\n", connected);
|
||
if (connected) {
|
||
// 网络重连的时候，需要刷新DNS IP
|
||
tvs_dns_refresh_start();
|
||
} else {
|
||
tvs_dns_refresh_stop();
|
||
}
|
||
}
|