Linux C/C++ 开发(学习笔记九 ):DNS协议与请求的实现

简介: Linux C/C++ 开发(学习笔记九 ):DNS协议与请求的实现

一、windows中通过uslookup根据域名查看ip

在windows中 通过域名查询 ip地址

在cmd中输入

nslookup www.baidu.com

就可以查询到百度的ip地址

这也是后续要实现的效果,通过dns请求来获取指定域名的ip地址

二、使用wireshark查看dns报文

从官方下载wireshark,直接全部下一步就行了,除了安装目录可以自己改一下。

打开后,选择当前连接的网络,(有峰状的图,才表明是连上的),比如我连的是无线网,双击WLAN

在上方输入dns,来过滤出dns相关内容

打开自己的浏览器,输入www.baidu.com,接下来就能在下面找到了

找到www.baidu.com

双击可以看到分组

总共五行,从上往下,以此是物理层、数据链路层、网络层、传输层、应用层

点开第5个,因为dns属于应用层

下图是dns协议报文,上面与下面的dns协议报文是一一对应的。

Transaction ID是一个随机数,Flags=0x0100是一个标准的查询,一般都是这么设置,里面包含了递归查询什么的设置。questions数是请求数,如果只请求一个网站,那么设置1就行了。剩下的就不用管了,默认都为0

Queries对应上图的Queries

注意这个长度6,不是’6’而是’\006’(也就是ascii的值为6),而域名中的0voice的0是字符‘0’,对应ascii的值为48

注意最后一个是’\0’不是’0’

三、代码实现DNS请求

1.创建首部header和question两个结构体

因此根据上面dns报文协议,创建2个结构体

1个存储dns首部header,另1个存储Queries(用来查询)

分别对应上面报文中的内容,除了length(表示char* name(域名)的长度)

struct dns_header{
    unsigned short id;
    unsigned short flags;
    unsigned short questions;
    unsigned short answers;
    unsigned short authority;
    unsigned short additional;
};
struct dns_question{
    int length;
    unsigned short qtype;
    unsigned short qclass;
    char* name;//域名
};

2.初始化dns首部

(id是随机的,flags为0x0100代表标准查询,questions为1,表示只查询一个,htons是为了转化为网络字节序,在补充中解释)

//client send to dns server
int dns_create_header(dns_header* header){
    if(header==NULL) return -1;
    memset(header,0,sizeof(header));
    //random
    srandom(time(NULL));//设置种子(因为种子根据时间有关,每次random也会变,因此这是一个线程不安全的)
    header->id=random();//获得随机数
    header->flags=htons(0x0100);//转化为网络字节序
    header->questions=htons(1);//每次查询一个域名
    return 0;
}

3.初始化question

(也就是dns协议报文中的Queries,由于规则问题,要将www.baidu.com转为3www5baidu3com’\0’,注意这个‘\0’是字符串结尾标志)

//创建question
//hostname:www.baidu.com
//name:3www5baidu3com'\0'
int dns_create_question(dns_question* question,const char* hostname){
    if(question==NULL||hostname==NULL) return -1;
    memset(question,0,sizeof(question));
    question->name=(char*)malloc(strlen(hostname)+2);//因为要判断结尾'\0',然后再补充一个开头3
    if(question->name==NULL){//如果内存分配失败
        return -2;
    }
    question->length=strlen(hostname)+2;
    question->qtype=htons(1);//查询类型,(1表示:由域名获得 IPv4 地址)
    question->qclass=htons(1);//通常为 1,表明是 Internet 数据
    //hostname->name
    const char delim[2]=".";//分隔符,末尾补个'\0'
    char* qname=question->name;
    char* hostname_dup=strdup(hostname);//复制一份hostname  --->malloc(所以后续要free)
    char* token=strtok(hostname_dup,delim);
    while(token!=NULL){
        size_t len=strlen(token);//第一个循环token为www,len=3
        *qname=len;//先把长度放上去
        qname++;
        strncpy(qname,token,len+1);//复制www,这里不+1也是可以的,这样是为了把最后的'\0'也复制过来,因为最后也会被覆盖的。(如果这边不+1,最后一步,需要额外加上'\0')
        qname+=len;
        token=strtok(NULL,delim);//因为上一次,token获取还未结束,因此可以指定NULL即可。(注意:要依赖上一次的结果,因此也是线程不安全的)
    }
    free(hostname_dup);
}

