server-doc-dns解析

DNS概念

DNS（Domain Name System，域名系统），万维网上作为域名和IP地址相互映射的一个分布式数据库，能够使用户更方便的访问互联网。DNS协议运行在UDP与TCP协议之上，使用端口号53。TCP协议用于DNS主从服务器之间数据同步，UDP协议用于客户端请求数据。

解析流程

要进行DNS解析，应用程序需要调用DNS接口函数来调度DNS解析器，由解析器进行控制，查询本地配置文件是否有相同的DNS目录条，如果本地没有，将发起网络请求，然后请求本地域名服务器，如果本地域名服务器并未同步此条域名信息，将由本地域名服务器去其他域名服务器请求域名数据条。如果其他服务器没有，就会再去其他服务器上同步，直到DNS顶级服务器。如果还没有就认为该域名不存在。

在linux里面可以使用gethostbyname、getaddrinfo、gethostbyname_r来进行DNS解析。

dns解析流程

代码参考

DNS接口的调用是阻塞式的，因此要同时查询很多域名的时候，会让查询进行的非常的慢，应该使用异步的方式来解决。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <errno.h>
#include <fcntl.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#include <sys/epoll.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <pthread.h>

#define DNS_SVR             "114.114.114.114"   // dns解析请求地址

#define DNS_RESULT_TYPE_HOST        0x01        // dns解析结果的 host类型对应的值
#define DNS_RESULT_TYPE_CNAME       0x05        // dns解析结果的 cname类型对应的值

#define ASYNC_DNS_MAX_COMMIT_NUM    1024        // 异步dns最大支持的解析提交请求数量



struct dns_header {
    unsigned short id;
    unsigned short flags;
    unsigned short qdcount;
    unsigned short ancount;
    unsigned short nscount;
    unsigned short arcount;
};

struct dns_content {
    int length;
    unsigned short qtype;
    unsigned short qclass;
    char *qname;
};

struct dns_item {
    char *domain;
    char *ip;
};


struct async_context {
    int epfd;
    pthread_t thread_id;
};

typedef void(*async_result_cb)(struct dns_item *list, int count);


struct ep_arg {
    int sockfd;
    const char *domain;
};

// 设置dns的标识
// @sockfd:网络描述符
// @block:是否阻塞请求，1阻塞，0不阻塞
int set_dns_flags(int sockfd, int block) {

    int flags = fcntl(sockfd, F_GETFL, 0);
    if (flags < 0) {
        return flags;
    }

    if (block) {
        flags &= ~O_NONBLOCK;
    } else {
        flags |= O_NONBLOCK;
    }

    if (fcntl(sockfd, F_SETFL, flags) < 0) {
        return -1;
    }

    return 0;
}

// 初始化dns头信息
// @header:头信息
int dns_init_header(struct dns_header *header) {

    if (header == NULL) {
        return -1;
    }

    memset(header, 0, sizeof(struct dns_header));
    srandom(time(NULL));

    header->id = random();
    header->flags |= htons(0x0100);
    header->qdcount = htons(1);

    return 0;
}

// 初始化dns内容
// @content:请求的内容
// @hostname:要请求的地址
int dns_init_content(struct dns_content *content, const char *hostname) {

    if (content == NULL) {
        return -1;
    }

    memset(content, 0, sizeof(struct dns_content));

    content->qname = (char*)malloc(strlen(hostname) + 2);
    if (content->qname == NULL) return -2;

    content->length = strlen(hostname) + 2;

    content->qtype = htons(1);
    content->qclass = htons(1);

    const char delim[2] = ".";

    char *hostname_dup = strdup(hostname);
    char *token = strtok(hostname_dup, delim);

    char *qname_p = content->qname;

    while (token != NULL) {

        size_t len = strlen(token);

        *qname_p = len;
        qname_p++;

        strncpy(qname_p, token, len + 1);
        qname_p += len;

        token = strtok(NULL, delim);
    }

    free(hostname_dup);

    return 0;

}

// 构建dns的请求信息
// @header:dns请求头
// @content:dns请求内容
// @request:dns请求信息存储指针
int dns_build_request(struct dns_header *header, struct dns_content *content, char *request)
{
    int header_s = sizeof(struct dns_header);
    int question_s = content->length + sizeof(content->qtype) + sizeof(content->qclass);

    int length = question_s + header_s;

    int offset = 0;
    memcpy(request + offset, header, sizeof(struct dns_header));
    offset += sizeof(struct dns_header);

    memcpy(request + offset, content->qname, content->length);
    offset += content->length;

    memcpy(request + offset, &content->qtype, sizeof(content->qtype));
    offset += sizeof(content->qtype);

    memcpy(request + offset, &content->qclass, sizeof(content->qclass));

    return length;

}


// dns打印dns结果
// @domain:dns解析前的域名
// @arr_item:解析到dns结果集合
// @count:解析到的dns结果数量
void print_dns_result(const char *domain, struct dns_item *arr_item, int count)
{
    int i = 0;
    for (i = 0; i < count; i++) {
        printf("nds domain:%s\n\tname:%s, ip:%s\n", domain, arr_item[i].domain, arr_item[i].ip);
    }
}

