update code

Makefile

@@ -1,6 +1,6 @@
 
 BIN=smartdns 
-OBJS=smartdns.o fast_ping.o lib/bitops.o dns_client.o dns_server.o dns.o
+OBJS=smartdns.o fast_ping.o lib/bitops.o dns_client.o dns_server.o dns.o util.o
 CFLAGS=-g -O0 -Wall 
 CFLAGS +=-Iinclude
 CXXFLAGS=-g -O0 -Wall -std=c++11 

dns.h

@@ -10,7 +10,7 @@
 #define DNS_RR_AAAA_LEN 16
 #define DNS_MAX_CNAME_LEN 256
 #define DNS_IN_PACKSIZE 512
-#define DNS_PACKSIZE (512 * 2)
+#define DNS_PACKSIZE (512 * 4)
 
 typedef enum dns_rr_type {
 	DNS_RRS_QD = 0,

dns_client.c

@@ -21,6 +21,8 @@
 #include "dns.h"
 #include "fast_ping.h"
 #include "hashtable.h"
+#include "list.h"
+#include "util.h"
 #include <arpa/inet.h>
 #include <errno.h>
 #include <linux/filter.h>
@@ -56,78 +58,357 @@ struct dns_client {
 	int run;
 	int epoll_fd;
 
+	pthread_mutex_t server_list_lock;
 	struct list_head dns_server_list;
 
-	pthread_mutex_t map_lock;
+	pthread_mutex_t dns_request_lock;
-	DECLARE_HASHTABLE(hostmap, 6);
+	struct list_head dns_request_list;
+	struct list_head dns_request_wait_list;
+
+	pthread_mutex_t domain_map_lock;
+	DECLARE_HASHTABLE(domain_map, 6);
 
 	int udp;
-	int tcp;
 };
+
+struct dns_server_info {
+	struct list_head list;
+	dns_server_type_t type;
+	unsigned short ss_family;
+	socklen_t addr_len;
+	union {
+		struct sockaddr_in in;
+		struct sockaddr_in6 in6;
+		struct sockaddr addr;
+	};
+};
+
 struct dns_query_struct {
-	char domain[DNS_MAX_HOSTNAME];
+	atomic_t refcnt;
-	struct hlist_node host_node;
+	struct list_head dns_request_list;
+	struct hlist_node domain_node;
+	char domain[DNS_MAX_CNAME_LEN];
+	int dns_request_sent;
 	void *user_ptr;
+	unsigned long send_tick;
+	dns_client_callback callback;
+	struct dns_result result;
 };
 
 static struct dns_client client;
 
-static dns_client_callback dns_callback;
+static struct addrinfo *_dns_client_getaddr(const char *host, char *port, int type, int protocol)
-
-static void tv_sub(struct timeval *out, struct timeval *in)
 {
-	if ((out->tv_usec -= in->tv_usec) < 0) { /* out -= in */
+	struct addrinfo hints;
-		--out->tv_sec;
+	struct addrinfo *result = NULL;
-		out->tv_usec += 1000000;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = type;
+	hints.ai_protocol = protocol;
+	if (getaddrinfo(host, port, &hints, &result) != 0) {
+		fprintf(stderr, "get addr info failed. %s\n", strerror(errno));
+		goto errout;
 	}
-	out->tv_sec -= in->tv_sec;
+
+	return result;
+errout:
+	if (result) {
+		freeaddrinfo(result);
+	}
+	return NULL;
+}
+
+int _dns_client_server_exist(struct addrinfo *gai, dns_server_type_t server_type)
+{
+	struct dns_server_info *server_info, *tmp;
+	pthread_mutex_lock(&client.server_list_lock);
+	list_for_each_entry_safe(server_info, tmp, &client.dns_server_list, list)
+	{
+		if (server_info->addr_len != gai->ai_addrlen || server_info->ss_family != gai->ai_family) {
+			continue;
+		}
+
+		if (server_info->type != server_type) {
+			continue;
+		}
+
+		if (memcmp(&server_info->addr, gai->ai_addr, gai->ai_addrlen) != 0) {
+			continue;
+		}
+		pthread_mutex_lock(&client.server_list_lock);
+		return 0;
+	}
+	pthread_mutex_unlock(&client.server_list_lock);
+	return -1;
+}
+
+int _dns_client_server_add(char *server_ip, struct addrinfo *gai, dns_server_type_t server_type)
+{
+	struct dns_server_info *server_info = NULL;
+
+	if (_dns_client_server_exist(gai, server_type) == 0) {
+		goto errout;
+	}
+
+	server_info = malloc(sizeof(*server_info));
+	if (server_info == NULL) {
+		goto errout;
+	}
+	memset(server_info, 0, sizeof(*server_info));
+	server_info->ss_family = gai->ai_family;
+	server_info->addr_len = gai->ai_addrlen;
+	server_info->type = server_type;
+	if (gai->ai_addrlen > sizeof(server_info->addr)) {
+		goto errout;
+	}
+	memcpy(&server_info->addr, gai->ai_addr, gai->ai_addrlen);
+	pthread_mutex_lock(&client.server_list_lock);
+	list_add(&server_info->list, &client.dns_server_list);
+	pthread_mutex_unlock(&client.server_list_lock);
+
+	if (fast_ping_start(server_ip, 0, 60000, NULL, server_info) != 0) {
+		goto errout;
+	}
+	return 0;
+errout:
+	if (server_info) {
+		free(server_info);
+	}
+
+	return -1;
+}
+
+int _dns_client_server_remove(char *server_ip, struct addrinfo *gai, dns_server_type_t server_type)
+{
+	struct dns_server_info *server_info, *tmp;
+	pthread_mutex_lock(&client.server_list_lock);
+	list_for_each_entry_safe(server_info, tmp, &client.dns_server_list, list)
+	{
+		if (server_info->addr_len != gai->ai_addrlen || server_info->ss_family != gai->ai_family) {
+			continue;
+		}
+
+		if (memcmp(&server_info->addr, gai->ai_addr, gai->ai_addrlen) != 0) {
+			continue;
+		}
+		list_del(&server_info->list);
+		pthread_mutex_unlock(&client.server_list_lock);
+		if (fast_ping_stop(server_ip) != 0) {
+			printf("stop ping failed.\n");
+		}
+		free(server_info);
+		return 0;
+	}
+	pthread_mutex_unlock(&client.server_list_lock);
+	return -1;
+}
+
+int _dns_client_server_operate(char *server_ip, int port, dns_server_type_t server_type, int operate)
+{
+	char port_s[8];
+	int sock_type;
+	int ret;
+	struct addrinfo *gai = NULL;
+
+	if (server_type >= DNS_SERVER_TYPE_END) {
+		return -1;
+	}
+
+	if (server_type == DNS_SERVER_UDP) {
+		sock_type = SOCK_DGRAM;
+	} else {
+		sock_type = SOCK_STREAM;
+	}
+
+	snprintf(port_s, 8, "%d", port);
+	gai = _dns_client_getaddr(server_ip, port_s, sock_type, 0);
+	if (gai == NULL) {
+		goto errout;
+	}
+
+	if (operate == 0) {
+		ret = _dns_client_server_add(server_ip, gai, server_type);
+		if (ret != 0) {
+			goto errout;
+		}
+	} else {
+		ret = _dns_client_server_remove(server_ip, gai, server_type);
+		if (ret != 0) {
+			goto errout;
+		}
+	}
+	freeaddrinfo(gai);
+	return 0;
+errout:
+	if (gai) {
+		freeaddrinfo(gai);
+	}
+	return -1;
+}
+
+int dns_add_server(char *server_ip, int port, dns_server_type_t server_type)
+{
+	return _dns_client_server_operate(server_ip, port, server_type, 0);
+}
+
+int dns_remove_server(char *server_ip, int port, dns_server_type_t server_type)
+{
+	return _dns_client_server_operate(server_ip, port, server_type, 1);
+}
+
+
+int _dns_client_query_complete(struct dns_query_struct *query)
+{
+	int ret = -1;
+	if (query->callback) {
+		ret = query->callback(query->domain, &query->result, query->user_ptr);
+	}
+    
+	return ret;
+}
+
+
+void _dns_client_query_release(struct dns_query_struct *query)
+{
+	if (!atomic_dec_and_test(&query->refcnt)) {
+		return;
+	}
+
+	pthread_mutex_lock(&client.domain_map_lock);
+	list_del(&query->dns_request_list);
+	hash_del(&query->domain_node);
+	pthread_mutex_unlock(&client.domain_map_lock);
+	_dns_client_query_complete(query);
+	free(query);
+}
+
+void _dns_client_query_get(struct dns_query_struct *query)
+{
+	atomic_inc(&query->refcnt);
+}
+
+void dns_client_ping_result(const char *host, FAST_PING_RESULT result, struct sockaddr *addr, socklen_t addr_len, int seqno, struct timeval *tv, void *userptr)
+{
+	struct dns_query_struct *query = userptr;
+
+	if (query == NULL) {
+		return;
+	}
+
+	unsigned int rtt = tv->tv_sec * 10000 + tv->tv_usec / 100;
+
+	switch (addr->sa_family) {
+	case AF_INET: {
+		struct sockaddr_in *addr_in;
+		addr_in = (struct sockaddr_in *)addr;
+		if (query->result.ttl_v4 > rtt) {
+			query->result.ttl_v4 = rtt;
+			memcpy(query->result.addr_ipv4, &addr_in->sin_addr.s_addr, 4);
+		}
+	} break;
+	case AF_INET6: {
+		struct sockaddr_in6 *addr_in6;
+		addr_in6 = (struct sockaddr_in6 *)addr;
+		if (IN6_IS_ADDR_V4MAPPED(&addr_in6->sin6_addr)) {
+			if (query->result.ttl_v4 > rtt) {
+                query->result.ttl_v4 = rtt;
+				memcpy(query->result.addr_ipv4, addr_in6->sin6_addr.s6_addr + 12, 4);
+			}
+		} else {
+			if (query->result.ttl_v6 > rtt) {
+                query->result.ttl_v6 = rtt;
+				memcpy(query->result.addr_ipv6, addr_in6->sin6_addr.s6_addr, 16);
+			}
+		}
+	} break;
+	default:
+		break;
+	}
+	printf("from %15s: seq=%d time=%d\n", host, seqno, rtt);
+	_dns_client_query_release(query);
 }
 
 void _dns_client_period_run()
 {
+	struct dns_query_struct *query, *tmp;
 
+	unsigned long now = get_tick_count();
+	pthread_mutex_lock(&client.domain_map_lock);
+	list_for_each_entry_safe(query, tmp, &client.dns_request_list, dns_request_list)
+	{
+		if (now - query->send_tick > 500) {
+		}
+	}
+	pthread_mutex_unlock(&client.domain_map_lock);
+	return;
 }
 
-static int _dns_client_recv(unsigned char *inpacket, int inpacket_len, struct sockaddr_storage *from, socklen_t from_len)
+static struct dns_query_struct *_dns_client_get_request(char *domain)
 {
-	int len;
+	struct dns_query_struct *query = NULL;
-	int i;
+	struct hlist_node *tmp = NULL;
-	int j;
+
-	int qtype;
+	pthread_mutex_lock(&client.domain_map_lock);
-	int qclass;
+	hash_for_each_possible_safe(client.domain_map, query, tmp, domain_node, hash_string(domain))
+	{
+		if (strncmp(query->domain, domain, DNS_MAX_CNAME_LEN) != 0) {
+			continue;
+		}
+		break;
+	}
+	pthread_mutex_unlock(&client.domain_map_lock);
+
+	return query;
+}
+
+static int _dns_client_process_answer(char *domain, struct dns_packet *packet)
+{
+	struct dns_query_struct *query;
 	int ttl;
 	char name[DNS_MAX_CNAME_LEN];
 	int rr_count;
+	int i = 0;
+	int j = 0;
 	struct dns_rrs *rrs = NULL;
-	unsigned char packet_buff[DNS_PACKSIZE];
+	int ret = -1;
-	struct dns_packet *packet = (struct dns_packet *)packet_buff;
+	int A_num = 0;
 
-	len = dns_decode(packet, DNS_PACKSIZE, inpacket, inpacket_len);
+	query = _dns_client_get_request(domain);
-	if (len != 0) {
+	if (query == NULL) {
-		printf("decode failed.\n");
 		return -1;
 	}
 
-	printf("qdcount = %d, ancount = %d, nscount = %d, nrcount = %d, len = %d\n", packet->head.qdcount, packet->head.ancount, packet->head.nscount,
-		   packet->head.nrcount, inpacket_len);
-
-	rrs = dns_get_rrs_start(packet, DNS_RRS_QD, &rr_count);
-	for (i = 0; i < rr_count && rrs; i++, rrs = dns_get_rrs_next(packet, rrs)) {
-		dns_get_domain(rrs, name, 128, &qtype, &qclass);
-		printf("domain: %s qtype: %d  qclass: %d\n", name, qtype, qclass);
-	}
-
 	for (j = 1; j < DNS_RRS_END; j++) {
 		rrs = dns_get_rrs_start(packet, j, &rr_count);
 		for (i = 0; i < rr_count && rrs; i++, rrs = dns_get_rrs_next(packet, rrs)) {
 			switch (rrs->type) {
 			case DNS_T_A: {
 				unsigned char addr[4];
-				dns_get_A(rrs, name, 128, &ttl, addr);
+				dns_get_A(rrs, name, DNS_MAX_CNAME_LEN, &ttl, addr);
 				printf("%s %d : %d.%d.%d.%d\n", name, ttl, addr[0], addr[1], addr[2], addr[3]);
-				dns_callback(name, addr, DNS_T_A, 0);
+				sprintf(name, "%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
+				_dns_client_query_get(query);
+				if (fast_ping_start(name, 1, 900, dns_client_ping_result, query) != 0) {
+					_dns_client_query_release(query);
+				}
+				A_num++;
+			} break;
+			case DNS_T_AAAA: {
+				unsigned char addr[16];
+				dns_get_AAAA(rrs, name, DNS_MAX_CNAME_LEN, &ttl, addr);
+				sprintf(name, "%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
+						addr[8], addr[9], addr[10], addr[11], addr[12], addr[13], addr[14], addr[15]);
+				_dns_client_query_get(query);
+				if (fast_ping_start(name, 1, 900, dns_client_ping_result, query) != 0) {
+					_dns_client_query_release(query);
+				}
+			} break;
+			case DNS_T_NS: {
+				char cname[128];
+				dns_get_CNAME(rrs, name, 128, &ttl, cname, 128);
+				printf("NS: %s %d : %s\n", name, ttl, cname);
 			} break;
-			case DNS_T_NS:
 			case DNS_T_CNAME: {
 				char cname[128];
 				dns_get_CNAME(rrs, name, 128, &ttl, cname, 128);
@@ -139,12 +420,50 @@ static int _dns_client_recv(unsigned char *inpacket, int inpacket_len, struct so
 		}
 	}
 
-	printf("\n");
+	query->dns_request_sent--;
+	if (query->dns_request_sent <= 0) {
+		_dns_client_query_release(query);
+	}
 
-	return 0;
+	return ret;
 }
 
-static int _dns_client_process(struct dns_query_struct *dns_query, struct timeval *now)
+static int _dns_client_recv(unsigned char *inpacket, int inpacket_len, struct sockaddr_storage *from, socklen_t from_len)
+{
+	int len;
+	int i;
+	int qtype;
+	int qclass;
+	char name[DNS_MAX_CNAME_LEN];
+	int rr_count;
+	struct dns_rrs *rrs = NULL;
+	unsigned char packet_buff[DNS_PACKSIZE];
+	struct dns_packet *packet = (struct dns_packet *)packet_buff;
+
+	len = dns_decode(packet, DNS_PACKSIZE, inpacket, inpacket_len);
+	if (len != 0) {
+		printf("decode failed, packet len = %d\n", inpacket_len);
+		return -1;
+	}
+
+	if (packet->head.qr != DNS_OP_IQUERY) {
+		printf("message type error.\n");
+		return -1;
+	}
+
+	printf("qdcount = %d, ancount = %d, nscount = %d, nrcount = %d, len = %d\n", packet->head.qdcount, packet->head.ancount, packet->head.nscount,
+		   packet->head.nrcount, inpacket_len);
+
+	rrs = dns_get_rrs_start(packet, DNS_RRS_QD, &rr_count);
+	for (i = 0; i < rr_count && rrs; i++, rrs = dns_get_rrs_next(packet, rrs)) {
+		dns_get_domain(rrs, name, DNS_MAX_CNAME_LEN, &qtype, &qclass);
+		printf("domain: %s qtype: %d  qclass: %d\n", name, qtype, qclass);
+	}
+
+	return _dns_client_process_answer(name, packet);
+}
+
+static int _dns_client_process(struct dns_query_struct *dns_query, unsigned long now)
 {
 	int len;
 	unsigned char inpacket[DNS_IN_PACKSIZE];
@@ -165,37 +484,35 @@ static void *_dns_client_work(void *arg)
 	struct epoll_event events[DNS_MAX_EVENTS + 1];
 	int num;
 	int i;
-	struct timeval last = {0};
+	unsigned long now = {0};
-	struct timeval now = {0};
+	unsigned int sleep = 100;
-	struct timeval diff = {0};
+	int sleep_time;
-	uint millisec = 0;
+	unsigned int expect_time = 0;
 
+	now = get_tick_count() - sleep;
+	expect_time = now + sleep;
 	while (client.run) {
-		diff = now;
+		now = get_tick_count();
-		tv_sub(&diff, &last);
+		if (now - expect_time >= 0) {
-		millisec = diff.tv_sec * 1000 + diff.tv_usec / 1000;
-		if (millisec >= 1000) {
 			_dns_client_period_run();
-			last = now;
+			sleep_time = sleep - (now - expect_time);
+			if (sleep_time < 0) {
+				sleep_time = 0;
+				expect_time = now;
+			}
+			expect_time += sleep;
 		}
 
-		num = epoll_wait(client.epoll_fd, events, DNS_MAX_EVENTS, 1000);
+		num = epoll_wait(client.epoll_fd, events, DNS_MAX_EVENTS, sleep_time);
 		if (num < 0) {
-			gettimeofday(&now, 0);
 			usleep(100000);
 			continue;
 		}
 
-		if (num == 0) {
-			gettimeofday(&now, 0);
-			continue;
-		}
-
-		gettimeofday(&now, 0);
 		for (i = 0; i < num; i++) {
 			struct epoll_event *event = &events[i];
 			struct dns_query_struct *dns_query = (struct dns_query_struct *)event->data.ptr;
-			_dns_client_process(dns_query, &now);
+			_dns_client_process(dns_query, now);
 		}
 	}
 
@@ -205,17 +522,10 @@ static void *_dns_client_work(void *arg)
 	return NULL;
 }
 
-static int _dns_client_send_packet(void *packet, int len)
+static int _dns_client_send_udp(struct dns_server_info *server_info, void *packet, int len)
 {
-	struct sockaddr_in to;
 	int send_len = 0;
-	socklen_t to_len = sizeof(to);
+	send_len = sendto(client.udp, packet, len, 0, (struct sockaddr *)&server_info->addr, server_info->addr_len);
-
-	memset(&to, 0, sizeof(to));
-	to.sin_addr.s_addr = inet_addr("192.168.1.1");
-	to.sin_port = htons(53);
-
-	send_len = sendto(client.udp, packet, len, 0, (struct sockaddr *)&to, to_len);
 	if (send_len != len) {
 		printf("send to server failed.");
 		return -1;
@@ -224,7 +534,34 @@ static int _dns_client_send_packet(void *packet, int len)
 	return 0;
 }
 
-static int _dns_client_send_request(struct dns_query_struct *request, char *doamin)
+static int _dns_client_send_packet(struct dns_query_struct *query, void *packet, int len)
+{
+	struct dns_server_info *server_info, *tmp;
+	int ret = 0;
+
+	query->send_tick = get_tick_count();
+	pthread_mutex_lock(&client.server_list_lock);
+	list_for_each_entry_safe(server_info, tmp, &client.dns_server_list, list)
+	{
+		switch (server_info->type) {
+		case DNS_SERVER_UDP:
+			ret = _dns_client_send_udp(server_info, packet, len);
+		default:
+			ret = -1;
+			break;
+		}
+
+		if (ret != 0) {
+			continue;
+		}
+
+		query->dns_request_sent++;
+	}
+	pthread_mutex_unlock(&client.server_list_lock);
+	return 0;
+}
+
+static int _dns_client_send_query(struct dns_query_struct *query, char *doamin)
 {
 	unsigned char packet_buff[DNS_PACKSIZE];
 	unsigned char inpacket[DNS_IN_PACKSIZE];
@@ -235,7 +572,7 @@ static int _dns_client_send_request(struct dns_query_struct *request, char *doam
 	memset(&head, 0, sizeof(head));
 	head.rcode = 0;
 	head.qr = DNS_OP_QUERY;
-	head.rd = 1;
+	head.rd = 0;
 	head.ra = 0;
 	head.id = 1;
 
@@ -243,42 +580,60 @@ static int _dns_client_send_request(struct dns_query_struct *request, char *doam
 	dns_add_domain(packet, doamin, DNS_T_A, DNS_C_IN);
 	encode_len = dns_encode(inpacket, DNS_IN_PACKSIZE, packet);
 	if (encode_len <= 0) {
-		printf("encode request failed.\n");
+		printf("encode query failed.\n");
 		return -1;
 	}
 
-	return _dns_client_send_packet(inpacket, encode_len);
+	return _dns_client_send_packet(query, inpacket, encode_len);
 }
 
-int dns_client_query(char *domain, void *user_ptr)
+int dns_client_query(char *domain, dns_client_callback callback, void *user_ptr)
 {
-	struct dns_query_struct *request = NULL;
+	struct dns_query_struct *query = NULL;
 	int ret = 0;
-	request = malloc(sizeof(*request));
-	if (request == NULL) {
-		return -1;
-	}
-	INIT_HLIST_NODE(&request->host_node);
-	strncpy(request->domain, domain, DNS_MAX_CNAME_LEN);
-	request->user_ptr = user_ptr;
 
-	ret =_dns_client_send_request(request, domain);
+	query = malloc(sizeof(*query));
-    if (ret != 0) {
+	if (query == NULL) {
 		goto errout;
 	}
-	free(request);
+	memset(query, 0, sizeof(*query));
+	INIT_HLIST_NODE(&query->domain_node);
+	INIT_LIST_HEAD(&query->dns_request_list);
+	atomic_set(&query->refcnt, 0);
+	strncpy(query->domain, domain, DNS_MAX_CNAME_LEN);
+	query->user_ptr = user_ptr;
+	query->callback = callback;
+	query->result.ttl_v4 = -1;
+	query->result.ttl_v6 = -1;
+
+	_dns_client_query_get(query);
+	ret = _dns_client_send_query(query, domain);
+	if (ret != 0) {
+		goto errout_del_list;
+	}
+
+	pthread_mutex_lock(&client.domain_map_lock);
+	list_add_tail(&query->dns_request_list, &client.dns_request_list);
+	hash_add(client.domain_map, &query->domain_node, hash_string(domain));
+	pthread_mutex_unlock(&client.domain_map_lock);
+
 	return 0;
+errout_del_list:
+	atomic_dec(&query->refcnt);
+	pthread_mutex_lock(&client.domain_map_lock);
+	list_del(&query->dns_request_list);
+	hash_del(&query->domain_node);
+	pthread_mutex_unlock(&client.domain_map_lock);
 errout:
-	if (request) {
+	if (query) {
-		free(request);
+		free(query);
 	}
 	return -1;
 }
 
-int dns_register_callback(dns_client_callback callback)
+int dns_client_query_raw(char *domain, unsigned char *raw, int raw_len, void *user_ptr)
 {
-	dns_callback = callback;
+	return -1;
-	return 0;
 }
 
 static struct addrinfo *_dns_server_getaddr(const char *host, const char *port, int type, int protocol)
@@ -322,7 +677,7 @@ int dns_client_socket(void)
 	int fd = -1;
 	struct addrinfo *gai = NULL;
 
-	gai = _dns_server_getaddr(NULL, "54", SOCK_DGRAM, 0);
+	gai = _dns_server_getaddr(NULL, "53", SOCK_DGRAM, 0);
 	if (gai == NULL) {
 		fprintf(stderr, "get address failed.\n");
 		goto errout;
@@ -383,11 +738,17 @@ int dns_client_init()
 		goto errout;
 	}
 
-	pthread_mutex_init(&client.map_lock, 0);
+	pthread_mutex_init(&client.server_list_lock, 0);
-	hash_init(client.hostmap);
+	INIT_LIST_HEAD(&client.dns_server_list);
+
+	pthread_mutex_init(&client.domain_map_lock, 0);
+	hash_init(client.domain_map);
+	INIT_LIST_HEAD(&client.dns_request_wait_list);
+	INIT_LIST_HEAD(&client.dns_request_list);
+
 	client.epoll_fd = epollfd;
 
-    if (dns_client_start()) {
+	if (dns_client_start()) {
 		fprintf(stderr, "start client failed.\n");
 		goto errout;
 	}
@@ -400,15 +761,17 @@ errout:
 		pthread_join(client.tid, &retval);
 	}
 
-	if (fd > 0) {
+	if (client.udp > 0) {
-		close(fd);
+		close(client.udp);
+		client.udp = -1;
 	}
 
 	if (epollfd) {
 		close(epollfd);
 	}
 
-	pthread_mutex_destroy(&client.map_lock);
+	pthread_mutex_destroy(&client.server_list_lock);
+	pthread_mutex_destroy(&client.domain_map_lock);
 
 	return -1;
 }
@@ -425,5 +788,6 @@ void dns_client_exit()
 		close(client.udp);
 	}
 
-	pthread_mutex_destroy(&client.map_lock);
+	pthread_mutex_destroy(&client.server_list_lock);
+	pthread_mutex_destroy(&client.domain_map_lock);
 }

dns_client.h

@@ -1,13 +1,35 @@
 #ifndef _SMART_DNS_CLIENT_H
 #define _SMART_DNS_CLIENT_H
 
+#include "dns.h"
+
+typedef enum {
+	DNS_SERVER_UDP,
+	DNS_SERVER_TCP,
+	DNS_SERVER_HTTP,
+    DNS_SERVER_TYPE_END,
+} dns_server_type_t;
+
+struct dns_result {
+	char alias[DNS_MAX_CNAME_LEN];
+	unsigned long ttl_v4;
+	unsigned char addr_ipv4[4];
+	unsigned long ttl_v6;
+	unsigned char addr_ipv6[16];
+};
+
 int dns_client_init(void);
 
-typedef int (*dns_client_callback)(char *domain, unsigned char *addr, int addr_type, void *user_ptr);
+typedef int (*dns_client_callback)(char *domain, struct dns_result *result, void *user_ptr);
-int dns_register_callback(dns_client_callback callback);
 
-int dns_client_query(char *domain, void *user_ptr);
+int dns_client_query(char *domain, dns_client_callback callback, void *user_ptr);
+
+int dns_client_query_raw(char *domain, unsigned char *raw, int raw_len, void *user_ptr);
 
 void dns_client_exit(void);
 
+int dns_add_server(char *server_ip, int port, dns_server_type_t server_type);
+
+int dns_remove_server(char *server_ip, int port, dns_server_type_t server_type);
+
 #endif

dns_server.c

@@ -18,6 +18,8 @@
 
 #include "dns_server.h"
 #include "dns.h"
+#include "util.h"
+#include "atomic.h"
 #include "hashtable.h"
 #include "list.h"
 #include "dns_client.h"
@@ -52,6 +54,7 @@ struct dns_server {
 };
 
 struct dns_request {
+	atomic_t refcnt;
 	struct hlist_node map;
 	char domain[DNS_MAX_CNAME_LEN];
 	unsigned short qtype;
@@ -72,15 +75,6 @@ struct dns_request {
 
 static struct dns_server server;
 
-static void tv_sub(struct timeval *out, struct timeval *in)
-{
-	if ((out->tv_usec -= in->tv_usec) < 0) { /* out -= in */
-		--out->tv_sec;
-		out->tv_usec += 1000000;
-	}
-	out->tv_sec -= in->tv_sec;
-}
-
 void _dns_server_period_run()
 {
 	return;
@@ -177,6 +171,7 @@ static int _dns_add_rrs(struct dns_packet *packet, struct dns_request *request)
 	return ret;
 }
 
+
 static int _dns_reply(struct dns_request *request)
 {
 	unsigned char inpacket[DNS_IN_PACKSIZE];
@@ -220,6 +215,40 @@ static int _dns_reply(struct dns_request *request)
 	return 0;
 }
 
+
+static int dns_server_resolve_callback(char *domain, struct dns_result *result, void *user_ptr)
+{
+	struct dns_request *request = user_ptr;
+
+	if (user_ptr == NULL) {
+		return -1;
+	}
+
+
+	memcpy(request->ipv4_addr, result->addr_ipv4, 4);
+	//memcpy(request->ipv6_addr, result->addr_ipv6, 16);
+	request->qtype = DNS_T_A;
+
+	printf("----------------%s--%d.%d.%d.%d-\n", domain, 
+		request->ipv4_addr[0], 
+		request->ipv4_addr[1], 
+		request->ipv4_addr[2], 
+		request->ipv4_addr[3]);
+	_dns_reply(request);
+
+	if (!atomic_dec_and_test(&request->refcnt)) {
+		return 0;
+
+	}
+
+	printf("free query server %p\n", request);
+	memset(request, 0, sizeof(*request));
+	free(request);
+
+	return 0;
+}
+
+
 static int _dns_server_recv(unsigned char *inpacket, int inpacket_len, struct sockaddr_storage *from, socklen_t from_len)
 {
 	int decode_len;
@@ -279,9 +308,10 @@ static int _dns_server_recv(unsigned char *inpacket, int inpacket_len, struct so
 		break;
 	}
 
-	dns_client_query(request->domain, request);
+	printf("query server %p\n", request);
+	atomic_set(&request->refcnt, 1);
+	dns_client_query(request->domain, dns_server_resolve_callback, request);
 
-	free(request);
 	return 0;
 errout:
 	if (request) {
@@ -291,7 +321,7 @@ errout:
 	return ret;
 }
 
-static int _dns_server_process(struct timeval *now)
+static int _dns_server_process(unsigned long now)
 {
 	int len;
 	unsigned char inpacket[DNS_IN_PACKSIZE];
@@ -312,33 +342,34 @@ int dns_server_run(void)
 	struct epoll_event events[DNS_MAX_EVENTS + 1];
 	int num;
 	int i;
-	struct timeval last = {0};
+	unsigned long now = {0};
-	struct timeval now = {0};
+	int sleep = 1000;
-	struct timeval diff = {0};
+	int sleep_time = 0;
-	uint millisec = 0;
+	unsigned long expect_time = 0;
 
-	while (server.run) {
+    now = get_tick_count() - sleep;
-		diff = now;
+    expect_time = now + sleep;
-		tv_sub(&diff, &last);
+    while (server.run) {
-		millisec = diff.tv_sec * 1000 + diff.tv_usec / 1000;
+        now = get_tick_count();
-		if (millisec >= 1000) {
+        if (now - expect_time >= 0) {
-			_dns_server_period_run();
+            _dns_server_period_run();
-			last = now;
+            sleep_time = sleep - (now - expect_time);
-		}
+			if (sleep_time < 0) {
+				sleep_time = 0;
+				
+			}
+            expect_time += sleep;
+        }
 
-		num = epoll_wait(server.epoll_fd, events, DNS_MAX_EVENTS, 1000);
+		num = epoll_wait(server.epoll_fd, events, DNS_MAX_EVENTS, sleep_time);
 		if (num < 0) {
-			gettimeofday(&now, 0);
 			usleep(100000);
 			continue;
 		}
 
 		if (num == 0) {
-			gettimeofday(&now, 0);
 			continue;
 		}
-
-		gettimeofday(&now, 0);
 		for (i = 0; i < num; i++) {
 			struct epoll_event *event = &events[i];
 			if (event->data.fd != server.fd) {
@@ -346,7 +377,7 @@ int dns_server_run(void)
 				continue;
 			}
 
-			_dns_server_process(&now);
+			_dns_server_process(now);
 		}
 	}
 
@@ -429,11 +460,6 @@ errout:
 	return -1;
 }
 
-static int dns_server_resolve_callback(char *domain, unsigned char *addr, int addr_type, void *user_ptr)
-{
-	return 0;
-}
-
 int dns_server_init(void)
 {
 	pthread_attr_t attr;
@@ -465,8 +491,6 @@ int dns_server_init(void)
 	server.fd = fd;
 	server.run = 1;
 
-	dns_register_callback(dns_server_resolve_callback);
-
 	if (dns_server_start() != 0) {
 		fprintf(stderr, "start service failed.\n");
 		goto errout;

fast_ping.h

@@ -2,7 +2,7 @@
 #define FAST_PING_H
 
 #include <sys/time.h>
-
+#include <netdb.h>
 #ifdef __cpluscplus
 extern "C" {
 #endif
@@ -18,10 +18,9 @@ typedef enum {
 	PING_RESULT_TIMEOUT = 2,
 } FAST_PING_RESULT;
 
-typedef void (*fast_ping_result)(const char *host, FAST_PING_RESULT result, int seqno, struct timeval *tv, void *userptr);
+typedef void (*fast_ping_result)(const char *host, FAST_PING_RESULT result, struct sockaddr *addr, socklen_t addr_len, int seqno, struct timeval *tv, void *userptr);
-void fast_ping_result_callback(fast_ping_result result);
 
-int fast_ping_start(const char *host, int timeout, void *userptr);
+int fast_ping_start(const char *host, int count, int timeout, fast_ping_result ping_callback, void *userptr);
 
 int fast_ping_stop(const char *host);
 

smartdns.c

@@ -21,18 +21,10 @@
 #include "dns_server.h"
 #include "hashtable.h"
 #include "list.h"
+#include "tlog.h"
 #include <stdio.h>
 #include <stdlib.h>
 
-void smartdns_ping_result(const char *host, FAST_PING_RESULT result, int seqno, struct timeval *tv, void *userptr)
-{
-    if (result == PING_RESULT_RESPONSE) {
-        double rtt = tv->tv_sec * 1000.0 + tv->tv_usec / 1000.0;
-        printf("%16s: seq=%d time=%.3f\n", host, seqno, rtt);
-    } else if (result == PING_RESULT_TIMEOUT) {
-		printf("%16s: seq=%d timeout\n", host, seqno);
-    }
-}
 
 int smartdns_init()
 {
@@ -44,8 +36,6 @@ int smartdns_init()
         goto errout;
     }
 
-    fast_ping_result_callback(smartdns_ping_result);
-
     ret = dns_server_init();
     if (ret != 0) {
         fprintf(stderr, "start dns server failed.\n");
@@ -58,7 +48,10 @@ int smartdns_init()
         goto errout;
     }
 
-    return 0;
+	//dns_add_server("192.168.1.1", 53, DNS_SERVER_UDP);
+    dns_add_server("114.114.114.114", 53, DNS_SERVER_UDP);
+	dns_add_server("123.207.137.88", 53, DNS_SERVER_UDP);
+	return 0;
 errout:
 
     return -1;

util.c

@@ -0,0 +1,11 @@
+#include "util.h"
+#include <time.h>
+
+unsigned long get_tick_count()
+{
+    struct timespec ts;
+
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+
+    return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
+}

util.h

@@ -0,0 +1,8 @@
+
+
+#ifndef SMART_DNS_UTIL_H
+#define SMART_DNS_UTIL_H
+
+unsigned long get_tick_count();
+
+#endif