自己实现gethostbyname

#define点击(此处)折叠或打开

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <sys/socket.h>
   
5. #include <sys/types.h>
   
6. #include <netinet/in.h>
   
7. #include <arpa/inet.h>
   
8. #include <unistd.h>
   
9. #include <errno.h>
   
10. #include <sys/stat.h>
    
11. #include <sys/epoll.h>
    
12. #include <time.h>
    
13. 
    
14. #define BUF_SIZE 1024
    
15. #define SRV_PORT 53
    
16. #define DNS_FILE "/etc/resolv.conf"
    
17. 
    
18. typedef unsigned short U16;
    
19. //const char srv_ip[] = "208.67.222.222";
    
20. 
    
21. typedef struct _DNS_HDR
    
22. {
    
23.     U16 id;
    
24.     U16 tag;
    
25.     U16 numq;
    
26.     U16 numa;
    
27.     U16 numa1;
    
28.     U16 numa2;
    
29. }DNS_HDR;
    
30. 
    
31. typedef struct _DNS_QER
    
32. {
    
33.     U16 type;
    
34.     U16 classes;
    
35. }DNS_QER;
    
36. 
    
37. char* get_dns_ip(void)
    
38. {
    
39.     FILE* fp = NULL;
    
40.     static char addr[32] = {''};
    
41. 
    
42.     fp = fopen(DNS_FILE, "r");
    
43.     if(fp == NULL)
    
44.         return NULL;
    
45.     
    
46.     fscanf(fp, "nameserver %s", addr);
    
47. 
    
48.     fclose(fp);
    
49.     return addr;
    
50. }
    
51. 
    
52. char* strtrim(char* str)
    
53. {
    
54.     char*p = NULL;
    
55.     char*q = NULL;
    
56. 
    
57.     p = str;
    
58.     q = str + strlen(str) - 1;
    
59.     while(isspace(*p))
    
60.         p++;
    
61.     while(isspace(*q))
    
62.         q--;
    
63.     *(q + 1) = '';
    
64.     return p;
    
65. }
    
66. 
    
67. char* get_reverct_ip(char* ipaddr)
    
68. {
    
69.     if (ipaddr == NULL)
    
70.         return NULL;
    
71.     char ipstr[INET_ADDRSTRLEN] = {'',};
    
72.     static char retstr[32] = {0};
    
73.     char a[4][4];
    
74.     struct in_addr addr1, addr2;
    
75.     memset(&addr1, 0, sizeof(addr1));
    
76.     memset(&addr2, 0, sizeof(addr2));
    
77.     int i, j;
    
78.     char *p = NULL;
    
79.     for (i = 0; i < 4; i++)
    
80.     {
    
81.         for (j = 0; j < 4; j++)
    
82.             a[i][j] = '';
    
83.     }
    
84.     i = 0;
    
85.     p = strtok(ipaddr, ".");
    
86.     while (p)
    
87.     {
    
88.         strcpy(a[i++], p);
    
89.         p = strtok(NULL, ".");
    
90.     }
    
91.     sprintf(retstr, "%s.%s.%s.%s.in-addr.arpa", a[3],a[2],a[1],a[0]);
    
92. 
    
93. #if 0
    
94.     inet_pton(AF_INET, ipaddr, &addr1);
    
95.     addr2.s_addr = ntohl(addr1.s_addr);
    
96.     inet_ntop(AF_INET, &addr2, ipstr, sizeof(ipstr));
    
97.     sprintf(retstr, "%s.in-addr.arpa", ipstr);
    
98. #endif
    
99. 
    
100.     return retstr;
     
101. }
     
102. 
     
103. int main(int argc, char** argv)
     
