DNS协议 实践

根据DNS协议发送UDP请求，然后获取IP地址

头文件：

#ifndef __DNS__
#define __DNS__

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

using namespace std;

/**
 * 查询类型
 */
#define DNS_TYPE_A     0x01
#define DNS_TYPE_NS    0x02
#define DNS_TYPE_CNAME 0x05
#define DNS_TYPE_SOA   0x06
#define DNS_TYPE_WKS   0x0B
#define DNS_TYPE_PTR   0x0C
#define DNS_TYPE_HINFO 0x0D
#define DNS_TYPE_MX    0x0E
#define DNS_TYPE_AAAA  0x1C
#define DNS_TYPE_AXFR  0xFC
#define DNS_TYPE_ANY   0xFF

/**
 * 查询类别
 */
#define DNS_CATEGORY_A      0x01
#define DNS_CATEGORY_CSNET  0x02
#define DNS_CATEGORY_CS     0x03
#define DNS_CATEGORY_HS     0x04

// 发送DNS请求的key
static u_short _dnsKey = 0x0000;
// DNS域名服务器地址，这里是通过网卡的属性得到的
static string DNSServerIPAddr = "192.168.105.1";
// DNS域名服务器端口，默认53
static int DNSServerPort = 53;

/**
 * 获取发送的key
 */
u_short getDNSKey();

/**
 * 生成请求数据
 */
void generateDNSRequset(string url, string* requestData);

/**
 * 解析记录中的名字
 */
void parseDNSName(unsigned char* buff, unsigned char* pBuff, unsigned char* name, int* offset);

/**
 * 解析DNS响应数据
 */
void parseDNSResponse(unsigned char buff, string* ip);

/**
 * 发送DNS请求
 */
bool sendDNSRequest(int socketId, struct sockaddr* address, char* sendBuff, int buffLen);

/**
 * 接受DNS数据
 */
bool recvDNSRequest(int socketId, struct sockaddr* address, char* recvBuff, int buffLen);

/**
 * 通过DNS请求，获取ip地址的点格式
 */
bool getIPAddrByDNS(string url, string* ip);

#endif

代码文件：

#include "DNS.h"

/**
 * 获取发送的key
 */
unsigned short getDNSKey()
{
    if (_dnsKey == 65535) {
        _dnsKey = 0;
    }
    return ++_dnsKey;
}

/**
 * 生成请求数据
 */
void generateDNSRequset(string url, string* requestData)
{
    unsigned char  request[256];
    unsigned char* pRequest = request;

    // key
    *((unsigned short*)pRequest) = htons( getDNSKey() );
    pRequest += 2;
    // 标志
    *(pRequest++) = 0x01;
    *(pRequest++) = 0x00;
    // 查询记录数
    *((unsigned short*)pRequest) = htons(0x0001);
    pRequest += 2;
    // 资源记录数
    *((unsigned short*)pRequest) = htons(0x0000);
    pRequest += 2;
    // 授权资源记录数
    *((unsigned short*)pRequest) = htons(0x0000);
    pRequest += 2;
    // 额外资源记录数
    *((unsigned short*)pRequest) = htons(0x0000);
    pRequest += 2;

    // 填充查询名字
    unsigned char* pCount = pRequest++;
    int count = 0;
    for (int i = 0, len = url.length(); i < len; i++) {
        unsigned char ch = url.at(i);

        if (ch != '.') {
            *(pRequest++) = ch;
            count++;
        }
        else {
            *pCount = count;
            pCount = (pRequest++);

            count = 0;
        }
    }
    *pCount = count;
    *(pRequest++) = 0;

    // 查询类型
    *((unsigned short*)pRequest) = htons(0x0001);
    pRequest += 2;
    // 查询类别
    *((unsigned short*)pRequest) = htons(0x0001);
    pRequest += 2;

    int requestLen = pRequest - request;
    // 将char数组转换成string
    for (int i = 0; i<requestLen; i++) {
        requestData->push_back(request[i]);
    }
}

/**
 * 解析记录中的名字
 */
void parseDNSName(unsigned char* buff, unsigned char* pBuff, unsigned char* name, int* offset)
{
    unsigned char flag;
    unsigned char* pName = name + (*offset);

    do {
        flag = *pBuff;


        if ((flag & 0xC0) == 0xC0) {
            unsigned char _offset = *(pBuff + 1);
            pBuff = buff + _offset;

            parseDNSName(buff, pBuff, name, offset);

            break;
        }
        else {
            unsigned char _count = *(pBuff++);

            memcpy(pName, pBuff, _count);

            pBuff += _count;
            pName += _count;
            *offset += _count;

            if (*pBuff != 0) {
                *(pName++) = '.';
                *offset += 1;
            }
        }
    }
    while (flag != 0);
}

/**
 * 解析DNS响应数据
 */
