43518ef28fae6ff1bb8fe205e4a34425292eb8bd
[icmp-dn.git] / idnlookup.c
1 /*
2  *  idnlookup - ICMP Domain Name lookup utility for Linux
3  *  Copyright (C) 2005 Fredrik Tolf <fredrik@dolda2000.com>
4  *  
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License as published by
7  *  the Free Software Foundation; either version 2 of the License, or
8  *  (at your option) any later version.
9  *  
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *  
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 */
19 #include <stdlib.h>
20 #include <unistd.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <netdb.h>
25 #include <sys/socket.h>
26 #include <netinet/in.h>
27 #include <netinet/ip.h>
28 #include <arpa/inet.h>
29 #include <sys/types.h>
30 #include <sys/poll.h>
31 #include <sys/time.h>
32
33 struct icmphdr {
34     u_int8_t type;
35     u_int8_t code;
36     u_int16_t checksum;
37 };
38
39 struct reqhdr {
40     u_int8_t type;
41     u_int8_t code;
42     u_int16_t checksum;
43     u_int16_t id;
44     u_int16_t seq;
45 };
46
47 struct rephdr {
48     u_int8_t type;
49     u_int8_t code;
50     u_int16_t checksum;
51     u_int16_t id;
52     u_int16_t seq;
53     int32_t ttl;
54     
55 };
56
57 #define ICMP_NAMEREQ 37
58 #define ICMP_NAMEREP 38
59
60 unsigned char buf[65536];
61
62 /* DN decompression not yet implemented, since I don't know where to
63  * begin counting the offset from -- the beginning of the ICMP
64  * payload, or from the beginning of the DN data buffer? */
65 void printdn(FILE *f, unsigned char *dnbuf, size_t size)
66 {
67     unsigned char *p;
68     
69     p = dnbuf;
70     while(p - dnbuf < size) {
71         while(*p != 0) {
72             if(*p & 0xc0) {
73                 fprintf(stderr, "domain name decompression not implemented, aborting\n");
74                 exit(1);
75             }
76             printf("%.*s.", (int)*p, p + 1);
77             p += 1 + (int)*p;
78         }
79         p++;
80         printf("\n");
81     }
82 }
83
84 void cksum(void *hdr, size_t len)
85 {
86     struct icmphdr *ih;
87     u_int8_t *cb;
88     int i;
89     int b1, b2;
90     
91     ih = (struct icmphdr *)hdr;
92     cb = (u_int8_t *)hdr;
93     ih->checksum = 0;
94     b1 = b2 = 0;
95     for(i = 0; i < (len & ~1); i += 2) {
96         b1 += cb[i];
97         b2 += cb[i + 1];
98     }
99     if(i & 1)
100         b1 += cb[len - 1];
101     while(1) {
102         if(b1 >= 256) {
103             b2 += b1 >> 8;
104             b1 &= 0xff;
105             continue;
106         }
107         if(b2 >= 256) {
108             b1 += b2 >> 8;
109             b2 &= 0xff;
110             continue;
111         }
112         break;
113     }
114     cb = (u_int8_t *)&ih->checksum;
115     cb[0] = ~(u_int8_t)b1;
116     cb[1] = ~(u_int8_t)b2;
117 }
118
119 void usage(void)
120 {
121     fprintf(stderr, "usage: idnlookup [-h] [-t timeout] host\n");
122 }
123
124 int main(int argc, char **argv)
125 {
126     int ret;
127     int s, c;
128     int id;
129     int namelen;
130     struct reqhdr req;
131     struct rephdr rep;
132     struct iphdr iphdr;
133     struct addrinfo *ai, *cai, aihint;
134     struct pollfd pfd;
135     struct timeval tvb, tvc;
136     struct sockaddr_storage name;
137     int timeout, elapsed;
138     
139     timeout = 3000;
140     while((c = getopt(argc, argv, "ht:")) != -1) {
141         switch(c) {
142         case 't':
143             timeout = atoi(optarg);
144             break;
145         case 'h':
146         case '?':
147         case ':':
148         default:
149             usage();
150             exit((c == 'h')?0:1);
151         }
152     }
153     
154     if(argc - optind < 1) {
155         usage();
156         exit(1);
157     }
158     
159     memset(&aihint, 0, sizeof(aihint));
160     aihint.ai_family = PF_INET; /* Only IPv4 for now. */
161     aihint.ai_socktype = SOCK_RAW;
162     aihint.ai_protocol = IPPROTO_ICMP;
163     ret = getaddrinfo(argv[optind], NULL, &aihint, &ai);
164     
165     for(cai = ai; cai != NULL; cai = cai->ai_next) {
166         if((s = socket(cai->ai_family, SOCK_RAW, IPPROTO_ICMP)) < 0) {
167             perror("could not create raw socket");
168             exit(1);
169         }
170         
171         id = random() % 65536;
172         memset(&req, 0, sizeof(req));
173         req.type = ICMP_NAMEREQ;
174         req.id = htons(id);
175         cksum(&req, sizeof(req));
176         
177         ret = sendto(s, &req, sizeof(req), 0, cai->ai_addr, cai->ai_addrlen);
178         if(ret < 0) {
179             perror("sendto");
180             exit(1);
181         } else if(ret != sizeof(req)) {
182             fprintf(stderr, "socket would not send entire packet\n");
183             exit(1);
184         }
185         
186         gettimeofday(&tvb, NULL);
187         while(1) {
188             pfd.fd = s;
189             pfd.events = POLLIN;
190             gettimeofday(&tvc, NULL);
191             elapsed = ((tvc.tv_sec - tvb.tv_sec) * 1000) + ((tvc.tv_usec - tvb.tv_usec) / 1000);
192             if(elapsed > timeout) {
193                 fprintf(stderr, "idnlookup: timeout\n");
194                 exit(1);
195             }
196             ret = poll(&pfd, 1, timeout - elapsed);
197             if(ret < 0) {
198                 perror("idnlookup: reading data");
199                 exit(1);
200             }
201             
202             if(pfd.revents & POLLIN) {
203                 namelen = sizeof(name);
204                 ret = recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr *)&name, &namelen);
205                 if(ret < 0) {
206                     perror("idnlookup: receiving data");
207                     exit(1);
208                 }
209                 
210                 if(name.ss_family != cai->ai_addr->sa_family)
211                     continue;
212                 if(name.ss_family == AF_INET) {
213                     if(memcmp(&(((struct sockaddr_in *)&name)->sin_addr), &(((struct sockaddr_in *)cai->ai_addr)->sin_addr), sizeof(struct in_addr)))
214                         continue;
215                 } else if(name.ss_family == AF_INET6) {
216                     if(memcmp(&(((struct sockaddr_in6 *)&name)->sin6_addr), &(((struct sockaddr_in6 *)cai->ai_addr)->sin6_addr), sizeof(struct in6_addr)))
217                         continue;
218                 } else {
219                     continue;
220                 }
221                 
222                 if(ret < sizeof(iphdr) + sizeof(rep))
223                     continue;
224                 memcpy(&iphdr, buf, sizeof(iphdr));
225                 memcpy(&rep, buf + sizeof(iphdr), sizeof(rep));
226                 if(iphdr.protocol != IPPROTO_ICMP)
227                     continue;
228                 if(rep.type != ICMP_NAMEREP)
229                     continue;
230                 if((ntohs(rep.id) != id) || (ntohs(rep.seq != 0)))
231                     continue;
232                 
233                 break;
234             }
235         }
236         
237         printdn(stdout, buf + sizeof(iphdr) + sizeof(rep), ret - sizeof(iphdr) - sizeof(rep));
238         
239         close(s);
240     }
241     
242     return(0);
243 }