// 检测是否是点
int is_pointer(int in)
{
    return ((in & 0xC0) == 0xC0);
}

// 解析dns的值
// @buffer:dns解析的源信息
// @ptr:当前指向的源信息
// @out:存储解析值的指针
// @len:解析到的值的长度
void dns_value_parse(unsigned char *buffer, unsigned char *ptr, char *out, int *len) {

    int flag = 0, n = 0, alen = 0;
    char *pos = out + (*len);

    while (1) {

        flag = (int)ptr[0];
        if (flag == 0) {
            break;
        }

        if (is_pointer(flag)) {
            n = (int)ptr[1];
            ptr = buffer + n;
            dns_value_parse(buffer, ptr, out, len);
            break;
        } else {

            ptr++;
            memcpy(pos, ptr, flag);
            pos += flag;
            ptr += flag;

            *len += flag;
            if ((int)ptr[0] != 0) {
                memcpy(pos, ".", 1);
                pos += 1;
                (*len) += 1;
            }
        }

    }

}

// dns结果解析
// @buffer:结果信息
// @domains:要存储解析信息的指针
int dns_result_parse(char *buffer, struct dns_item **domains)
{
    int i = 0;
    unsigned char *ptr = buffer;

    ptr += 4;
    int querys = ntohs(*(unsigned short*)ptr);

    ptr += 2;
    int answers = ntohs(*(unsigned short*)ptr);

    ptr += 6;
    for (i = 0; i < querys; i++) {
        while (1) {
            int flag = (int)ptr[0];
            ptr += (flag + 1);

            if (flag == 0) break;
        }
        ptr += 4;
    }

    char cname[128], aname[128], ip[20], netip[4];
    int len, type, ttl, datalen;

    int cnt = 0;
    struct dns_item *list = (struct dns_item*)calloc(answers, sizeof(struct dns_item));
    if (list == NULL) {
        return -1;
    }

    for (i = 0; i < answers; i++) {

        bzero(aname, sizeof(aname));
        len = 0;

        dns_value_parse(buffer, ptr, aname, &len);
        ptr += 2;

        type = htons(*(unsigned short*)ptr);
        ptr += 4;

        ttl = htons(*(unsigned short*)ptr);
        ptr += 4;

        datalen = ntohs(*(unsigned short*)ptr);
        ptr += 2;

        if (type == DNS_RESULT_TYPE_CNAME) {

            bzero(cname, sizeof(cname));
            len = 0;
            dns_value_parse(buffer, ptr, cname, &len);
            ptr += datalen;

        } else if (type == DNS_RESULT_TYPE_HOST) {

            bzero(ip, sizeof(ip));

            if (datalen == 4) {
                memcpy(netip, ptr, datalen);
                inet_ntop(AF_INET, netip, ip, sizeof(struct sockaddr));

                //printf("%s has address %s\n" , aname, ip);
                //printf("\tTime to live: %d minutes , %d seconds\n", ttl / 60, ttl % 60);

                list[cnt].domain = (char *)calloc(strlen(aname) + 1, 1);
                memcpy(list[cnt].domain, aname, strlen(aname));

                list[cnt].ip = (char *)calloc(strlen(ip) + 1, 1);
                memcpy(list[cnt].ip, ip, strlen(ip));

                cnt++;
            }

            ptr += datalen;
        }
    }

    *domains = list;
    ptr += 2;

    return cnt;

}

// 普通的dns解析请求提交
// @domain:要解析的域名
int dns_commit(const char *domain)
{
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        perror("create socket failed\n");
        exit(-1);
    }

    set_dns_flags(sockfd, 0);

    printf("url:%s\n", domain);

    struct sockaddr_in dest;
    bzero(&dest, sizeof(dest));
    dest.sin_family = AF_INET;
    dest.sin_port = htons(53);
    dest.sin_addr.s_addr = inet_addr(DNS_SVR);

    int ret = connect(sockfd, (struct sockaddr*)&dest, sizeof(dest));
    printf("connect :%d\n", ret);

    struct dns_header header = { 0 };
    dns_init_header(&header);

    struct dns_content question = { 0 };
    dns_init_content(&question, domain);

    char request[1024] = { 0 };
    int req_len = dns_build_request(&header, &question, request);
    int slen = sendto(sockfd, request, req_len, 0, (struct sockaddr*)&dest, sizeof(struct sockaddr));

    while (1) {
        char buffer[1024] = { 0 };
        struct sockaddr_in addr;
        size_t addr_len = sizeof(struct sockaddr_in);
        //nonblock
        int n = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, (socklen_t*)&addr_len);
        if (n <= 0) {
            continue;
        }

        printf("recvfrom n : %d\n", n);
        struct dns_item *domains = NULL;
        dns_result_parse(buffer, &domains);

        break;
    }

    return 0;
}


