|
/***************************************************************
* 文件：resolver.c
* 功能：C 语言实现域名解析（两种方式）
* - 方法 A：使用系统接口 getaddrinfo/getnameinfo（推荐）
* - 方法 B：自实现简易 DNS 客户端（UDP 查询 A / AAAA / CNAME）
*
* 编译（Linux）:
* gcc resolver.c -o resolver
*
* 用法示例：
* ./resolver sys www.example.com # 使用系统接口解析
* ./resolver dns 8.8.8.8 www.example.com # 使用自定义 DNS 客户端，指定 DNS 服务器
* ./resolver reverse sys 93.184.216.34 # 反向解析（IP->域名）使用系统接口
*
***************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <time.h>
#include <sys/time.h>
/* -----------------------------
通用工具函数与定义
----------------------------- */
#define MAXBUF 512
static void pprint_addrinfo(struct addrinfo *res) {
char host[NI_MAXHOST];
for (struct addrinfo *p = res; p != NULL; p = p->ai_next) {
void *addr;
const char *ipver;
if (p->ai_family == AF_INET) {
struct sockaddr_in *ipv4 = (struct sockaddr_in *)p->ai_addr;
addr = &(ipv4->sin_addr);
ipver = "IPv4";
} else if (p->ai_family == AF_INET6) {
struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)p->ai_addr;
addr = &(ipv6->sin6_addr);
ipver = "IPv6";
} else {
continue;
}
if (inet_ntop(p->ai_family, addr, host, sizeof(host)) == NULL) {
strncpy(host, "unknown", sizeof(host));
host[sizeof(host)-1] = 0;
}
printf(" %-4s %s\n", ipver, host);
}
}
/* -----------------------------
方法 A：使用系统接口 getaddrinfo / getnameinfo
----------------------------- */
static int resolve_with_getaddrinfo(const char *name) {
struct addrinfo hints, *res;
int rv;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // 支持 IPv4 和 IPv6
hints.ai_socktype = 0; // 任意 socket 类型
hints.ai_flags = AI_CANONNAME; // 返回规范名（如可用）
rv = getaddrinfo(name, NULL, &hints, &res);
if (rv != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
printf("Canonical name: %s\n", res->ai_canonname ? res->ai_canonname : "(none)");
printf("Addresses for %s:\n", name);
pprint_addrinfo(res);
freeaddrinfo(res);
return 0;
}
/* 反向解析：IP -> 主机名 */
static int reverse_with_getnameinfo(const char *ipstr) {
struct sockaddr_storage sa;
socklen_t sa_len;
char host[NI_MAXHOST];
memset(&sa, 0, sizeof(sa));
if (strchr(ipstr, ':')) {
// IPv6
struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)&sa;
sa6->sin6_family = AF_INET6;
if (inet_pton(AF_INET6, ipstr, &(sa6->sin6_addr)) != 1) {
fprintf(stderr, "Invalid IPv6 address: %s\n", ipstr);
return 1;
}
sa_len = sizeof(struct sockaddr_in6);
} else {
// IPv4
struct sockaddr_in *sa4 = (struct sockaddr_in *)&sa;
sa4->sin_family = AF_INET;
if (inet_pton(AF_INET, ipstr, &(sa4->sin_addr)) != 1) {
fprintf(stderr, "Invalid IPv4 address: %s\n", ipstr);
return 1;
}
sa_len = sizeof(struct sockaddr_in);
}
int rv = getnameinfo((struct sockaddr *)&sa, sa_len, host, sizeof(host), NULL, 0, NI_NAMEREQD);
if (rv != 0) {
fprintf(stderr, "getnameinfo: %s\n", gai_strerror(rv));
return 1;
}
printf("Reverse lookup: %s -> %s\n", ipstr, host);
return 0;
}
/* -----------------------------
方法 B：自实现简易 DNS 客户端（UDP）
仅支持查询 A(1) / AAAA(28) / CNAME (5)
----------------------------- */
/* DNS header: 12 bytes */
#pragma pack(push, 1)
struct dns_header {
unsigned short id;
unsigned short flags;
unsigned short qdcount;
unsigned short ancount;
unsigned short nscount;
unsigned short arcount;
};
#pragma pack(pop)
/* DNS question tail (type & class) */
struct dns_question_tail {
unsigned short qtype;
unsigned short qclass;
};
/* 资源记录固定头部（不含可变长度 NAME 与 RDATA） */
#pragma pack(push,1)
struct dns_rr_fixed {
unsigned short type;
unsigned short class;
unsigned int ttl;
unsigned short rdlength;
};
#pragma pack(pop)
/* 将域名从点分格式转换为 DNS 报文的标签格式：
e.g., "www.example.com" -> [3]www[7]example[3]com[0]
返回写入的字节数到 buf（不超过 buflen）。
*/
static int dns_name_pack(const char *name, unsigned char *buf, int buflen) {
int nlen = strlen(name);
if (nlen == 0) {
if (buflen < 1) return -1;
buf[0] = 0;
return 1;
}
int pos = 0;
const char *label = name;
const char *p = name;
while (1) {
if (*p == '.' || *p == '\0') {
int len = p - label;
if (len > 63) return -1; // label too long
if (pos + 1 + len >= buflen) return -1;
buf[pos++] = (unsigned char)len;
if (len > 0) {
memcpy(&buf[pos], label, len);
pos += len;
}
if (*p == '\0') {
// terminate with zero
if (pos >= buflen) return -1;
buf[pos++] = 0;
break;
}
label = p + 1;
}
p++;
}
return pos;
}
/* 解析 DNS 报文中的名称（包含指针压缩）
packet：完整报文起始地址
pktlen：报文总长度
offset：当前读取偏移（输入时指向名称开始），函数结束时 offset 会更新到名称后的第一个字节
out：输出缓冲区存放解析出的点分格式字符串
outlen：输出长度
返回：0 成功，-1 失败
*/
static int dns_name_unpack(unsigned char *packet, int pktlen, int *offset, char *out, int outlen) {
int orig_offset = *offset;
int pos = 0;
int jumped = 0;
int max_jumps = 0;
int cur = *offset;
while (cur < pktlen) {
unsigned char len = packet[cur];
if (len == 0) {
// end of name
if (!jumped) *offset = cur + 1;
if (pos == 0) {
// root
if (pos + 1 > outlen) return -1;
out[pos] = '\0';
} else {
if (pos + 1 > outlen) return -1;
out[pos] = '\0';
}
return 0;
}
if ((len & 0xC0) == 0xC0) {
// pointer: next byte + (len & 0x3F) << 8
if (cur + 1 >= pktlen) return -1;
int b2 = packet[cur + 1];
int pointer = ((len & 0x3F) << 8) | b2;
if (pointer >= pktlen) return -1;
if (!jumped) *offset = cur + 2;
cur = pointer;
jumped = 1;
if (++max_jumps > 10) return -1; // avoid loops
continue;
} else {
// label
cur++;
if (cur + len > pktlen) return -1;
if (pos + len + 1 >= outlen) return -1;
memcpy(out + pos, packet + cur, len);
pos += len;
out[pos++] = '.';
cur += len;
}
}
return -1;
}
/* 构造并发送 DNS 查询（type: 1=A, 28=AAAA）
dns_server: dotted IP string, e.g., "8.8.8.8"
name: 域名
type: qtype (1/A, 28/AAAA)
timeout_sec: 接收超时时间（秒）
返回：0 成功（并将打印解析结果），非0表示失败
*/
static int dns_query_simple(const char *dns_server, const char *name, unsigned short qtype, int timeout_sec) {
unsigned char buf[512];
memset(buf, 0, sizeof(buf));
struct dns_header hdr;
memset(&hdr, 0, sizeof(hdr));
srand((unsigned int)time(NULL));
hdr.id = (unsigned short) (rand() & 0xFFFF);
hdr.flags = htons(0x0100); // standard query, recursion desired
hdr.qdcount = htons(1);
// 写 header
memcpy(buf, &hdr, sizeof(hdr));
int offset = sizeof(hdr);
// 写 QNAME
int n = dns_name_pack(name, buf + offset, sizeof(buf) - offset);
if (n < 0) {
fprintf(stderr, "dns_name_pack failed\n");
return 1;
}
offset += n;
// 写 QTYPE & QCLASS
struct dns_question_tail qt;
qt.qtype = htons(qtype);
qt.qclass = htons(1); // IN
memcpy(buf + offset, &qt, sizeof(qt));
offset += sizeof(qt);
// 发送 UDP 包
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
perror("socket");
return 1;
}
struct sockaddr_in serv;
memset(&serv, 0, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(53);
if (inet_pton(AF_INET, dns_server, &serv.sin_addr) != 1) {
fprintf(stderr, "Invalid DNS server IP: %s\n", dns_server);
close(sock);
return 1;
}
// 发送并等待回复（带重试）
int tries = 3;
int rv = 1;
for (int t = 0; t < tries; t++) {
ssize_t sent = sendto(sock, buf, offset, 0, (struct sockaddr*)&serv, sizeof(serv));
if (sent != offset) {
perror("sendto");
continue;
}
// 设置 recv 超时
struct timeval tv;
tv.tv_sec = timeout_sec;
tv.tv_usec = 0;
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
unsigned char resp[4096];
struct sockaddr_in from;
socklen_t fromlen = sizeof(from);
ssize_t rlen = recvfrom(sock, resp, sizeof(resp), 0, (struct sockaddr*)&from, &fromlen);
if (rlen < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
// timeout
if (t == tries - 1) {
fprintf(stderr, "DNS query timeout\n");
} else {
// retry
continue;
}
} else {
perror("recvfrom");
}
continue;
}
// parse response
if (rlen < (ssize_t)sizeof(struct dns_header)) {
fprintf(stderr, "DNS response too short\n");
continue;
}
struct dns_header rhdr;
memcpy(&rhdr, resp, sizeof(rhdr));
unsigned short qdcount = ntohs(rhdr.qdcount);
unsigned short ancount = ntohs(rhdr.ancount);
// skip questions
int roff = sizeof(struct dns_header);
for (int i = 0; i < qdcount; i++) {
char qname[256];
if (dns_name_unpack(resp, rlen, &roff, qname, sizeof(qname)) != 0) {
fprintf(stderr, "Failed to unpack question name\n");
break;
}
// skip qtype & qclass
if (roff + sizeof(struct dns_question_tail) > rlen) break;
roff += sizeof(struct dns_question_tail);
}
// parse answers
printf("Answers (%d):\n", ancount);
for (int i = 0; i < ancount; i++) {
char aname[512];
if (dns_name_unpack(resp, rlen, &roff, aname, sizeof(aname)) != 0) {
fprintf(stderr, "Failed to unpack answer name\n");
break;
}
if (roff + sizeof(struct dns_rr_fixed) > rlen) {
fprintf(stderr, "Truncated RR header\n");
break;
}
struct dns_rr_fixed rrf;
memcpy(&rrf, resp + roff, sizeof(rrf));
roff += sizeof(rrf);
unsigned short type = ntohs(rrf.type);
unsigned short rclass = ntohs(rrf.class);
unsigned short rdlen = ntohs(rrf.rdlength);
if (roff + rdlen > rlen) {
fprintf(stderr, "Truncated RDATA\n");
break;
}
if (type == 1 && rdlen == 4) {
// A
char addrbuf[INET_ADDRSTRLEN];
inet_ntop(AF_INET, resp + roff, addrbuf, sizeof(addrbuf));
printf(" NAME: %s TYPE=A ADDR=%s\n", aname, addrbuf);
} else if (type == 28 && rdlen == 16) {
// AAAA
char addrbuf[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, resp + roff, addrbuf, sizeof(addrbuf));
printf(" NAME: %s TYPE=AAAA ADDR=%s\n", aname, addrbuf);
} else if (type == 5) {
// CNAME (rdata is a name)
int tmp_off = roff;
char cname[512];
if (dns_name_unpack(resp, rlen, &tmp_off, cname, sizeof(cname)) == 0) {
printf(" NAME: %s TYPE=CNAME RDATA=%s\n", aname, cname);
} else {
printf(" NAME: %s TYPE=CNAME (unpack failed)\n", aname);
}
} else {
printf(" NAME: %s TYPE=%d (rdlen=%d bytes)\n", aname, type, rdlen);
}
roff += rdlen;
}
rv = 0; // success
break;
}
close(sock);
return rv;
}
/* -----------------------------
简单命令行接口
支持:
resolver sys <domain>
resolver reverse sys <ip>
resolver dns <dns_server> <domain>
----------------------------- */
int main(int argc, char *argv[]) {
if (argc < 3) {
fprintf(stderr, "Usage:\n");
fprintf(stderr, " %s sys <domain> # use system resolver\n", argv[0]);
fprintf(stderr, " %s reverse sys <ip> # reverse lookup via system resolver\n", argv[0]);
fprintf(stderr, " %s dns <dns_server> <domain> # use custom DNS client\n", argv[0]);
return 1;
}
if (strcmp(argv[1], "sys") == 0) {
// system resolver
return resolve_with_getaddrinfo(argv[2]);
} else if (strcmp(argv[1], "reverse") == 0 && argc >= 4 && strcmp(argv[2], "sys") == 0) {
return reverse_with_getnameinfo(argv[3]);
} else if (strcmp(argv[1], "dns") == 0 && argc >= 4) {
const char *dns_server = argv[2];
const char *domain = argv[3];
// query A and AAAA
printf("Query A records via DNS server %s for %s\n", dns_server, domain);
dns_query_simple(dns_server, domain, 1, 2);
printf("\nQuery AAAA records via DNS server %s for %s\n", dns_server, domain);
dns_query_simple(dns_server, domain, 28, 2);
return 0;
} else {
fprintf(stderr, "Unknown command or insufficient args\n");
return 1;
}
}
|
0
0
已为社区贡献31条内容
所有评论(0)