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

1146
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 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;
@@ -63,10 +71,10 @@ struct dns_head {
unsigned short id; // identification number
unsigned short qr; /* Query/Response Flag */
unsigned short opcode; /* Operation Code */
unsigned short aa; /* Authoritative Answer Flag */
unsigned short tc; /* Truncation Flag */
unsigned short rd; /* Recursion Desired */
unsigned short ra; /* Recursion Available */
unsigned char aa; /* Authoritative Answer Flag */
unsigned char tc; /* Truncation Flag */
unsigned char rd; /* Recursion Desired */
unsigned char ra; /* Recursion Available */
unsigned short rcode; /* Response Code */
unsigned short qdcount; // number of question entries
unsigned short ancount; // number of answer entries
@@ -74,77 +82,6 @@ struct dns_head {
unsigned short nrcount; // number of addititional resource entries
} __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 {
unsigned short next;
unsigned short len;
@@ -163,18 +100,26 @@ struct dns_packet {
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_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

304
dns_server.c
View File

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