// dns解析信息释放
// @arr_item:解析信息集合
// @count:解析信息数量
void dns_result_free(struct dns_item *arr_item, int count)
{
    if (arr_item == NULL) {
        return;
    }

    int i = 0;
    for (i = 0; i < count; i++) {
        free(arr_item[i].domain);
        free(arr_item[i].ip);
    }

    free(arr_item);
}

// 异步dns信息处理
// @arg:异步信息
void *dns_async_context_proc(void *arg)
{
    struct async_context *ctx = (struct async_context*)arg;
    if (ctx == NULL) {
        return NULL;
    }

    int epfd = ctx->epfd;

    while (1) {

        struct epoll_event events[ASYNC_DNS_MAX_COMMIT_NUM] = { 0 };

        int nready = epoll_wait(epfd, events, ASYNC_DNS_MAX_COMMIT_NUM, -1);
        if (nready < 0) {
            if (errno == EINTR || errno == EAGAIN) {
                continue;
            } else {
                break;
            }
        } else if (nready == 0) {
            continue;
        }

        int i = 0;
        for (i = 0; i < nready; i++) { //

            struct ep_arg *data = (struct ep_arg *)events[i].data.ptr;
            if (data == NULL) {
                continue;
            }

            int sockfd = data->sockfd;

            char buffer[1024] = { 0 };
            struct sockaddr_in addr;
            size_t addr_len = sizeof(struct sockaddr_in);
            //nonblock
            int n = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&addr, (socklen_t*)&addr_len);
            if (n < 0) continue;

            //printf("recvfrom n : %d\n", n);
            struct dns_item *arr_item = NULL;
            int count = dns_result_parse(buffer, &arr_item);

            print_dns_result(data->domain, arr_item, count);

            int ret = epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
            close(sockfd);

            dns_result_free(arr_item, count);
            free(data);
        }
    }
}


// 初始化dns解析的异步信息
// return:异步请求信息
struct async_context *dns_async_context_init(void)
{
    // 创建epoll
    int epfd = epoll_create(1);
    if (epfd < 0) {
        return NULL;
    }

    struct async_context *ctx = calloc(1, sizeof(struct async_context));
    if (ctx == NULL) {
        close(epfd);
        return NULL;
    }

    ctx->epfd = epfd;

    // 创建线程
    pthread_t thread_id;
    int ret = pthread_create(&thread_id, NULL, dns_async_context_proc, ctx);
    if (ret) {
        perror("pthread_create");
        close(epfd);
        free(ctx);
        return NULL;
    }
    ctx->thread_id = thread_id;

    usleep(1); //child first

    return ctx;
}

// 提交异步dns解析请求
// @ctx:异步信息
// @domain:要解析的域名
int dns_async_commit(struct async_context *ctx, const char *domain)
{
    if (ctx == NULL) {
        return -1;
    }

    if (domain == NULL) {
        return -1;
    }

    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        perror("create socket failed\n");
        exit(-1);
    }

    set_dns_flags(sockfd, 0);

    struct sockaddr_in dest;
    bzero(&dest, sizeof(dest));
    dest.sin_family = AF_INET;
    dest.sin_port = htons(53);
    dest.sin_addr.s_addr = inet_addr(DNS_SVR);

    int ret = connect(sockfd, (struct sockaddr*)&dest, sizeof(dest));

    struct dns_header header = { 0 };
    dns_init_header(&header);

    struct dns_content content = { 0 };
    dns_init_content(&content, domain);

    char request[1024] = { 0 };
    int req_len = dns_build_request(&header, &content, request);
    int slen = sendto(sockfd, request, req_len, 0, (struct sockaddr*)&dest, sizeof(struct sockaddr));
    if (slen < 0) {
        printf("send dns request fail %s\n", request);
        return -1;
    }

    struct ep_arg *eparg = (struct ep_arg *)calloc(1, sizeof(struct ep_arg));
    if (eparg == NULL) {
        close(sockfd);
        return -1;
    }

    eparg->sockfd = sockfd;
    eparg->domain = domain;

    struct epoll_event ev;
    ev.data.ptr = eparg;
    ev.events = EPOLLIN;

    ret = epoll_ctl(ctx->epfd, EPOLL_CTL_ADD, sockfd, &ev);

    return ret;
}


// 释放dns解析信息
// @ctx:异步信息
void dns_async_context_free(struct async_context *ctx)
{
    if (ctx == NULL) {
        return;
    }

    close(ctx->epfd);
    pthread_cancel(ctx->thread_id);
}


char *arr_domain[] = {
    "www.microsoft.com",
    "www.baidu.com",
    "www.qq.com",
    "www.163.com"
};


int main(int argc, char *argv[])
{
#if 0
    // 解析一个
    dns_client_commit(argv[1]);

    getchar();
#else
    // 解析一组
    struct async_context *ctx = dns_async_context_init();
    if (ctx == NULL) {
        return -2;
    }

    int count = sizeof(arr_domain) / sizeof(arr_domain[0]);

    int i = 0;
    for (i = 0; i < count; i++) {
        dns_async_commit(ctx, arr_domain[i]);
    }

    getchar();

    dns_async_context_free(ctx);

#endif

}