daxi20/smartdns
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update code

Browse Source
This commit is contained in:
Nick Peng
2018-05-12 22:56:23 +08:00
parent 675534ab12
commit 7ea212f03a
3 changed files with 1023 additions and 534 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1144
dns.c
View File

File diff suppressed because it is too large Load Diff

107
dns.h
View File

@@ -14,7 +14,15 @@
#define RA_MASK 0x8000 #define RA_MASK 0x8000
#define RCODE_MASK 0x000F #define RCODE_MASK 0x000F
typedef enum dns_section { DNS_S_QD = 0x01, DNS_S_AN = 0x02, DNS_S_NS = 0x04, DNS_S_AR = 0x08, DNS_S_ALL = 0x0f } dns_section_t; #define DNS_RR_A_LEN 4
#define DNS_RR_AAAA_LEN 16
#define DNS_RRS_QD 0
#define DNS_RRS_AN 1
#define DNS_RRS_NS 2
#define DNS_RRS_NR 3
#define DNS_RR_END (-1)
typedef enum dns_class { DNS_C_IN = 1, DNS_C_ANY = 255 } dns_class_t; typedef enum dns_class { DNS_C_IN = 1, DNS_C_ANY = 255 } dns_class_t;
@@ -63,10 +71,10 @@ struct dns_head {
unsigned short id; // identification number unsigned short id; // identification number
unsigned short qr; /* Query/Response Flag */ unsigned short qr; /* Query/Response Flag */
unsigned short opcode; /* Operation Code */ unsigned short opcode; /* Operation Code */
unsigned short aa; /* Authoritative Answer Flag */ unsigned char aa; /* Authoritative Answer Flag */
unsigned short tc; /* Truncation Flag */ unsigned char tc; /* Truncation Flag */
unsigned short rd; /* Recursion Desired */ unsigned char rd; /* Recursion Desired */
unsigned short ra; /* Recursion Available */ unsigned char ra; /* Recursion Available */
unsigned short rcode; /* Response Code */ unsigned short rcode; /* Response Code */
unsigned short qdcount; // number of question entries unsigned short qdcount; // number of question entries
unsigned short ancount; // number of answer entries unsigned short ancount; // number of answer entries
@@ -74,77 +82,6 @@ struct dns_head {
unsigned short nrcount; // number of addititional resource entries unsigned short nrcount; // number of addititional resource entries
} __attribute__((packed)); } __attribute__((packed));
struct dns_qds {
unsigned short type;
unsigned short classes;
};
typedef uint32_t TTL;
typedef struct dns_question_t /* RFC-1035 */
{
const char *name;
dns_type_t type;
dns_class_t class;
} dns_question_t;
typedef struct dns_generic_t /* RFC-1035 */
{
const char *name;
dns_type_t type;
dns_class_t class;
TTL ttl;
} dns_generic_t;
typedef struct dns_a_t /* RFC-1035 */
{
const char *name;
dns_type_t type;
dns_class_t class;
TTL ttl;
in_addr_t address;
} dns_a_t;
typedef struct dns_aaaa_t /* RFC-1886 */
{
const char *name;
dns_type_t type;
dns_class_t class;
TTL ttl;
struct in6_addr address;
} dns_aaaa_t;
typedef struct dns_cname_t /* RFC-1035 */
{
const char *name;
dns_type_t type;
dns_class_t class;
TTL ttl;
const char *cname;
} dns_cname_t;
typedef struct dns_ptr_t /* RFC-1035 */
{
const char *name;
dns_type_t type;
dns_class_t class;
TTL ttl;
const char *ptr;
} dns_ptr_t;
typedef union dns_answer_t {
dns_generic_t generic;
dns_a_t a;
dns_cname_t cname;
dns_ptr_t ptr;
dns_aaaa_t aaaa;
} dns_answer_t;
#define DNS_RR_QD 0
#define DNS_RR_AN 1
#define DNS_RR_NS 2
#define DNS_RR_NR 3
struct dns_rrs { struct dns_rrs {
unsigned short next; unsigned short next;
unsigned short len; unsigned short len;
@@ -163,18 +100,26 @@ struct dns_packet {
unsigned char data[0]; unsigned char data[0];
}; };
int dns_decode(struct dns_packet *packet, unsigned char *data, int size); struct dns_rrs *dns_get_rrs_next(struct dns_packet *packet, struct dns_rrs *rrs);
int dns_encode(unsigned char *data, int size, struct dns_packet *packet); struct dns_rrs *dns_get_rrs_start(struct dns_packet *packet, int type, int *count);
int dns_packet_init(struct dns_packet *packet, int size); int dns_add_A(struct dns_packet *packet, char *domain, int ttl, unsigned char addr[4]);
int dns_get_A(struct dns_rrs *rrs, char *domain, int maxsize, int *ttl, unsigned char addr[4]);
int dns_add_AAAA(struct dns_packet *packet, char *domain, int ttl, unsigned char addr[16]);
int dns_get_AAAA(struct dns_rrs *rrs, char *domain, int maxsize, int *ttl, unsigned char addr[16]);
int dns_get_domain(struct dns_rrs *rrs, char *domain, int maxsize, int *qtype, int *qclass); int dns_get_domain(struct dns_rrs *rrs, char *domain, int maxsize, int *qtype, int *qclass);
int dns_add_domain(struct dns_packet *packet, char *domain, int qtype, int qclass); int dns_add_domain(struct dns_packet *packet, char *domain, int qtype, int qclass);
struct dns_rrs *dns_rr_get_next(struct dns_packet *packet, struct dns_rrs *rrs); int dns_decode(struct dns_packet *packet, int maxsize, unsigned char *data, int size);
struct dns_rrs *dns_rr_get_start(struct dns_packet *packet, int type, int *count); int dns_encode(unsigned char *data, int size, struct dns_packet *packet);
int dns_packet_init(struct dns_packet *packet, int size, struct dns_head *head);
#endif #endif

300
dns_server.c
View File

@@ -1,6 +1,6 @@
#include "dns_server.h" #include "dns_server.h"
#include "hashtable.h"
#include "dns.h" #include "dns.h"
#include "hashtable.h"
#include <arpa/inet.h> #include <arpa/inet.h>
#include <errno.h> #include <errno.h>
#include <linux/filter.h> #include <linux/filter.h>
@@ -24,127 +24,171 @@
#define DNS_INPACKET_SIZE 512 #define DNS_INPACKET_SIZE 512
struct dns_server { struct dns_server {
int run; int run;
int epoll_fd; int epoll_fd;
int fd; int fd;
pthread_mutex_t map_lock; pthread_mutex_t map_lock;
DECLARE_HASHTABLE(hostmap, 6); DECLARE_HASHTABLE(hostmap, 6);
}; };
static struct dns_server server; static struct dns_server server;
static void tv_sub(struct timeval *out, struct timeval *in) static void tv_sub(struct timeval *out, struct timeval *in)
{ {
if ((out->tv_usec -= in->tv_usec) < 0) { /* out -= in */ if ((out->tv_usec -= in->tv_usec) < 0) { /* out -= in */
--out->tv_sec; --out->tv_sec;
out->tv_usec += 1000000; out->tv_usec += 1000000;
} }
out->tv_sec -= in->tv_sec; out->tv_sec -= in->tv_sec;
} }
void _dns_server_period_run() void _dns_server_period_run()
{ {
unsigned char packet_data[DNS_INPACKET_SIZE];
unsigned char data[DNS_INPACKET_SIZE];
struct dns_packet *packet = (struct dns_packet *)packet_data;
struct dns_head head;
memset(&head, 0, sizeof(head));
head.rcode = 0;
head.qr = 0;
head.ra = 1;
head.id = 1;
int len;
struct sockaddr_in to;
socklen_t to_len = sizeof(to);
dns_packet_init(packet, DNS_INPACKET_SIZE, &head);
dns_add_domain(packet, "www.baidu.com", 1, 1);
len = dns_encode(data, DNS_INPACKET_SIZE, packet);
memset(&to, 0, sizeof(to));
to.sin_addr.s_addr = inet_addr("192.168.1.1");
to.sin_port = htons(53);
len = sendto(server.fd, data, len, 0, (struct sockaddr *)&to, to_len);
if (len < 0) {
printf("send failed.");
}
printf("send %d\n", len);
} }
static int _dns_server_process(struct timeval *now) static int _dns_server_process(struct timeval *now)
{ {
int len; int len;
unsigned char inpacket[DNS_INPACKET_SIZE]; unsigned char inpacket[DNS_INPACKET_SIZE];
unsigned char rsppacket[DNS_INPACKET_SIZE]; unsigned char rsppacket[DNS_INPACKET_SIZE];
struct dns_packet *packet = (struct dns_packet *)rsppacket; struct dns_packet *packet = (struct dns_packet *)rsppacket;
struct sockaddr_storage from; struct sockaddr_storage from;
socklen_t from_len = sizeof(from); socklen_t from_len = sizeof(from);
len = recvfrom(server.fd, inpacket, sizeof(inpacket), 0, (struct sockaddr *)&from, (socklen_t *)&from_len); len = recvfrom(server.fd, inpacket, sizeof(inpacket), 0, (struct sockaddr *)&from, (socklen_t *)&from_len);
if (len < 0) { if (len < 0) {
fprintf(stderr, "recvfrom failed, %s\n", strerror(errno)); fprintf(stderr, "recvfrom failed, %s\n", strerror(errno));
goto errout; goto errout;
} }
dns_packet_init(packet, sizeof(rsppacket)); dns_decode(packet, DNS_INPACKET_SIZE, inpacket, len);
dns_decode(packet, inpacket, len);
printf("head.id = %d\n", packet->head.id); int count;
printf("head.an_count = %d\n", packet->head.ancount); struct dns_rrs *rrs;
printf("head.qd_count = %d\n", packet->head.qdcount); char name[128];
int i = 0;
int ttl;
rrs = dns_get_rrs_start(packet, DNS_RRS_AN, &count);
for (i = 0; i < 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);
printf("%s %d : %d.%d.%d.%d\n", name, ttl, addr[0], addr[1], addr[2], addr[3]);
} break;
default:
break;
}
}
return 0; return 0;
errout: errout:
return -1; return -1;
} }
int dns_server_run(void) int dns_server_run(void)
{ {
struct epoll_event events[DNS_MAX_EVENTS + 1]; struct epoll_event events[DNS_MAX_EVENTS + 1];
int num; int num;
int i; int i;
struct timeval last = { 0 }; struct timeval last = {0};
struct timeval now = { 0 }; struct timeval now = {0};
struct timeval diff = { 0 }; struct timeval diff = {0};
uint millisec = 0; uint millisec = 0;
while (server.run) { while (server.run) {
diff = now; diff = now;
tv_sub(&diff, &last); tv_sub(&diff, &last);
millisec = diff.tv_sec * 1000 + diff.tv_usec / 1000; millisec = diff.tv_sec * 1000 + diff.tv_usec / 1000;
if (millisec >= 100) { if (millisec >= 100) {
_dns_server_period_run(); _dns_server_period_run();
last = now; last = now;
} }
num = epoll_wait(server.epoll_fd, events, DNS_MAX_EVENTS, 100); num = epoll_wait(server.epoll_fd, events, DNS_MAX_EVENTS, 100);
if (num < 0) { if (num < 0) {
gettimeofday(&now, 0); gettimeofday(&now, 0);
usleep(100000); usleep(100000);
continue; continue;
} }
if (num == 0) { if (num == 0) {
gettimeofday(&now, 0); gettimeofday(&now, 0);
continue; continue;
} }
gettimeofday(&now, 0); gettimeofday(&now, 0);
for (i = 0; i < num; i++) { for (i = 0; i < num; i++) {
struct epoll_event *event = &events[i]; struct epoll_event *event = &events[i];
if (event->data.fd != server.fd) { if (event->data.fd != server.fd) {
fprintf(stderr, "invalid fd\n"); fprintf(stderr, "invalid fd\n");
continue; continue;
} }
_dns_server_process(&now); _dns_server_process(&now);
} }
} }
close(server.epoll_fd); close(server.epoll_fd);
server.epoll_fd = -1; server.epoll_fd = -1;
return 0; return 0;
} }
static struct addrinfo *_dns_server_getaddr(const char *host, const char *port, int type, int protocol) static struct addrinfo *_dns_server_getaddr(const char *host, const char *port, int type, int protocol)
{ {
struct addrinfo hints; struct addrinfo hints;
struct addrinfo *result = NULL; struct addrinfo *result = NULL;
memset(&hints, 0, sizeof(hints)); memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; hints.ai_family = AF_UNSPEC;
hints.ai_socktype = type; hints.ai_socktype = type;
hints.ai_protocol = protocol; hints.ai_protocol = protocol;
hints.ai_flags = AI_PASSIVE; hints.ai_flags = AI_PASSIVE;
if (getaddrinfo(host, port, &hints, &result) != 0) { if (getaddrinfo(host, port, &hints, &result) != 0) {
fprintf(stderr, "get addr info failed. %s\n", strerror(errno)); fprintf(stderr, "get addr info failed. %s\n", strerror(errno));
goto errout; goto errout;
} }
return result; return result;
errout: errout:
if (result) { if (result) {
freeaddrinfo(result); freeaddrinfo(result);
} }
return NULL; return NULL;
} }
int dns_server_start(void) int dns_server_start(void)
@@ -162,102 +206,102 @@ int dns_server_start(void)
int dns_server_socket(void) int dns_server_socket(void)
{ {
int fd = -1; int fd = -1;
struct addrinfo *gai = NULL; struct addrinfo *gai = NULL;
gai = _dns_server_getaddr(NULL, "53", SOCK_DGRAM, 0); gai = _dns_server_getaddr(NULL, "53", SOCK_DGRAM, 0);
if (gai == NULL) { if (gai == NULL) {
fprintf(stderr, "get address failed.\n"); fprintf(stderr, "get address failed.\n");
goto errout; goto errout;
} }
fd = socket(gai->ai_family, gai->ai_socktype, gai->ai_protocol); fd = socket(gai->ai_family, gai->ai_socktype, gai->ai_protocol);
if (fd < 0) { if (fd < 0) {
fprintf(stderr, "create socket failed.\n"); fprintf(stderr, "create socket failed.\n");
goto errout; goto errout;
} }
if (bind(fd, gai->ai_addr, gai->ai_addrlen) != 0) { if (bind(fd, gai->ai_addr, gai->ai_addrlen) != 0) {
fprintf(stderr, "bind failed.\n"); fprintf(stderr, "bind failed.\n");
goto errout; goto errout;
} }
server.fd = fd; server.fd = fd;
freeaddrinfo(gai); freeaddrinfo(gai);
return fd; return fd;
errout: errout:
if (fd > 0) { if (fd > 0) {
close(fd); close(fd);
} }
if (gai) { if (gai) {
freeaddrinfo(gai); freeaddrinfo(gai);
} }
return -1; return -1;
} }
int dns_server_init(void) int dns_server_init(void)
{ {
pthread_attr_t attr; pthread_attr_t attr;
int epollfd = -1; int epollfd = -1;
int fd = -1; int fd = -1;
if (server.epoll_fd > 0) { if (server.epoll_fd > 0) {
return -1; return -1;
} }
memset(&server, 0, sizeof(server)); memset(&server, 0, sizeof(server));
pthread_attr_init(&attr); pthread_attr_init(&attr);
epollfd = epoll_create1(EPOLL_CLOEXEC); epollfd = epoll_create1(EPOLL_CLOEXEC);
if (epollfd < 0) { if (epollfd < 0) {
fprintf(stderr, "create epoll failed, %s\n", strerror(errno)); fprintf(stderr, "create epoll failed, %s\n", strerror(errno));
goto errout; goto errout;
} }
fd = dns_server_socket(); fd = dns_server_socket();
if (fd < 0) { if (fd < 0) {
fprintf(stderr, "create server socket failed.\n"); fprintf(stderr, "create server socket failed.\n");
goto errout; goto errout;
} }
pthread_mutex_init(&server.map_lock, 0); pthread_mutex_init(&server.map_lock, 0);
hash_init(server.hostmap); hash_init(server.hostmap);
server.epoll_fd = epollfd; server.epoll_fd = epollfd;
server.fd = fd; server.fd = fd;
server.run = 1; server.run = 1;
if (dns_server_start() != 0) { if (dns_server_start() != 0) {
fprintf(stderr, "start service failed.\n"); fprintf(stderr, "start service failed.\n");
goto errout; goto errout;
} }
return 0; return 0;
errout: errout:
server.run = 0; server.run = 0;
if (fd > 0) { if (fd > 0) {
close(fd); close(fd);
} }
if (epollfd) { if (epollfd) {
close(epollfd); close(epollfd);
} }
pthread_mutex_destroy(&server.map_lock); pthread_mutex_destroy(&server.map_lock);
return -1; return -1;
} }
void dns_server_exit(void) void dns_server_exit(void)
{ {
server.run = 0; server.run = 0;
if (server.fd > 0) { if (server.fd > 0) {
close(server.fd); close(server.fd);
server.fd = -1; server.fd = -1;
} }
pthread_mutex_destroy(&server.map_lock); pthread_mutex_destroy(&server.map_lock);
} }