DNS协议与请求

什么是DNS

域名系统（英文：Domain Name System，缩写：DNS）是互联网的一项服务。它作为 将域名和 IP 地址相互映射的一个分布式数据库，能够使人更方便地访问互联网。DNS 使 用 TCP 和 UDP 端口 53。当前，对于每一级域名长度的限制是 63 个字符，域名总长度 则不能超过 253 个字符。

域名解析

主机名到IP地址的映射有两种方式：

静态映射 - 在本机上配置域名和 IP 的映射，旨在本机上使用。Windows 和 Linux 的 hosts 文件中的内容就属于静态映射。 

动态映射 - 建立一套域名解析系统（DNS），只在专门的 DNS 服务器上配置主机到 IP 地址的映射，网络上需要使用主机名通信的设备，首先需要到 DNS 服务器查询主 机所对应的 IP 地址。

DNS协议

域名结构

域名系统并不像电话号码通讯录那么简单，通讯录主要是单个个体在使用，同一个名字出 现在不同个体的通讯录里并不会出现问题，但域名是群体中所有人都在用的，必须要保持 唯一性。为了达到唯一性的目的，因特网在命名的时候采用了层次结构的命名方法。每一 个域名（本文只讨论英文域名）都是一个标号序列（labels），用字母（A-Z，a-z，大小写 等价）、数字（0-9）和连接符（-）组成，标号序列总长度不能超过 255 个字符，它由点号 分割成一个个的标号（label），每个标号应该在 63 个字符之内，每个标号都可以看成一个 层次的域名。级别最低的域名写在左边，级别最高的域名写在右边。域名服务主要是基于 UDP 实现的，服务器的端口号为 53。

协议报文格式 

头部

会话标识（2字节）:是 DNS 报文的 ID 标识，对于请求报文和其对应的应答报文，这个字段 是相同的，通过它可以区分 DNS 应答报文是哪个请求的响应

标志（2字节）：

QR（1bit）查询/响应标志，0 为查询，1 为响应

opcode（4bit）0 表示标准查询，1 表示反向查询，2 表示服务器状态请求

AA（1bit）表示授权回答

TC（1bit）表示可截断的

RD（1bit）表示期望递归

RA（1bit）表示可用递归 rcode（4bit）表示返回码，0 表示没有差错，3 表示名字差错，2 表示服务器错误（Server Failure）

数量字段（总共8字节）：Questions、Answer RRs、Authority RRs、Additional RRs 各自 表示后面的四个区域的数目。Questions 表示查询问题区域节的数量，Answers 表示回答区 域的数量，Authoritative namesversers 表示授权区域的数量，Additional recoreds 表示 附加区域的数量。

正文

Queries

查询名：长度不固定，且不使用填充字节，一般该字段表示的就是需要查询的域名（如果是 反向查询，则为 IP，反向查询即由 IP 地址反查域名）。

查询类型：

查询类：通常为 1，表明是 Internet 数据

使用C实现DNS请求

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

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


#define DNS_SERVER_PORT		53
#define DNS_SERVER_IP		"114.114.114.114"

#define DNS_HOST			0x01
#define DNS_CNAME			0x05

struct dns_header {

	unsigned short id;
	unsigned short flags;

	unsigned short questions; // 1
	unsigned short answer;

	unsigned short authority;
	unsigned short additional;

};


struct dns_question {
	int length;
	unsigned short qtype;
	unsigned short qclass;
	unsigned char *name; // 
};

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


//client sendto dns server

int dns_create_header(struct dns_header *header) {

	if (header == NULL) return -1;
	memset(header, 0, sizeof(struct dns_header));

	//random
	srandom(time(NULL));
	header->id = random();

	header->flags = htons(0x0100);
	header->questions = htons(1); 

	return 0;
}

// hostname: www.0voice.com
// www
// 0voice
// com

// name: 3www60voice3com0

int dns_create_question(struct dns_question *question, const char *hostname) {

	if (question == NULL || hostname == NULL) return -1;
	memset(question, 0, sizeof(struct dns_question));

	question->name = (char*)malloc(strlen(hostname) + 2);
	if (question->name == NULL) {
		return -2;
	}

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

	question->qtype = htons(1); //
	question->qclass = htons(1);

	// name 
	const char delim[2] = ".";
	char *qname = question->name;
	
	char *hostname_dup = strdup(hostname); // strdup --> malloc
	char *token = strtok(hostname_dup, delim); // www.0voice.com 

	while (token != NULL) {

		size_t len = strlen(token);

		*qname = len;
		qname ++;

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

		token = strtok(NULL, delim); //0voice.com ,  com

	}

	free(hostname_dup);
	
}

// struct dns_header *header
// struct dns_question *question
// char *request

int dns_build_request(struct dns_header *header, struct dns_question *question, char *request, int rlen) {

	if (header == NULL || question == NULL || request == NULL) return -1;
	memset(request, 0, rlen);

	// header --> request
	
	memcpy(request, header, sizeof(struct dns_header));
	int offset = sizeof(struct dns_header);

	// question --> request
	memcpy(request+offset, question->name, question->length);
	offset += question->length;

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

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

	return offset;

}


static int is_pointer(int in) {
	return ((in & 0xC0) == 0xC0);
}


static void dns_parse_name(unsigned char *chunk, 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 = chunk + n;
			dns_parse_name(chunk, 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;
			}
		}
	
	}
	
}




static int dns_parse_response(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_parse_name(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_CNAME) {

			bzero(cname, sizeof(cname));
			len = 0;
			dns_parse_name(buffer, ptr, cname, &len);
			ptr += datalen;
			
		} else if (type == DNS_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;
	
}


int dns_client_commit(const char *domain) {

	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd < 0) {
		return  -1;
	}

	struct sockaddr_in servaddr = {0};
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(DNS_SERVER_PORT);
	servaddr.sin_addr.s_addr = inet_addr(DNS_SERVER_IP);

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

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

	struct dns_question question = {0};
	dns_create_question(&question, domain);

	char request[1024] = {0};
	int length = dns_build_request(&header, &question, request, 1024);

	// request
	int slen = sendto(sockfd, request, length, 0, (struct sockaddr*)&servaddr, sizeof(struct sockaddr));
	
	//recvfrom 
	char response[1024] = {0};
	struct sockaddr_in addr;
	size_t addr_len = sizeof(struct sockaddr_in);
	
	
	int n = recvfrom(sockfd, response, sizeof(response), 0, (struct sockaddr*)&addr, (socklen_t*)&addr_len);

	struct dns_item *dns_domain = NULL;
	dns_parse_response(response, &dns_domain);

	free(dns_domain);
	
	return n;

}


int main(int argc, char *argv[]) {

	if (argc < 2) return -1;

	dns_client_commit(argv[1]);

}