4.合并header和question为1个报文

char* request来接受

按序拷贝到request中

//struct dns_header* header
//struct dns_question* question
//把上面两个合到request中 返回长度
int dns_build_requestion(dns_header* header,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(dns_header));//把header的数据 拷贝 到request中
    int offset=sizeof(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;
}

5.通过socket实现dns请求

(1.创建sockfd,2.servaddr服务器地址 3.获得request, 4.sendto发送请求 5.recvfrom接受数据 6.从数据中解析出ip地址)

int dns_client_commit(const char* domin){
    int sockfd=socket(AF_INET,SOCK_DGRAM,0);//创建sockfd,AF_INET表示ipv4, SOCK_DGRAM为报文方式(UDP);
    if(sockfd<0){//创建失败
        return -1;
    }
    sockaddr_in servaddr={0};//服务器地址(sockaddr_in存储)
    servaddr.sin_family=AF_INET;//协议簇
    servaddr.sin_port=htons(DNS_SERVER_PORT);//端口
    servaddr.sin_addr.s_addr=inet_addr(DNS_SERVER_IP);//添加dns服务器ip
    int ret=connect(sockfd,(sockaddr*)&servaddr,sizeof(servaddr));//在udp编程中可加可不加
    printf("connect:%d",ret);
    dns_header header={0};
    dns_create_header(&header);
    dns_question question={0};
    dns_create_question(&question,domin);
    char request[1024]={0};//假设定义为1024长度
    int length = dns_build_requestion(&header,&question,request,1024);
    //request 发送请求
    int slen=sendto(sockfd,request,length,0,(sockaddr*)&servaddr,sizeof(sockaddr));
    //receive from 接受数据
    char response[1024]={0};
    sockaddr_in addr;
    size_t addr_len=sizeof(sockaddr_in);
    int n = recvfrom(sockfd,response,sizeof(response),0,(sockaddr*)&addr,(socklen_t*)&addr_len);
    printf("recvfrom:%d \n",n);
    for(int i=0;i<n;i++){
        printf("%c",response[i]);
    }
    for(int i=0;i<n;i++){
        printf("%x",response[i]);
    }
    printf("\n");
    return n;
}

6.解析结果

