Cannot ship the portage part, due to the MD5 sum.
[icmp-dn.git] / src / icmpdnd.c
1 /*
2  *  icmpdnd - ICMP Domain Name responder daemon 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 <syslog.h>
25 #include <time.h>
26 #include <sys/socket.h>
27 #include <sys/poll.h>
28 #include <netinet/in.h>
29 #include <arpa/inet.h>
30 #include <netinet/ip.h>
31 #include <sys/types.h>
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 struct icmphdr {
37     u_int8_t type;
38     u_int8_t code;
39     u_int16_t checksum;
40 };
41
42 struct reqhdr {
43     u_int8_t type;
44     u_int8_t code;
45     u_int16_t checksum;
46     u_int16_t id;
47     u_int16_t seq;
48 };
49
50 struct rephdr {
51     u_int8_t type;
52     u_int8_t code;
53     u_int16_t checksum;
54     u_int16_t id;
55     u_int16_t seq;
56     int32_t ttl;
57 };
58
59 #define ICMP_NAMEREQ 37
60 #define ICMP_NAMEREP 38
61
62 volatile int alive;
63
64 size_t filldn(char *dst)
65 {
66     char *p, *p2, *dp;
67     char namebuf[1024];
68     int hl;
69     
70     if(gethostname(namebuf, sizeof(namebuf)) < 0) {
71         perror("gethostname");
72         exit(1);
73     }
74     hl = strlen(namebuf);
75     namebuf[hl++] = '.';
76     if(getdomainname(namebuf + hl, sizeof(namebuf) - hl) < 0) {
77         perror("getdomainname");
78         exit(1);
79     }
80     if(strlen(namebuf + hl) != 0) {
81         hl = strlen(namebuf);
82         namebuf[hl++] = '.';
83     }
84     namebuf[hl] = 0;
85     
86     p = namebuf;
87     dp = dst;
88     while((p2 = strchr(p, '.')) != NULL) {
89         *p2 = 0;
90         *(dp++) = p2 - p;
91         memcpy(dp, p, p2 - p);
92         dp += p2 - p;
93         p = p2 + 1;
94     }
95     *(dp++) = 0;
96     
97     return(dp - dst);
98 }
99
100 void cksum(void *hdr, size_t len)
101 {
102     struct icmphdr *ih;
103     u_int8_t *cb;
104     int i;
105     int b1, b2;
106     
107     ih = (struct icmphdr *)hdr;
108     cb = (u_int8_t *)hdr;
109     ih->checksum = 0;
110     b1 = b2 = 0;
111     for(i = 0; i < (len & ~1); i += 2) {
112         b1 += cb[i];
113         b2 += cb[i + 1];
114     }
115     if(i & 1)
116         b1 += cb[len - 1];
117     while(1) {
118         if(b1 >= 256) {
119             b2 += b1 >> 8;
120             b1 &= 0xff;
121             continue;
122         }
123         if(b2 >= 256) {
124             b1 += b2 >> 8;
125             b2 &= 0xff;
126             continue;
127         }
128         break;
129     }
130     cb = (u_int8_t *)&ih->checksum;
131     cb[0] = ~(u_int8_t)b1;
132     cb[1] = ~(u_int8_t)b2;
133 }
134
135 int main(int argc, char **argv)
136 {
137     int i, n, ret;
138     int c, cs, s4, s6, datalen;
139     int daemonize, ttl;
140     unsigned char buf[65536];
141     struct sockaddr_storage name;
142     struct reqhdr req;
143     struct rephdr rep;
144     struct iphdr iphdr;
145     struct msghdr mhdr;
146     struct iovec iov;
147     char cmsgbuf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
148     size_t hdrlen;
149     struct pollfd pfd[2];
150     time_t curtime, lasterr;
151     
152     daemonize = 1;
153     ttl = 3600;
154     while((c = getopt(argc, argv, "nht:")) != -1) {
155         switch(c) {
156         case 't':
157             ttl = atoi(optarg);
158             break;
159         case 'n':
160             daemonize = 0;
161             break;
162         case 'h':
163         case '?':
164         case ':':
165         default:
166             fprintf(stderr, "usage: icmpdnd [-n]");
167             exit((c == 'h')?0:1);
168         }
169     }
170     
171     s4 = socket(PF_INET, SOCK_RAW, IPPROTO_ICMP);
172     s6 = socket(PF_INET6, SOCK_RAW, IPPROTO_ICMP);
173     if((s4 < 0) && (s6 < 0)) {
174         perror("could not open raw socket");
175         exit(1);
176     }
177     if(s6 >= 0) {
178         i = 1;
179         if(setsockopt(s6, IPPROTO_IPV6, IPV6_PKTINFO, &i, sizeof(i))) {
180             perror("could not set IPV6_PKTINFO sockopt");
181             exit(1);
182         }
183     }
184     
185     if(daemonize)
186         daemon(0, 0);
187     
188     openlog("icmpdnd", LOG_PID | LOG_NDELAY, LOG_DAEMON);
189     
190     alive = 1;
191     lasterr = 0;
192     while(alive) {
193         n = 0;
194         if(s4 >= 0) {
195             pfd[n].fd = s4;
196             pfd[n].events = POLLIN;
197             n++;
198         }
199         if(s6 >= 0) {
200             pfd[n].fd = s6;
201             pfd[n].events = POLLIN;
202             n++;
203         }
204         ret = poll(pfd, n, -1);
205
206         curtime = time(NULL);
207         if(ret < 0) {
208             if(errno == EINTR)
209                 continue;
210             syslog(LOG_ERR, "error while polling sockets: %m");
211             if(lasterr == curtime) {
212                 syslog(LOG_CRIT, "exiting due to repeated errors");
213                 exit(1);
214             }
215             lasterr = curtime;
216         }
217         
218         for(i = 0; i < n; i++) {
219             if((pfd[i].revents & POLLIN) == 0)
220                 continue;
221             cs = pfd[i].fd;
222             memset(&name, 0, sizeof(name));
223             
224             iov.iov_len = sizeof(buf);
225             iov.iov_base = buf;
226             mhdr.msg_name = &name;
227             mhdr.msg_namelen = sizeof(name);
228             mhdr.msg_iov = &iov;
229             mhdr.msg_iovlen = 1;
230             mhdr.msg_control = cmsgbuf;
231             mhdr.msg_controllen = sizeof(cmsgbuf);
232             
233             ret = recvmsg(cs, &mhdr, 0);
234             if(ret < 0) {
235                 syslog(LOG_WARNING, "error while receiving datagram: %m");
236                 continue;
237             }
238             
239             if(cs == s4) {
240                 if(ret < sizeof(iphdr) + sizeof(req))
241                     continue;
242                 hdrlen = sizeof(iphdr);
243                 memcpy(&iphdr, buf, sizeof(iphdr));
244                 if(iphdr.protocol != IPPROTO_ICMP)
245                     continue;
246                 mhdr.msg_control = NULL;
247                 mhdr.msg_controllen = 0;
248             } else if(cs == s6) {
249                 if(ret < sizeof(req))
250                     continue;
251                 ((struct sockaddr_in6 *)&name)->sin6_port = 0;
252                 hdrlen = 0;
253                 /* Just keep mhdr.msg_control. */
254             } else {
255                 syslog(LOG_CRIT, "strangeness!");
256                 abort();
257             }
258             memcpy(&req, buf + hdrlen, sizeof(req));
259             if(req.type != ICMP_NAMEREQ)
260                 continue;
261             rep.type = ICMP_NAMEREP;
262             rep.code = 0;
263             rep.id = req.id;
264             rep.seq = req.seq;
265             rep.ttl = htonl(ttl);
266             memcpy(buf, &rep, sizeof(rep));
267             datalen = filldn(buf + sizeof(rep));
268         
269             cksum(buf, datalen + sizeof(rep));
270             
271             iov.iov_len = sizeof(rep) + datalen;
272             iov.iov_base = buf;
273             mhdr.msg_iov = &iov;
274             mhdr.msg_iovlen = 1;
275             ret = sendmsg(cs, &mhdr, 0);
276             if(ret < 0)
277                 syslog(LOG_WARNING, "error in sending reply: %m");
278         }
279     }
280     
281     close(s4);
282     close(s6);
283     return(0);
284 }
285
286 /*
287  * Local Variables:
288  * compile-command: "gcc -Wall -g -o icmpdnd icmpdnd.c"
289  * End:
290  */