104. {
     
105.     int clifd, len = 0, i,count=0;
     
106.     int ipv4 = 0, ipv6 = 0;
     
107.     socklen_t socklen = 0;
     
108.     char buf[BUF_SIZE] = {''};
     
109.     char tmpip[32] = {''};
     
110.     char *p = NULL;
     
111.     char *ipaddr = NULL;
     
112.     char *ipaddr2 = NULL;
     
113.     time_t sendtime = 0, recvtime = 0, caltime = 0;
     
114.     struct sockaddr_in servaddr;
     
115.     struct sockaddr_in6 servaddr6;
     
116.     struct timeval pretime, aftertime, tv;
     
117.     memset(&tv, '', sizeof(tv));
     
118. 
     
119.     if (strchr(argv[1], '.'))
     
120.         ipv4 = 1;    
     
121.     else if (strchr(argv[1], ':'))
     
122.         ipv6 = 1;
     
123.     else
     
124.         return -1;
     
125. 
     
126.     ipaddr = get_dns_ip();
     
127.     if (ipv4)
     
128.     {
     
129.         clifd = socket(AF_INET, SOCK_DGRAM, 0 );
     
130.         if (clifd < 0)
     
131.         {
     
132.             printf( " create socket error!\n " );
     
133.             return -1;
     
134.         }
     
135.         bzero(&servaddr, sizeof(servaddr));
     
136.         servaddr.sin_family = AF_INET;
     
137.         servaddr.sin_port = htons(SRV_PORT);
     
138.         inet_pton(AF_INET, ipaddr, &servaddr.sin_addr);
     
139.     }
     
140.     else if (ipv6)
     
141.     {
     
142.         clifd = socket(AF_INET6, SOCK_DGRAM, 0 );
     
143.         if (clifd < 0)
     
144.         {
     
145.             printf( " create socket error!\n " );
     
146.             return -1;
     
147.         }
     
148.         bzero(&servaddr6, sizeof(servaddr6));
     
149.         servaddr6.sin6_family = AF_INET6;
     
150.         servaddr6.sin6_port = htons(SRV_PORT);
     
151.         inet_pton(AF_INET6, ipaddr, &servaddr6.sin6_addr);
     
152.     }
     
153.     
     
154.     DNS_HDR *dnshdr = (DNS_HDR *)buf;
     
155.     DNS_QER *dnsqer = (DNS_QER *)(buf + sizeof(DNS_HDR));
     
156.     memset(buf, 0, BUF_SIZE);
     
157.     dnshdr->id = (U16)1;
     
158.     dnshdr->tag = htons(0x0100);
     
159.     dnshdr->numq = htons(1);
     
160.     dnshdr->numa = 0;
     
161. 
     
162.     strncpy(buf + sizeof(DNS_HDR) + 1, argv[1], strlen(argv[1]));
     
163.     p = buf + sizeof(DNS_HDR) + 1;
     
164.     i = 0;
     
165.     while (p < (buf + sizeof(DNS_HDR) + 1 + strlen(argv[1])))
     
166.     {
     
167.         if ( *p == '.')
     
168.         {
     
169.             *(p - i - 1) = i;
     
170.             i = 0;
     
171.         }
     
172.         else
     
173.         {
     
174.             i++;
     
175.         }
     
176.         p++;
177.     }
     
178.     *(p - i - 1) = i;
     
179.     
     
180.     dnsqer = (DNS_QER *)(buf + sizeof(DNS_HDR) + 2 + strlen(argv[1]));
     
181.     dnsqer->classes = htons(1);
     
182.     dnsqer->type = htons(1);
     
183.   
     
184.     tv.tv_sec = 2;
     
185.     tv.tv_usec = 0;
     
186.     gettimeofday(&pretime, NULL);
     
187.     if (ipv4)
     
188.     {
     
189.         setsockopt(clifd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
     
190.         socklen = sizeof(struct sockaddr_in);
     
191.   
     
192.         len = sendto(clifd, buf, sizeof(DNS_HDR) + sizeof(DNS_QER) + strlen(argv[1]) + 2, 0, (struct sockaddr *)&servaddr, socklen);
     
193.         if (len < 0)
     
194.         {
     
195.             printf("send error\n");
     
196.             return -1;
     
197.         }
     
198.         len = recvfrom(clifd, buf, BUF_SIZE, 0, (struct sockaddr *)&servaddr, &socklen);
     
199.         if (len < 0)
     
200.         {
     
201.             if (errno == EAGAIN)
     
202.             {
     
203.                 printf("recvfrom timeout!\n");
     
204.             }
     
205.         }
     
206.     }
     
207.     else
     
208.     {
     
209.         setsockopt(clifd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
     
210.         socklen = sizeof(struct sockaddr_in6);
     
211.         len = sendto(clifd, buf, sizeof(DNS_HDR) + sizeof(DNS_QER) + strlen(argv[1]) + 2, 0, (struct sockaddr *)&servaddr6, socklen);
     
212.         if (len < 0)
     
213.         {
     
214.             printf("send error\n");
     
215.             return -1;
     
216.         }
     
217.         len = recvfrom(clifd, buf, BUF_SIZE, 0, (struct sockaddr *)&servaddr6, &socklen);
     
218.         if (len < 0)
     
219.         {
     
220.             if (errno == EAGAIN)
     
221.             {
     
222.                 fprintf(stdout, "recvfrom timeout!\n");
     
223.             }
     
224.         }
     
225.     }
     
226.     gettimeofday(&aftertime, NULL);
     
227.     fprintf(stdout, "time ==> %d \n", (aftertime.tv_sec - pretime.tv_sec)*1000 + (aftertime.tv_usec - pretime.tv_usec)/1000);
     
228.     
     
229.     printf("answer: %d\n", dnshdr->numa);
     
230.     if (dnshdr->numa == 0)
     
231.     {
     
232.         printf("ack error\n");
     
233.         return -1;
     
234.     }
235. 
     
236.     p = buf + len -4;
     
237.     printf("%s ==> %u.%u.%u.%u\n",argv[1], (unsigned char)*p, (unsigned char)*(p + 1),(unsigned char)*(p + 2), (unsigned char)*(p + 3));
     
238.   
     
239.     close(clifd);
     
240.     return 0;
     
241. }