#define DNS_HOST      0x01
#define DNS_CNAME     0x05
struct dns_item {
  char *domain;
  char *ip;
};
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 = (unsigned char* )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((unsigned char* )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((unsigned char* )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;
}

在dns_client_commit末尾补充

四、补充

1.srandom()

srandom()可以设定种子,比如srandom(0) 、srandom(1)等等。如果srandom设定了一个固定的种子,那么random得出的随机数就是固定的;

如果程序运行时通过srandom(time(NULL))设定种子为随机的,那么random()每次生成的随机数就是非固定的了。

2.htons()

大小端及网络字节序

htons完整是 host to net short (将unsigned short转为网络字节序)

为什么htons(1)的值是256?

因为short是16位的,可以用0x00 01来表示内存中的1。但是,在网路字节序中,就是0x01 00,因此值为256

htons函数的问题

现在通过memcp将header中的内容拷贝到request中去

由于struct dns_header占用2个字节,因此sizeof(dns_header)=12

每个request[i]表示1个字节,一个unsigned short对应2个字节

比如flags=1,那么低位request[2]=0x01,高位request[3]=0x00

可以发现在内存空间中,低位占内存空间小的位置,也就是小端模式

反之,之前调用了htons(0x0100),使得flags=1,对应于网络字节序就是0x0100(也就是256)

3.connect

在udp中,connect仅仅是为了开路的,保证sendto的成功

4.recvfrom的结果

得到的response结果需要进行解析

5.dns_build_requestion要传入长度

dns_build_requestion时候一定要传长度1024

虽然现在结果是1024,是一块连续的内存,char占一个字节,因此是1024

但是传入函数后

因为传入的是一个指针,占8个字节。

同理,这边,不能用question->name,因为指针的大小为8字节,虽然指向字符串头部,但是不代表字符串的大小。

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

6.sockaddr和sockaddr_in的区别

sockaddr和sockaddr_in详解

7.udp的优势

五、完整代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<netinet/in.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<iostream>
#define DNS_SERVER_PORT 53
#define DNS_SERVER_IP "114.114.114.114"
#define DNS_HOST      0x01
#define DNS_CNAME     0x05
//声明
static int dns_parse_response(char *buffer, struct dns_item **domains);
struct dns_header{
    unsigned short id;
    unsigned short flags;
    unsigned short questions;
    unsigned short answers;
    unsigned short authority;
    unsigned short additional;
};
struct dns_question{
    int length;
    unsigned short qtype;
    unsigned short qclass;
    char* name;//域名
};
struct dns_item {
  char *domain;
  char *ip;
};
//client send to dns server
int dns_create_header(dns_header* header){
    if(header==NULL) return -1;
    memset(header,0,sizeof(dns_header));
    //random
    srandom(time(NULL));//设置种子(因为种子根据时间有关,每次random也会变,因此这是一个线程不安全的)
    header->id=random();//获得随机数
    header->flags=htons(0x0100);//转化为网络字节序
    header->questions=htons(1);//每次查询一个域名
    return 0;
}
//创建question
//hostname:www.baidu.com
//name:3www5baidu3com'\0'
int dns_create_question(dns_question* question,const char* hostname){
    if(question==NULL||hostname==NULL) return -1;
    memset(question,0,sizeof(question));
    question->name=(char*)malloc(strlen(hostname)+2);//因为要判断结尾'\0',然后再补充一个开头3
    if(question->name==NULL){//如果内存分配失败
        return -2;
    }
    question->length=strlen(hostname)+2;
    question->qtype=htons(1);//查询类型,(1表示:由域名获得 IPv4 地址)
    question->qclass=htons(1);//通常为 1,表明是 Internet 数据
    //hostname->name
    const char delim[2]=".";//分隔符,末尾补个'\0'
    char* qname=question->name;
    char* hostname_dup=strdup(hostname);//复制一份hostname  --->malloc(所以后续要free)
    char* token=strtok(hostname_dup,delim);
    while(token!=NULL){
        size_t len=strlen(token);//第一个循环token为www,len=3
        *qname=len;//先把长度放上去
        qname++;
        strncpy(qname,token,len+1);//复制www,这里不+1也是可以的,这样是为了把最后的'\0'也复制过来,因为最后也会被覆盖的。(如果这边不+1,最后一步,需要额外加上'\0')
        qname+=len;
        token=strtok(NULL,delim);//因为上一次,token获取还未结束,因此可以指定NULL即可。(注意:要依赖上一次的结果,因此也是线程不安全的)
    }
    free(hostname_dup);
}
#if 0
int dns_create_question(dns_question* question,const char* hostname){
    if(question==NULL||hostname==NULL) return -1;
    memset(question,0,sizeof(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);
    // memset(question->name,0,question->length);
    int i=0,n=strlen(hostname);
    string hostname_tmp=(char*)hostname;
    string name;
    while(i<n){
        int start=i;
        while(i<n&&hostname_tmp[i]!='.') i++;
        name+=i-start;
        name+=hostname_tmp.substr(start,i-start);
        while(i<n&&hostname[i]=='.') i++;
    }
    for(int i=0;i<question->length;i++) question->name[i]=name[i];
    return 0;
}
#endif
//struct dns_header* header
//struct dns_question* question
//把上面两个合到request中 返回长度
int dns_build_requestion(dns_header* header,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(dns_header));//把header的数据 拷贝 到request中
    int offset=sizeof(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;
}
int dns_client_commit(const char* domin){
    int sockfd=socket(AF_INET,SOCK_DGRAM,0);//创建sockfd,AF_INET表示ipv4, SOCK_DGRAM为报文方式(UDP);
    if(sockfd<0){//创建失败
        return -1;
    }
    sockaddr_in servaddr={0};//服务器地址(sockaddr_in存储)
    servaddr.sin_family=AF_INET;//协议簇(sockaddr_in_family)
    servaddr.sin_port=htons(DNS_SERVER_PORT);//端口
    servaddr.sin_addr.s_addr=inet_addr(DNS_SERVER_IP);//添加dns服务器ip
    int ret=connect(sockfd,(sockaddr*)&servaddr,sizeof(servaddr));//在udp编程中可加可不加
    printf("connect:%d",ret);
    dns_header header={0};
    dns_create_header(&header);
    dns_question question={0};
    dns_create_question(&question,domin);
    char request[1024]={0};//假设定义为1024长度
    int length = dns_build_requestion(&header,&question,request,1024);
    //request 发送请求
    int slen=sendto(sockfd,request,length,0,(sockaddr*)&servaddr,sizeof(sockaddr));
    //receive from 接受数据
    char response[1024]={0};
    sockaddr_in addr;
    size_t addr_len=sizeof(sockaddr_in);
    int n = recvfrom(sockfd,response,sizeof(response),0,(sockaddr*)&addr,(socklen_t*)&addr_len);
    // printf("recvfrom:%d \n",n);
    // for(int i=0;i<n;i++){
    //     printf("%c",response[i]);
    // }
    // for(int i=0;i<n;i++){
    //     printf("%x",response[i]);
    // }
    dns_item *dns_domain = NULL;
  dns_parse_response(response, &dns_domain);
    free(dns_domain);
    return n;
}
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 = (unsigned char* )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((unsigned char* )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((unsigned char* )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 main(int argc,char* argv[]){
    if(argc<2) return -1;
    dns_client_commit(argv[1]);
}


相关文章
|
27天前
|
存储 传感器 安全
【串口通信】使用C++和Qt设计和实现串口协议解析器(二)
【串口通信】使用C++和Qt设计和实现串口协议解析器
45 0
|
27天前
|
存储 开发框架 算法
【串口通信】使用C++和Qt设计和实现串口协议解析器(一)
【串口通信】使用C++和Qt设计和实现串口协议解析器
67 0
|
30天前
|
缓存 网络协议 Linux
【Shell 命令集合 网络通讯 】Linux 配置DNS dnsconf 命令 使用教程
【Shell 命令集合 网络通讯 】Linux 配置DNS dnsconf 命令 使用教程
38 0
|
10天前
|
存储 算法 Linux
【实战项目】网络编程:在Linux环境下基于opencv和socket的人脸识别系统--C++实现
【实战项目】网络编程:在Linux环境下基于opencv和socket的人脸识别系统--C++实现
26 6
|
25天前
|
Linux 编译器 程序员
【Linux 调试秘籍】深入探索 C++:运行时获取堆栈信息和源代码行数的终极指南
【Linux 调试秘籍】深入探索 C++:运行时获取堆栈信息和源代码行数的终极指南
66 0
|
27天前
|
消息中间件 Linux 调度
【Linux 进程/线程状态 】深入理解Linux C++中的进程/线程状态:阻塞,休眠,僵死
【Linux 进程/线程状态 】深入理解Linux C++中的进程/线程状态:阻塞,休眠,僵死
67 0
|
4天前
|
域名解析 网络协议 Linux
TCP/IP协议及配置、IP地址、子网掩码、网关地址、DNS与DHCP介绍
TCP/IP协议及配置、IP地址、子网掩码、网关地址、DNS与DHCP介绍
|
16天前
|
Linux API C语言
FFmpeg开发笔记(一)搭建Linux系统的开发环境
本文指导初学者如何在Linux上搭建FFmpeg开发环境。首先,由于FFmpeg依赖第三方库,可以免去编译源码的复杂过程,直接安装预编译的FFmpeg动态库。推荐网站<https://github.com/BtbN/FFmpeg-Builds/releases>提供适用于不同系统的FFmpeg包。但在安装前,需确保系统有不低于2.22版本的glibc库。详细步骤包括下载glibc-2.23源码,配置、编译和安装。接着,下载Linux版FFmpeg安装包,解压至/usr/local/ffmpeg,并设置环境变量。最后编写和编译简单的C或C++测试程序验证FFmpeg环境是否正确配置。
35 8
FFmpeg开发笔记(一)搭建Linux系统的开发环境
|
22天前
|
网络协议 Linux
Linux自建DNS
Linux自建DNS
11 0
|
22天前
|
网络协议 Linux 网络安全
Linux服务器DNS服务器配置实现bind的正向解释和反向解释
Linux服务器DNS服务器配置实现bind的正向解释和反向解释
17 0