void parseDNSResponse(unsigned char* buff, string* ip)
{
    unsigned char* pBuff = buff;

    // key
    unsigned short key = ntohs(*((unsigned short*)pBuff));
    pBuff += 2;
    // 标志
    unsigned short remarkLeft  = *(pBuff++);
    unsigned short remarkRight = *(pBuff++);
    unsigned char  QR      = (remarkLeft & 0x80) >> 7;
    unsigned char  OpCode = (remarkLeft & 0x78) >> 4;
    unsigned char  AA     = (remarkLeft & 0x04) >> 3;
    unsigned char  TC     = (remarkLeft & 0x02) >> 2;
    unsigned char  RD     = (remarkLeft & 0x01);
    unsigned char  RA     = (remarkRight & 0x80) >> 7;
    unsigned char  ZERO   = (remarkRight & 0x70) >> 4;
    unsigned char  rCode  = (remarkRight & 0x0F);
    // 问题记录数
    unsigned short questionCount = ntohs(*(unsigned short*)pBuff);
    pBuff += 2;
    // 回答记录数
    unsigned short answerCount = ntohs(*(unsigned short*)pBuff);
    pBuff += 2;
    // 授权记录数
    unsigned short authCount = ntohs(*(unsigned short*)pBuff);
    pBuff += 2;
    // 附加记录数
    unsigned short addiCount = ntohs(*(unsigned short*)pBuff);
    pBuff += 2;

    // 名字
    for (int i = 0; i<questionCount; i++) {
        unsigned char name[256];
        int nameLen = 0;

        parseDNSName(buff, pBuff, name, &nameLen);
        pBuff += nameLen;
        pBuff += 2;

        // 查询类型
        unsigned short queryType = ntohs(*((unsigned short*)pBuff));
        pBuff += 2;
        // 查询类别
        unsigned short queryClass = ntohs(*((unsigned short*)pBuff));
        pBuff += 2;
    }

    // 回答资源记录
    for (int i = 0; i<answerCount; i++) {
        unsigned char name[256];
        int nameLen = 0;

        parseDNSName(buff, pBuff, name, &nameLen);
        pBuff += 2;

        unsigned short queryType = ntohs(*((unsigned short*)pBuff));
        pBuff += 2;
        unsigned short queryClass = ntohs(*((unsigned short*)pBuff));
        pBuff += 2;
        unsigned int resTTL = ntohl(*((unsigned int*)pBuff));
        pBuff += 4;
        unsigned short resLen = ntohs(*((unsigned short*)pBuff));
        pBuff += 2;

        if (queryType == DNS_TYPE_CNAME) {
            unsigned char cname[256];
            int cnameLen = 0;

            parseDNSName(buff , pBuff , cname , &cnameLen);
        }
        else if (queryType == DNS_TYPE_A) {
            unsigned char ipData[4];
            memset(ipData ,0, sizeof(ipData));

            if (resLen == 4) { 
                memcpy(ipData , pBuff , resLen);

                in_addr _addr;
                _addr.S_un.S_un_b.s_b1 = ipData[0];
                _addr.S_un.S_un_b.s_b2 = ipData[1];
                _addr.S_un.S_un_b.s_b3 = ipData[2];
                _addr.S_un.S_un_b.s_b4 = ipData[3];

                string _ip = inet_ntoa(_addr);
                ip->clear();
                ip->insert(0, _ip);
            }
        }
        pBuff += resLen;
    }
}

/**
 * 发送DNS请求
 */
bool sendDNSRequest(int socketId, struct sockaddr* address, char* sendBuff, int buffLen)
{
    // 发送请求
    int sendBtyes = sendto(socketId, sendBuff, buffLen, 0, address, sizeof(struct sockaddr));
    return sendBtyes >= 0;
}

/**
 * 接受DNS数据
 */
bool recvDNSRequest(int socketId, struct sockaddr* address, char* recvBuff, int buffLen)
{
    // 接受响应数据
    int fromLen = sizeof(struct sockaddr);
    int recvBytes = recvfrom(socketId, recvBuff, buffLen, 0, address, &fromLen);
    return recvBytes >= 0;
}

/**
 * 通过DNS请求，获取ip地址的点格式
 */
bool getIPAddrByDNS(string url, string* ip)
{
    int socketId = socket(AF_INET, SOCK_DGRAM, 0);
    if (socketId == INVALID_SOCKET) {
        return false;
    }

    // 生成请求文本
    string requestData;
    generateDNSRequset(url, &requestData);

    // 初始化DNS服务器的套接字地址
    struct sockaddr_in serverAddr;
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.S_un.S_addr = inet_addr(DNSServerIPAddr.c_str());
    serverAddr.sin_port = htons(DNSServerPort);

    // 发送请求
    if (!sendDNSRequest(socketId, (struct sockaddr*)&serverAddr, (char *)requestData.c_str(), requestData.length())) {
        return false;
    }
    
    // 接受响应
    unsigned char recvBuff[1024];
    if (!recvDNSRequest(socketId, (struct sockaddr*)&serverAddr, (char *)recvBuff, sizeof(recvBuff))) {
        return false;
    }

    // 解析响应数据
    parseDNSResponse(recvBuff, ip);
    return true;
}

使用方法：

// 获取DNS信息
string host = "www.xiami.com";
string ip;
 if (!getIPAddrByDNS(host, &ip)) {
    printf("Get ip(%s) from DNS server failed
", host.c_str());
    return false;
}