![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dns.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / ui|
Return to dns.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / ui |
1.1 misho 1: /*
2: mtr -- a network diagnostic tool
3: Copyright (C) 1997,1998 Matt Kimball
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 version 2 as
7: published by the Free Software Foundation.
8:
9: This program is distributed in the hope that it will be useful,
10: but WITHOUT ANY WARRANTY; without even the implied warranty of
11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12: GNU General Public License for more details.
13:
14: You should have received a copy of the GNU General Public License
15: along with this program; if not, write to the Free Software
16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: /*
20: Non-blocking DNS portion --
21: Copyright (C) 1998 by Simon Kirby <sim@neato.org>
22: Released under GPL, as above.
23: */
24:
25: #include "config.h"
26:
27: #ifdef HAVE_ERROR_H
28: #include <error.h>
29: #else
30: #include "portability/error.h"
31: #endif
32: #include <errno.h>
33: #include <unistd.h>
34: #include <fcntl.h>
35: #include <string.h>
36: #include <stdio.h>
37: #include <stdlib.h>
38: #include <signal.h>
39:
40: #include "mtr.h"
41: #include "dns.h"
42: #include "net.h"
43: #include "utils.h"
44:
45: struct dns_results {
46: ip_t ip;
47: char *name;
48: struct dns_results *next;
49: };
50:
51: static struct dns_results *results;
52:
53: char *strlongip(
54: struct mtr_ctl *ctl,
55: ip_t * ip)
56: {
57: #ifdef ENABLE_IPV6
58: static char addrstr[INET6_ADDRSTRLEN];
59:
60: return (char *) inet_ntop(ctl->af, ip, addrstr, sizeof addrstr);
61: #else
62: return inet_ntoa(*ip);
63: #endif
64: }
65:
66:
67: #ifdef ENABLE_IPV6
68: #define UNUSED_IF_NO_IPV6 /* empty */
69: #else
70: #define UNUSED_IF_NO_IPV6 ATTRIBUTE_UNUSED
71: #endif
72:
73: static int todns[2], fromdns[2];
74: static FILE *fromdnsfp;
75:
76: static int longipstr(
77: char *s,
78: ip_t * dst,
79: int family UNUSED_IF_NO_IPV6)
80: {
81: #ifdef ENABLE_IPV6
82: return inet_pton(family, s, dst);
83: #else
84: return inet_aton(s, dst);
85: #endif
86: }
87:
88:
89: struct hostent *dns_forward(
90: const char *name)
91: {
92: struct hostent *host;
93:
94: if ((host = gethostbyname(name)))
95: return host;
96: else
97: return NULL;
98: }
99:
100:
101: static struct dns_results *findip(
102: struct mtr_ctl *ctl,
103: ip_t * ip)
104: {
105: struct dns_results *t;
106:
107: for (t = results; t; t = t->next) {
108: if (addrcmp((void *) ip, (void *) &t->ip, ctl->af) == 0)
109: return t;
110: }
111:
112: return NULL;
113: }
114:
115: static void set_sockaddr_ip(
116: struct mtr_ctl *ctl,
117: struct sockaddr_storage *sa,
118: ip_t * ip)
119: {
120: struct sockaddr_in *sa_in;
121: struct sockaddr_in6 *sa_in6;
122:
123: memset(sa, 0, sizeof(struct sockaddr_storage));
124: switch (ctl->af) {
125: case AF_INET:
126: sa_in = (struct sockaddr_in *) sa;
127: sa_in->sin_family = ctl->af;
128: addrcpy((void *) &sa_in->sin_addr, (void *) ip, ctl->af);
129: break;
130: case AF_INET6:
131: sa_in6 = (struct sockaddr_in6 *) sa;
132: sa_in6->sin6_family = ctl->af;
133: addrcpy((void *) &sa_in6->sin6_addr, (void *) ip, ctl->af);
134: break;
135: }
136: }
137:
138: void dns_open(
139: struct mtr_ctl *ctl)
140: {
141: int pid;
142:
143: if (pipe(todns) < 0) {
144: error(EXIT_FAILURE, errno, "can't make a pipe for DNS process");
145: }
146:
147: if (pipe(fromdns) < 0) {
148: error(EXIT_FAILURE, errno, "can't make a pipe for DNS process");
149: }
150: fflush(stdout);
151: pid = fork();
152: if (pid < 0) {
153: error(EXIT_FAILURE, errno, "can't fork for DNS process");
154: }
155: if (pid == 0) {
156: char buf[2048];
157: int i;
158: FILE *infp;
159:
160: /* Automatically reap children. */
161: if (signal(SIGCHLD, SIG_IGN) == SIG_ERR) {
162: error(EXIT_FAILURE, errno, "signal");
163: }
164:
165: /* Close all unneccessary FDs.
166: for debugging and error reporting, keep std-in/out/err. */
167: for (i = 3; i < fromdns[1]; i++) {
168: if (i == todns[0])
169: continue;
170: if (i == fromdns[1])
171: continue;
172: close(i);
173: }
174: infp = fdopen(todns[0], "r");
175:
176: while (fgets(buf, sizeof(buf), infp)) {
177: ip_t host;
178: struct sockaddr_storage sa;
179: socklen_t salen;
180: char hostname[NI_MAXHOST];
181: char result[INET6_ADDRSTRLEN + NI_MAXHOST + 2];
182:
183: if (!fork()) {
184: int rv;
185:
186: buf[strlen(buf) - 1] = 0; /* chomp newline. */
187:
188: longipstr(buf, &host, ctl->af);
189: set_sockaddr_ip(ctl, &sa, &host);
190: salen = (ctl->af == AF_INET) ? sizeof(struct sockaddr_in) :
191: sizeof(struct sockaddr_in6);
192:
193: rv = getnameinfo((struct sockaddr *) &sa, salen,
194: hostname, sizeof(hostname), NULL, 0, 0);
195: if (rv == 0) {
196: snprintf(result, sizeof(result),
197: "%s %s\n", strlongip(ctl, &host), hostname);
198:
199: rv = write(fromdns[1], result, strlen(result));
200: if (rv < 0)
201: error(0, errno, "write DNS lookup result");
202: }
203:
204: exit(EXIT_SUCCESS);
205: }
206: }
207: exit(EXIT_SUCCESS);
208: } else {
209: int flags;
210:
211: /* the parent. */
212: close(todns[0]); /* close the pipe ends we don't need. */
213: close(fromdns[1]);
214: fromdnsfp = fdopen(fromdns[0], "r");
215: flags = fcntl(fromdns[0], F_GETFL, 0);
216: flags |= O_NONBLOCK;
217: fcntl(fromdns[0], F_SETFL, flags);
218: }
219: }
220:
221: int dns_waitfd(
222: void)
223: {
224: return fromdns[0];
225: }
226:
227:
228: void dns_ack(
229: struct mtr_ctl *ctl)
230: {
231: char buf[2048], host[NI_MAXHOST], name[NI_MAXHOST];
232: ip_t hostip;
233: struct dns_results *r;
234:
235: while (fgets(buf, sizeof(buf), fromdnsfp)) {
236: sscanf(buf, "%s %s", host, name);
237:
238: longipstr(host, &hostip, ctl->af);
239: r = findip(ctl, &hostip);
240: if (r)
241: r->name = xstrdup(name);
242: else
243: error(0, 0, "dns_ack: Couldn't find host %s", host);
244: }
245: }
246:
247:
248:
249: #ifdef ENABLE_IPV6
250:
251: int dns_waitfd6(
252: void)
253: {
254: return -1;
255: }
256:
257: void dns_ack6(
258: void)
259: {
260: return;
261: }
262:
263: #endif
264:
265:
266: char *dns_lookup2(
267: struct mtr_ctl *ctl,
268: ip_t * ip)
269: {
270: struct dns_results *r;
271: char buf[INET6_ADDRSTRLEN + 1];
272: int rv;
273:
274: r = findip(ctl, ip);
275: if (r) {
276: /* we've got a result. */
277: if (r->name)
278: return r->name;
279: else
280: return strlongip(ctl, ip);
281: } else {
282: r = xmalloc(sizeof(struct dns_results));
283: memcpy(&r->ip, ip, sizeof(r->ip));
284: r->name = NULL;
285: r->next = results;
286: results = r;
287: snprintf(buf, sizeof(buf), "%s\n", strlongip(ctl, ip));
288: rv = write(todns[1], buf, strlen(buf));
289: if (rv < 0)
290: error(0, errno, "couldn't write to resolver process");
291: }
292: return strlongip(ctl, ip);
293: }
294:
295:
296: char *dns_lookup(
297: struct mtr_ctl *ctl,
298: ip_t * ip)
299: {
300: char *t;
301:
302: if (!ctl->dns || !ctl->use_dns)
303: return NULL;
304: t = dns_lookup2(ctl, ip);
305: return t;
306: }
307:
308: /* XXX check if necessary/exported. */
309:
310: /* Resolve an IP address to a hostname. */
311: struct hostent *addr2host(
312: const char *addr,
313: int family)
314: {
315: int len = 0;
316: switch (family) {
317: case AF_INET:
318: len = sizeof(struct in_addr);
319: break;
320: #ifdef ENABLE_IPV6
321: case AF_INET6:
322: len = sizeof(struct in6_addr);
323: break;
324: #endif
325: }
326: return gethostbyaddr(addr, len, family);
327: }