Annotation of embedaddon/mtr/dns.c, revision 1.1.1.1
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: #include <sys/types.h>
27: #include <sys/time.h>
28: #include <sys/select.h>
29: #include <sys/stat.h>
30: #include <sys/errno.h>
31: #include <sys/socket.h>
32: #include <netinet/in.h>
33: #include <arpa/inet.h>
34:
35: #ifndef __APPLE__
36: #define BIND_8_COMPAT
37: #endif
38: #include <arpa/nameser.h>
39: #ifdef HAVE_ARPA_NAMESER_COMPAT_H
40: #include <arpa/nameser_compat.h>
41: #endif
42: #include <netdb.h>
43: #include <resolv.h>
44: #include <unistd.h>
45: #include <fcntl.h>
46: #include <ctype.h>
47: #include <string.h>
48: #include <stdio.h>
49: #include <stdlib.h>
50: #include <errno.h>
51: #include <time.h>
52:
53: #include "mtr.h"
54: #include "dns.h"
55: #include "net.h"
56:
57: #ifdef ENABLE_IPV6
58: #ifdef __GLIBC__
59: #define NSCOUNT6 myres._u._ext.nscount6
60: #define NSSOCKADDR6(i) (myres._u._ext.nsaddrs[i])
61: #else
62: #define NSCOUNT6 myres.nscount
63: #define NSSOCKADDR6(i) (&(myres._u._ext.ext->nsaddrs[i].sin6))
64: #endif
65: #endif
66:
67:
68: #ifdef NO_STRERROR
69: extern int sys_nerr;
70: extern char *sys_errlist[];
71: #define strerror(errno) (((errno) >= 0 && (errno) < sys_nerr) ? sys_errlist[errno] : "unlisted error")
72: #endif
73:
74: #if !HAVE_DECL_ERRNO
75: /* Hmm, it seems Irix requires this */
76: extern int errno;
77: #endif
78:
79: extern int af;
80:
81: /* Defines */
82:
83: #undef Debug
84:
85: #undef CorruptCheck
86: #undef WipeFrees
87: #undef WipeMallocs
88:
89: #define BashSize 8192 /* Size of hash tables */
90: #define BashModulo(x) ((x) & 8191) /* Modulo for hash table size: */
91: #define HostnameLength 255 /* From RFC */
92: #define ResRetryDelay1 3
93: #define ResRetryDelay2 4
94: #define ResRetryDelay3 5
95:
96: /* Macros */
97:
98: #define nonull(s) (s) ? s : nullstring
99:
100: /* Structures */
101:
102: struct resolve {
103: struct resolve *next;
104: struct resolve *previous;
105: struct resolve *nextid;
106: struct resolve *previousid;
107: struct resolve *nextip;
108: struct resolve *previousip;
109: struct resolve *nexthost;
110: struct resolve *previoushost;
111: float expiretime; /* Fucking HPUX has a problem with "double" here. */
112: char *hostname;
113: ip_t ip;
114: word id;
115: byte state;
116: };
117:
118: /* Non-blocking nameserver interface routines */
119:
120: #define MaxPacketsize (PACKETSZ)
121: #define DomainLength (MAXDNAME)
122:
123: #define OpcodeCount 3
124: char *opcodes[OpcodeCount+1] = {
125: "standard query",
126: "inverse query",
127: "server status request",
128: "unknown",
129: };
130:
131: #define ResponsecodeCount 6
132: char *responsecodes[ResponsecodeCount+1] = {
133: "no error",
134: "format error in query",
135: "server failure",
136: "queried domain name does not exist",
137: "requested query type not implemented",
138: "refused by name server",
139: "unknown error",
140: };
141:
142: #define ResourcetypeCount 17
143: char *resourcetypes[ResourcetypeCount+1] = {
144: "unknown type",
145: "A: host address",
146: "NS: authoritative name server",
147: "MD: mail destination (OBSOLETE)",
148: "MF: mail forwarder (OBSOLETE)",
149: "CNAME: name alias",
150: "SOA: authority record",
151: "MB: mailbox domain name (EXPERIMENTAL)",
152: "MG: mail group member (EXPERIMENTAL)",
153: "MR: mail rename domain name (EXPERIMENTAL)",
154: "NULL: NULL RR (EXPERIMENTAL)",
155: "WKS: well known service description",
156: "PTR: domain name pointer",
157: "HINFO: host information",
158: "MINFO: mailbox or mail list information",
159: "MX: mail exchange",
160: "TXT: text string",
161: "unknown type",
162: };
163:
164: #define ClasstypeCount 5
165: char *classtypes[ClasstypeCount+1] = {
166: "unknown class",
167: "IN: the Internet",
168: "CS: CSNET (OBSOLETE)",
169: "CH: CHAOS",
170: "HS: Hesoid [Dyer 87]",
171: "unknown class"
172: };
173:
174: char *rrtypes[] = {
175: "Unknown",
176: "Query",
177: "Answer",
178: "Authority reference",
179: "Resource reference",
180: };
181:
182:
183: /* Please don't use a trailing comma in enumerations: It doesn't
184: work on all compilers */
185: enum {
186: RR_UNKNOWN,
187: RR_QUERY,
188: RR_ANSWER,
189: RR_AUTHORITY,
190: RR_RESOURCE
191: };
192:
193: typedef struct {
194: word id; /* Packet id */
195: byte databyte_a;
196: /* rd:1 recursion desired
197: * tc:1 truncated message
198: * aa:1 authoritive answer
199: * opcode:4 purpose of message
200: * qr:1 response flag
201: */
202: byte databyte_b;
203: /* rcode:4 response code
204: * unassigned:2 unassigned bits
205: * pr:1 primary server required (non standard)
206: * ra:1 recursion available
207: */
208: word qdcount; /* Query record count */
209: word ancount; /* Answer record count */
210: word nscount; /* Authority reference record count */
211: word arcount; /* Resource reference record count */
212: } packetheader;
213:
214: #ifndef HFIXEDSZ
215: #define HFIXEDSZ (sizeof(packetheader))
216: #endif
217:
218: /*
219: * Byte order independent macros for packetheader
220: */
221: #define getheader_rd(x) (x->databyte_a & 1)
222: #define getheader_tc(x) ((x->databyte_a >> 1) & 1)
223: #define getheader_aa(x) ((x->databyte_a >> 2) & 1)
224: #define getheader_opcode(x) ((x->databyte_a >> 3) & 15)
225: #define getheader_qr(x) (x->databyte_a >> 7)
226: #define getheader_rcode(x) (x->databyte_b & 15)
227: #define getheader_pr(x) ((x->databyte_b >> 6) & 1)
228: #define getheader_ra(x) (x->databyte_b >> 7)
229:
230: #if 0
231:
232: /* The execution order inside an expression is undefined! That means that
233: this might work, but then again, it might not... */
234:
235: #define sucknetword(x) (((word)*(x) << 8) | (((x)+= 2)[-1]))
236: #define sucknetshort(x) (((short)*(x) << 8) | (((x)+= 2)[-1]))
237: #define sucknetdword(x) (((dword)*(x) << 24) | ((x)[1] << 16) | ((x)[2] << 8) | (((x)+= 4)[-1]))
238: #define sucknetlong(x) (((long)*(x) << 24) | ((x)[1] << 16) | ((x)[2] << 8) | (((x)+= 4)[-1]))
239: #else
240:
241: #define sucknetword(x) ((x)+=2,((word) (((x)[-2] << 8) | ((x)[-1] << 0))))
242: #define sucknetshort(x) ((x)+=2,((short) (((x)[-2] << 8) | ((x)[-1] << 0))))
243: #define sucknetdword(x) ((x)+=4,((dword) (((x)[-4] << 24) | ((x)[-3] << 16) | \
244: ((x)[-2] << 8) | ((x)[-1] << 0))))
245: #define sucknetlong(x) ((x)+=4,((long) (((x)[-4] << 24) | ((x)[-3] << 16) | \
246: ((x)[-2] << 8) | ((x)[-1] << 0))))
247: #endif
248:
249: enum {
250: STATE_FINISHED,
251: STATE_FAILED,
252: STATE_PTRREQ1,
253: STATE_PTRREQ2,
254: STATE_PTRREQ3
255: };
256:
257: #define Is_PTR(x) ((x->state == STATE_PTRREQ1) || (x->state == STATE_PTRREQ2) || (x->state == STATE_PTRREQ3))
258:
259: dword resrecvbuf[(MaxPacketsize + 7) >> 2]; /* MUST BE DWORD ALIGNED */
260:
261: struct resolve *idbash[BashSize];
262: struct resolve *ipbash[BashSize];
263: struct resolve *hostbash[BashSize];
264: struct resolve *expireresolves = NULL;
265: struct resolve *lastresolve = NULL;
266: struct logline *streamlog = NULL;
267: struct logline *lastlog = NULL;
268:
269: ip_t alignedip;
270: ip_t localhost;
271: #ifdef ENABLE_IPV6
272: ip_t localhost6;
273: #endif
274:
275: double sweeptime;
276:
277: #ifdef Debug
278: int debug = 1;
279: #else
280: int debug = 0;
281: #endif
282:
283: dword mem = 0;
284:
285: dword res_iplookupsuccess = 0;
286: dword res_reversesuccess = 0;
287: dword res_nxdomain = 0;
288: dword res_nserror = 0;
289: dword res_hostipmismatch = 0;
290: dword res_unknownid = 0;
291: dword res_resend = 0;
292: dword res_timeout = 0;
293:
294: dword resolvecount = 0;
295:
296: long idseed = 0xdeadbeef;
297: long aseed;
298:
299: #ifdef ENABLE_IPV6
300: struct sockaddr_storage from_sastruct;
301: struct sockaddr_in6 * from6 = (struct sockaddr_in6 *) &from_sastruct;
302: #else
303: struct sockaddr_in from_sastruct;
304: #endif
305:
306: struct sockaddr_in * from4 = (struct sockaddr_in *) &from_sastruct;
307: struct sockaddr * from = (struct sockaddr *) &from_sastruct;
308:
309: int resfd;
310: #ifdef ENABLE_IPV6
311: int resfd6;
312: #endif
313: socklen_t fromlen = sizeof from_sastruct;
314:
315: char tempstring[16384+1+1];
316: char sendstring[1024+1];
317: char namestring[1024+1];
318: char stackstring[1024+1];
319:
320: char nullstring[] = "";
321:
322: int use_dns = 1;
323:
324: #ifdef res_ninit
325: #define MY_RES_INIT() res_ninit(&myres);
326: #define RES_MKQUERY(a, b, c, d, e, f, g, h, i) \
327: res_nmkquery(&myres, a, b, c, d, e, f, g, h, i)
328: struct __res_state myres;
329: #else
330: #define MY_RES_INIT() res_init();
331: #define RES_MKQUERY(a, b, c, d, e, f, g, h, i) \
332: res_mkquery(a, b, c, d, e, f, g, h, i)
333: #define myres _res
334: #endif
335:
336: /* Code */
337: #ifdef CorruptCheck
338: #define TOT_SLACK 2
339: #define HEAD_SLACK 1
340: /* Need an entry for sparc systems here too.
341: Don't try this on Sparc for now. */
342: #else
343: #ifdef sparc
344: #define TOT_SLACK 2
345: #define HEAD_SLACK 2
346: #else
347: #define TOT_SLACK 1
348: #define HEAD_SLACK 1
349: #endif
350: #endif
351:
352:
353: void *statmalloc(size_t size)
354: {
355: void *p;
356: size_t mallocsize;
357:
358: mem+= size;
359: mallocsize = size + TOT_SLACK * sizeof(dword);
360:
361: p = malloc(mallocsize);
362: if (!p) {
363: fprintf(stderr,"malloc() of %u bytes failed: %s\n", (unsigned int)size, strerror(errno));
364: exit(-1);
365: }
366: *((dword *)p) = (dword)size;
367: #ifdef CorruptCheck
368: *(byte *)((char *)p + size + sizeof(dword) + sizeof(byte) * 0) = 0xde;
369: *(byte *)((char *)p + size + sizeof(dword) + sizeof(byte) * 1) = 0xad;
370: *(byte *)((char *)p + size + sizeof(dword) + sizeof(byte) * 2) = 0xbe;
371: *(byte *)((char *)p + size + sizeof(dword) + sizeof(byte) * 3) = 0xef;
372: #endif
373: p = (void *)((dword *)p + HEAD_SLACK);
374: #ifdef WipeMallocs
375: memset(p,0xf0,size);
376: #endif
377: return p;
378: }
379:
380:
381: void statfree(void *p)
382: {
383: if (p) {
384: if (*((dword *)p - HEAD_SLACK) == 0) {
385: fprintf(stderr,"ERROR: Attempt to free pointer twice.\n");
386: abort();
387: exit(-1);
388: } else {
389: if (*((dword *)p - HEAD_SLACK) > 8192) {
390: fprintf (stderr,"ERROR: Corrupted free() buffer. (header)\n");
391: abort();
392: exit(-1);
393: }
394: #ifdef CorruptCheck
395: if ((*(byte *)((char *)p + (*((dword *)p - 1)) + sizeof(byte) * 0) != 0xde) ||
396: (*(byte *)((char *)p + (*((dword *)p - 1)) + sizeof(byte) * 1) != 0xad) ||
397: (*(byte *)((char *)p + (*((dword *)p - 1)) + sizeof(byte) * 2) != 0xbe) ||
398: (*(byte *)((char *)p + (*((dword *)p - 1)) + sizeof(byte) * 3) != 0xef)) {
399: fprintf(stderr,"ERROR: Corrupted free() buffer. (footer)\n");
400: abort();
401: exit(-1);
402: }
403: #endif
404: mem-= *((dword *)p - HEAD_SLACK);
405: #ifdef WipeFrees
406: memset(p,0xfe,*((dword *)p - HEAD_SLACK));
407: *((dword *)p - 1) = 0;
408: #endif
409: free((dword *)p - HEAD_SLACK);
410: }
411: }
412: }
413:
414:
415: char *strtdiff(char *d,long signeddiff)
416: {
417: dword diff;
418: dword seconds,minutes,hours;
419: long days;
420:
421: if ((diff = labs(signeddiff))) {
422: seconds = diff % 60; diff/= 60;
423: minutes = diff % 60; diff/= 60;
424: hours = diff % 24;
425: days = signeddiff / (60 * 60 * 24);
426: if (days)
427: sprintf(d,"%lid",days);
428: else
429: *d = '\0';
430: if (hours)
431: sprintf(d + strlen(d),"%luh",hours);
432: if (minutes)
433: sprintf(d + strlen(d),"%lum",minutes);
434: if (seconds)
435: sprintf(d + strlen(d),"%lus",seconds);
436: } else
437: sprintf(d,"0s");
438: return d;
439: }
440:
441:
442: int issetfd(fd_set *set,int fd)
443: {
444: return (int)((FD_ISSET(fd,set)) && 1);
445: }
446:
447:
448: void setfd(fd_set *set,int fd)
449: {
450: FD_SET(fd,set);
451: }
452:
453:
454: void clearfd(fd_set *set,int fd)
455: {
456: FD_CLR(fd,set);
457: }
458:
459:
460: void clearset(fd_set *set)
461: {
462: FD_ZERO(set);
463: }
464:
465:
466: char *strlongip(ip_t * ip)
467: {
468: #ifdef ENABLE_IPV6
469: static char addrstr[INET6_ADDRSTRLEN];
470:
471: return (char *) inet_ntop( af, ip, addrstr, sizeof addrstr );
472: #else
473: return inet_ntoa( *ip );
474: #endif
475: }
476:
477:
478: int longipstr( char *s, ip_t *dst, int af )
479: {
480: #ifdef ENABLE_IPV6
481: return inet_pton( af, s, dst );
482: #else
483: return inet_aton( s, dst );
484: #endif
485: }
486:
487:
488: struct hostent * dns_forward(const char *name)
489: {
490: struct hostent *host;
491:
492: if ((host = gethostbyname(name)))
493: return host;
494: else
495: return NULL;
496: }
497:
498:
499: int dns_waitfd(void)
500: {
501: return resfd;
502: }
503: #ifdef ENABLE_IPV6
504: int dns_waitfd6(void)
505: {
506: return resfd6;
507: }
508: #endif
509:
510:
511: void dns_open(void)
512: {
513: int option,i;
514:
515: if (!dns) return;
516: MY_RES_INIT();
517: if (!myres.nscount) {
518: fprintf(stderr,"No nameservers defined.\n");
519: exit(-1);
520: }
521: myres.options|= RES_RECURSE | RES_DEFNAMES | RES_DNSRCH;
522: resfd = socket(AF_INET, SOCK_DGRAM, 0);
523: if (resfd == -1) {
524: fprintf(stderr,
525: "Unable to allocate IPv4 socket for nameserver communication: %s\n",
526: strerror(errno));
527: exit(-1);
528: }
529: #ifdef ENABLE_IPV6
530: resfd6 = socket(AF_INET6, SOCK_DGRAM, 0);
531: if (resfd6 == -1) {
532: fprintf(stderr,
533: "Unable to allocate IPv6 socket for nameserver communication: %s\n",
534: strerror(errno));
535: exit(-1);
536: }
537: #endif
538: option = 1;
539: if (setsockopt(resfd,SOL_SOCKET,SO_BROADCAST,(char *)&option,sizeof(option))) {
540: fprintf(stderr,
541: "Unable to setsockopt() on IPv4 nameserver communication socket: %s\n",
542: strerror(errno));
543: exit(-1);
544: }
545: #ifdef ENABLE_IPV6
546: if (setsockopt(resfd6,SOL_SOCKET,SO_BROADCAST,(char *)&option,sizeof(option))) {
547: fprintf(stderr,
548: "Unable to setsockopt() on IPv6 nameserver communication socket: %s\n",
549: strerror(errno));
550: exit(-1);
551: }
552: #endif
553: longipstr( "127.0.0.1", &localhost, AF_INET );
554: #ifdef ENABLE_IPV6
555: longipstr( "::1", &localhost6, AF_INET6 );
556: #endif
557: aseed = time(NULL) ^ (time(NULL) << 3) ^ (dword)getpid();
558: for (i = 0;i < BashSize;i++) {
559: idbash[i] = NULL;
560: hostbash[i] = NULL;
561: }
562: }
563:
564:
565: struct resolve *allocresolve(void)
566: {
567: struct resolve *rp;
568:
569: rp = (struct resolve *)statmalloc(sizeof(struct resolve));
570: if (!rp) {
571: fprintf(stderr,"statmalloc() failed: %s\n",strerror(errno));
572: exit(-1);
573: }
574: memset(rp,0, sizeof(struct resolve));
575: return rp;
576: }
577:
578:
579: dword getidbash(word id)
580: {
581: return (dword)BashModulo(id);
582: }
583:
584:
585: dword getipbash(ip_t * ip)
586: {
587: char *p = (char *) ip;
588: int i, len = 0;
589: dword bashvalue = 0;
590:
591: switch ( af ) {
592: case AF_INET:
593: len = sizeof (struct in_addr);
594: break;
595: #ifdef ENABLE_IPV6
596: case AF_INET6:
597: len = sizeof (struct in6_addr);
598: break;
599: #endif
600: }
601: for (i = 0; i < len; i++, p++) {
602: bashvalue^= *p;
603: bashvalue+= (*p >> 1) + (bashvalue >> 1);
604: }
605: return BashModulo(bashvalue);
606: }
607:
608:
609: dword gethostbash(char *host)
610: {
611: dword bashvalue = 0;
612:
613: for (;*host;host++) {
614: bashvalue^= *host;
615: bashvalue+= (*host >> 1) + (bashvalue >> 1);
616: }
617: return BashModulo(bashvalue);
618: }
619:
620:
621: void linkresolveid(struct resolve *addrp)
622: {
623: struct resolve *rp;
624: dword bashnum;
625:
626: bashnum = getidbash(addrp->id);
627: rp = idbash[bashnum];
628: if (rp) {
629: while ((rp->nextid) && (addrp->id > rp->nextid->id))
630: rp = rp->nextid;
631: while ((rp->previousid) && (addrp->id < rp->previousid->id))
632: rp = rp->previousid;
633: if (rp->id < addrp->id) {
634: addrp->previousid = rp;
635: addrp->nextid = rp->nextid;
636: if (rp->nextid)
637: rp->nextid->previousid = addrp;
638: rp->nextid = addrp;
639: } else {
640: addrp->previousid = rp->previousid;
641: addrp->nextid = rp;
642: if (rp->previousid)
643: rp->previousid->nextid = addrp;
644: rp->previousid = addrp;
645: }
646: } else
647: addrp->nextid = addrp->previousid = NULL;
648: idbash[bashnum] = addrp;
649: }
650:
651:
652: void unlinkresolveid(struct resolve *rp)
653: {
654: dword bashnum;
655:
656: bashnum = getidbash(rp->id);
657: if (idbash[bashnum] == rp)
658: idbash[bashnum] = (rp->previousid)? rp->previousid : rp->nextid;
659: if (rp->nextid)
660: rp->nextid->previousid = rp->previousid;
661: if (rp->previousid)
662: rp->previousid->nextid = rp->nextid;
663: }
664:
665:
666: void linkresolvehost(struct resolve *addrp)
667: {
668: struct resolve *rp;
669: dword bashnum;
670:
671: bashnum = gethostbash(addrp->hostname);
672: rp = hostbash[bashnum];
673: if (rp) {
674: while ((rp->nexthost) && (strcasecmp(addrp->hostname,rp->nexthost->hostname) < 0))
675: rp = rp->nexthost;
676: while ((rp->previoushost) && (strcasecmp(addrp->hostname,rp->previoushost->hostname) > 0))
677: rp = rp->previoushost;
678: if (strcasecmp(addrp->hostname,rp->hostname) < 0) {
679: addrp->previoushost = rp;
680: addrp->nexthost = rp->nexthost;
681: if (rp->nexthost)
682: rp->nexthost->previoushost = addrp;
683: rp->nexthost = addrp;
684: } else {
685: addrp->previoushost = rp->previoushost;
686: addrp->nexthost = rp;
687: if (rp->previoushost)
688: rp->previoushost->nexthost = addrp;
689: rp->previoushost = addrp;
690: }
691: } else
692: addrp->nexthost = addrp->previoushost = NULL;
693: hostbash[bashnum] = addrp;
694: }
695:
696:
697: void unlinkresolvehost(struct resolve *rp)
698: {
699: dword bashnum;
700:
701: bashnum = gethostbash(rp->hostname);
702: if (hostbash[bashnum] == rp)
703: hostbash[bashnum] = (rp->previoushost)? rp->previoushost : rp->nexthost;
704: if (rp->nexthost)
705: rp->nexthost->previoushost = rp->previoushost;
706: if (rp->previoushost)
707: rp->previoushost->nexthost = rp->nexthost;
708: statfree(rp->hostname);
709: }
710:
711:
712: void linkresolveip(struct resolve *addrp)
713: {
714: struct resolve *rp;
715: dword bashnum;
716:
717: bashnum = getipbash( &(addrp->ip) );
718: rp = ipbash[bashnum];
719: if (rp) {
720: while ((rp->nextip) &&
721: ( addrcmp( (void *) &(addrp->ip),
722: (void *) &(rp->nextip->ip), af ) > 0 ))
723: rp = rp->nextip;
724: while ((rp->previousip) &&
725: ( addrcmp( (void *) &(addrp->ip),
726: (void *) &(rp->previousip->ip), af ) < 0 ))
727: rp = rp->previousip;
728: if ( addrcmp( (void *) &(rp->ip), (void *) &(addrp->ip), af ) < 0 ) {
729: addrp->previousip = rp;
730: addrp->nextip = rp->nextip;
731: if (rp->nextip)
732: rp->nextip->previousip = addrp;
733: rp->nextip = addrp;
734: } else {
735: addrp->previousip = rp->previousip;
736: addrp->nextip = rp;
737: if (rp->previousip)
738: rp->previousip->nextip = addrp;
739: rp->previousip = addrp;
740: }
741: } else
742: addrp->nextip = addrp->previousip = NULL;
743: ipbash[bashnum] = addrp;
744: }
745:
746:
747: void unlinkresolveip(struct resolve *rp)
748: {
749: dword bashnum;
750:
751: bashnum = getipbash( &(rp->ip) );
752: if (ipbash[bashnum] == rp)
753: ipbash[bashnum] = (rp->previousip)? rp->previousip : rp->nextip;
754: if (rp->nextip)
755: rp->nextip->previousip = rp->previousip;
756: if (rp->previousip)
757: rp->previousip->nextip = rp->nextip;
758: }
759:
760:
761: void linkresolve(struct resolve *rp)
762: {
763: struct resolve *irp;
764:
765: if (expireresolves) {
766: irp = expireresolves;
767: while ((irp->next) && (rp->expiretime >= irp->expiretime)) irp = irp->next;
768: if (rp->expiretime >= irp->expiretime) {
769: rp->next = NULL;
770: rp->previous = irp;
771: irp->next = rp;
772: lastresolve = rp;
773: } else {
774: rp->previous = irp->previous;
775: rp->next = irp;
776: if (irp->previous)
777: irp->previous->next = rp;
778: else
779: expireresolves = rp;
780: irp->previous = rp;
781: }
782: } else {
783: rp->next = NULL;
784: rp->previous = NULL;
785: expireresolves = lastresolve = rp;
786: }
787: resolvecount++;
788: }
789:
790:
791: void lastlinkresolve(struct resolve *rp)
792: {
793: struct resolve *irp;
794:
795: if (lastresolve) {
796: irp = lastresolve;
797: while ((irp->previous) && (rp->expiretime < irp->expiretime)) irp = irp->previous;
798: while ((irp->next) && (rp->expiretime >= irp->expiretime)) irp = irp->next;
799: if (rp->expiretime >= irp->expiretime) {
800: rp->next = NULL;
801: rp->previous = irp;
802: irp->next = rp;
803: lastresolve = rp;
804: } else {
805: rp->previous = irp->previous;
806: rp->next = irp;
807: if (irp->previous)
808: irp->previous->next = rp;
809: else
810: expireresolves = rp;
811: irp->previous = rp;
812: }
813: } else {
814: rp->next = NULL;
815: rp->previous = NULL;
816: expireresolves = lastresolve = rp;
817: }
818: resolvecount++;
819: }
820:
821:
822: void untieresolve(struct resolve *rp)
823: {
824: if (rp->previous)
825: rp->previous->next = rp->next;
826: else
827: expireresolves = rp->next;
828: if (rp->next)
829: rp->next->previous = rp->previous;
830: else
831: lastresolve = rp->previous;
832: resolvecount--;
833: }
834:
835:
836: void unlinkresolve(struct resolve *rp)
837: {
838: untieresolve(rp);
839: unlinkresolveid(rp);
840: unlinkresolveip(rp);
841: if (rp->hostname)
842: unlinkresolvehost(rp);
843: }
844:
845:
846: struct resolve *findid(word id)
847: {
848: struct resolve *rp;
849: int bashnum;
850:
851: bashnum = getidbash(id);
852: rp = idbash[bashnum];
853: if (rp) {
854: while ((rp->nextid) && (id >= rp->nextid->id))
855: rp = rp->nextid;
856: while ((rp->previousid) && (id <= rp->previousid->id))
857: rp = rp->previousid;
858: if (id == rp->id) {
859: idbash[bashnum] = rp;
860: return rp;
861: } else
862: return NULL;
863: }
864: return rp; /* NULL */
865: }
866:
867:
868: struct resolve *findhost(char *hostname)
869: {
870: struct resolve *rp;
871: int bashnum;
872:
873: bashnum = gethostbash(hostname);
874: rp = hostbash[bashnum];
875: if (rp) {
876: while ((rp->nexthost) && (strcasecmp(hostname,rp->nexthost->hostname) >= 0))
877: rp = rp->nexthost;
878: while ((rp->previoushost) && (strcasecmp(hostname,rp->nexthost->hostname) <= 0))
879: rp = rp->previoushost;
880: if (strcasecmp(hostname,rp->hostname))
881: return NULL;
882: else {
883: hostbash[bashnum] = rp;
884: return rp;
885: }
886: }
887: return rp; /* NULL */
888: }
889:
890:
891: struct resolve *findip(ip_t * ip)
892: {
893: struct resolve *rp;
894: dword bashnum;
895:
896: bashnum = getipbash(ip);
897: rp = ipbash[bashnum];
898: if (rp) {
899: while ((rp->nextip) &&
900: ( addrcmp( (void *) ip, (void *) &(rp->nextip->ip), af ) >= 0 ))
901: rp = rp->nextip;
902: while ((rp->previousip) &&
903: ( addrcmp( (void *) ip, (void *) &(rp->previousip->ip), af ) <= 0 ))
904: rp = rp->previousip;
905: if ( addrcmp( (void *) ip, (void *) &(rp->ip), af ) == 0 ) {
906: ipbash[bashnum] = rp;
907: return rp;
908: } else
909: return NULL;
910: }
911: return rp; /* NULL */
912: }
913:
914:
915: void restell(char *s)
916: {
917: fputs(s,stderr);
918: fputs("\r",stderr);
919: }
920:
921:
922: void dorequest(char *s,int type,word id)
923: {
924: packetheader *hp;
925: int r,i;
926: unsigned char buf[MaxPacketsize];
927:
928: r = RES_MKQUERY(QUERY,s,C_IN,type,NULL,0,NULL,(unsigned char*)buf,MaxPacketsize);
929: if (r == -1) {
930: restell("Resolver error: Query too large.");
931: return;
932: }
933: hp = (packetheader *)buf;
934: hp->id = id; /* htons() deliberately left out (redundant) */
935: #ifdef ENABLE_IPV6
936: for (i = 0;i < NSCOUNT6;i++) {
937: if (!NSSOCKADDR6(i))
938: continue;
939: if (NSSOCKADDR6(i)->sin6_family == AF_INET6)
940: (void)sendto(resfd6,buf,r,0,(struct sockaddr *) NSSOCKADDR6(i),
941: sizeof(struct sockaddr_in6));
942: }
943: #endif
944: for (i = 0;i < myres.nscount;i++)
945: if (myres.nsaddr_list[i].sin_family == AF_INET)
946: (void)sendto(resfd,buf,r,0,(struct sockaddr *)&myres.nsaddr_list[i],
947: sizeof(struct sockaddr));
948: }
949:
950: void resendrequest(struct resolve *rp,int type)
951: {
952: if (type == T_A) {
953: dorequest(rp->hostname,type,rp->id);
954: if (debug) {
955: snprintf(tempstring, sizeof(tempstring), "Resolver: Sent reverse authentication request for \"%s\".",
956: rp->hostname);
957: restell(tempstring);
958: }
959: } else if (type == T_PTR) {
960: switch ( af ) {
961: case AF_INET:
962: sprintf(tempstring,"%u.%u.%u.%u.in-addr.arpa",
963: ((byte *)&rp->ip)[3],
964: ((byte *)&rp->ip)[2],
965: ((byte *)&rp->ip)[1],
966: ((byte *)&rp->ip)[0]);
967: break;
968: #ifdef ENABLE_IPV6
969: case AF_INET6:
970: addr2ip6arpa( &(rp->ip), tempstring );
971: break;
972: #endif
973: }
974: dorequest(tempstring,type,rp->id);
975: if (debug) {
976: snprintf(tempstring, sizeof(tempstring), "Resolver: Sent domain lookup request for \"%s\".",
977: strlongip( &(rp->ip) ));
978: restell(tempstring);
979: }
980: }
981: }
982:
983: void sendrequest(struct resolve *rp,int type)
984: {
985: do {
986: idseed = (((idseed + idseed) | (long)time(NULL)) + idseed - 0x54bad4a) ^ aseed;
987: aseed^= idseed;
988: rp->id = (word)idseed;
989: } while (findid(rp->id));
990: linkresolveid(rp);
991: resendrequest(rp,type);
992: }
993:
994:
995: void failrp(struct resolve *rp)
996: {
997: if (rp->state == STATE_FINISHED)
998: return;
999: rp->state = STATE_FAILED;
1000: untieresolve(rp);
1001: if (debug)
1002: restell("Resolver: Lookup failed.\n");
1003: }
1004:
1005:
1006: void passrp(struct resolve *rp,long ttl)
1007: {
1008: rp->state = STATE_FINISHED;
1009: rp->expiretime = sweeptime + (double)ttl;
1010: untieresolve(rp);
1011: if (debug) {
1012: snprintf(tempstring, sizeof(tempstring), "Resolver: Lookup successful: %s\n",rp->hostname);
1013: restell(tempstring);
1014: }
1015: }
1016:
1017:
1018: void parserespacket(byte *s, int l)
1019: {
1020: struct resolve *rp;
1021: packetheader *hp;
1022: byte *eob;
1023: byte *c;
1024: long ttl;
1025: int r,usefulanswer;
1026: word rr,datatype,class,qdatatype,qclass;
1027: byte rdatalength;
1028:
1029: if (l < (int) sizeof(packetheader)) {
1030: restell("Resolver error: Packet smaller than standard header size.");
1031: return;
1032: }
1033: if (l == (int) sizeof(packetheader)) {
1034: restell("Resolver error: Packet has empty body.");
1035: return;
1036: }
1037: hp = (packetheader *)s;
1038: /* Convert data to host byte order */
1039: /* hp->id does not need to be redundantly byte-order flipped, it is only echoed by nameserver */
1040: rp = findid(hp->id);
1041: if (!rp) {
1042: res_unknownid++;
1043: return;
1044: }
1045: if ((rp->state == STATE_FINISHED) || (rp->state == STATE_FAILED))
1046: return;
1047: hp->qdcount = ntohs(hp->qdcount);
1048: hp->ancount = ntohs(hp->ancount);
1049: hp->nscount = ntohs(hp->nscount);
1050: hp->arcount = ntohs(hp->arcount);
1051: if (getheader_tc(hp)) { /* Packet truncated */
1052: restell("Resolver error: Nameserver packet truncated.");
1053: return;
1054: }
1055: if (!getheader_qr(hp)) { /* Not a reply */
1056: restell("Resolver error: Query packet received on nameserver communication socket.");
1057: return;
1058: }
1059: if (getheader_opcode(hp)) { /* Not opcode 0 (standard query) */
1060: restell("Resolver error: Invalid opcode in response packet.");
1061: return;
1062: }
1063: eob = s + l;
1064: c = s + HFIXEDSZ;
1065: switch (getheader_rcode(hp)) {
1066: case NOERROR:
1067: if (hp->ancount) {
1068: if (debug) {
1069: snprintf(tempstring, sizeof(tempstring), "Resolver: Received nameserver reply. (qd:%u an:%u ns:%u ar:%u)",
1070: hp->qdcount,hp->ancount,hp->nscount,hp->arcount);
1071: restell(tempstring);
1072: }
1073: if (hp->qdcount != 1) {
1074: restell("Resolver error: Reply does not contain one query.");
1075: return;
1076: }
1077: if (c > eob) {
1078: restell("Resolver error: Reply too short.");
1079: return;
1080: }
1081: switch (rp->state) { /* Construct expected query reply */
1082: case STATE_PTRREQ1:
1083: case STATE_PTRREQ2:
1084: case STATE_PTRREQ3:
1085: switch ( af ) {
1086: case AF_INET:
1087: sprintf(stackstring,"%u.%u.%u.%u.in-addr.arpa",
1088: ((byte *)&rp->ip)[3],
1089: ((byte *)&rp->ip)[2],
1090: ((byte *)&rp->ip)[1],
1091: ((byte *)&rp->ip)[0]);
1092: break;
1093: #ifdef ENABLE_IPV6
1094: case AF_INET6:
1095: addr2ip6arpa( &(rp->ip), stackstring );
1096: break;
1097: #endif
1098: }
1099: }
1100: *namestring = '\0';
1101: r = dn_expand(s,s + l,c,namestring,MAXDNAME);
1102: if (r == -1) {
1103: restell("Resolver error: dn_expand() failed while expanding query domain.");
1104: return;
1105: }
1106: namestring[strlen(stackstring)] = '\0';
1107: if (strcasecmp(stackstring,namestring)) {
1108: if (debug) {
1109: snprintf(tempstring, sizeof(tempstring), "Resolver: Unknown query packet dropped. (\"%s\" does not match \"%s\")",
1110: stackstring,namestring);
1111: restell(tempstring);
1112: }
1113: return;
1114: }
1115: if (debug) {
1116: snprintf(tempstring, sizeof(tempstring), "Resolver: Queried domain name: \"%s\"",namestring);
1117: restell(tempstring);
1118: }
1119: c+= r;
1120: if (c + 4 > eob) {
1121: restell("Resolver error: Query resource record truncated.");
1122: return;
1123: }
1124: qdatatype = sucknetword(c);
1125: qclass = sucknetword(c);
1126: if (qclass != C_IN) {
1127: snprintf(tempstring, sizeof(tempstring), "Resolver error: Received unsupported query class: %u (%s)",
1128: qclass,qclass < ClasstypeCount ? classtypes[qclass] :
1129: classtypes[ClasstypeCount]);
1130: restell(tempstring);
1131: }
1132: switch (qdatatype) {
1133: case T_PTR:
1134: if (!Is_PTR(rp))
1135: if (debug) {
1136: restell("Resolver warning: Ignoring response with unexpected query type \"PTR\".");
1137: return;
1138: }
1139: break;
1140: default:
1141: snprintf(tempstring, sizeof(tempstring), "Resolver error: Received unimplemented query type: %u (%s)",
1142: qdatatype,qdatatype < ResourcetypeCount ?
1143: resourcetypes[qdatatype] : resourcetypes[ResourcetypeCount]);
1144: restell(tempstring);
1145: }
1146: for (rr = hp->ancount + hp->nscount + hp->arcount;rr;rr--) {
1147: if (c > eob) {
1148: restell("Resolver error: Packet does not contain all specified resouce records.");
1149: return;
1150: }
1151: *namestring = '\0';
1152: r = dn_expand(s,s + l,c,namestring,MAXDNAME);
1153: if (r == -1) {
1154: restell("Resolver error: dn_expand() failed while expanding answer domain.");
1155: return;
1156: }
1157: namestring[strlen(stackstring)] = '\0';
1158: if (strcasecmp(stackstring,namestring))
1159: usefulanswer = 0;
1160: else
1161: usefulanswer = 1;
1162: if (debug) {
1163: snprintf(tempstring, sizeof(tempstring), "Resolver: answered domain query: \"%s\"",namestring);
1164: restell(tempstring);
1165: }
1166: c+= r;
1167: if (c + 10 > eob) {
1168: restell("Resolver error: Resource record truncated.");
1169: return;
1170: }
1171: datatype = sucknetword(c);
1172: class = sucknetword(c);
1173: ttl = sucknetlong(c);
1174: rdatalength = sucknetword(c);
1175: if (class != qclass) {
1176: snprintf(tempstring, sizeof(tempstring), "query class: %u (%s)",qclass,qclass < ClasstypeCount ?
1177: classtypes[qclass] : classtypes[ClasstypeCount]);
1178: restell(tempstring);
1179: snprintf(tempstring, sizeof(tempstring), "rr class: %u (%s)",class,class < ClasstypeCount ?
1180: classtypes[class] : classtypes[ClasstypeCount]);
1181: restell(tempstring);
1182: restell("Resolver error: Answered class does not match queried class.");
1183: return;
1184: }
1185: if (!rdatalength) {
1186: restell("Resolver error: Zero size rdata.");
1187: return;
1188: }
1189: if (c + rdatalength > eob) {
1190: restell("Resolver error: Specified rdata length exceeds packet size.");
1191: return;
1192: }
1193: if (datatype == qdatatype || datatype == T_CNAME) {
1194: if (debug) {
1195: snprintf(tempstring, sizeof(tempstring), "Resolver: TTL: %s",strtdiff(sendstring,ttl));
1196: restell(tempstring);
1197: }
1198: if (usefulanswer)
1199: switch (datatype) {
1200: case T_A:
1201: if (rdatalength != 4) {
1202: snprintf(tempstring, sizeof(tempstring), "Resolver error: Unsupported rdata format for \"A\" type. (%u bytes)",
1203: rdatalength);
1204: restell(tempstring);
1205: return;
1206: }
1207: if ( addrcmp( (void *) &(rp->ip), (void *) c, af ) == 0 ) {
1208: snprintf(tempstring, sizeof(tempstring), "Resolver: Reverse authentication failed: %s != ",
1209: strlongip( &(rp->ip) ));
1210: addrcpy( (void *) &alignedip, (void *) c, af );
1211: strcat(tempstring,strlongip( &alignedip ));
1212: restell(tempstring);
1213: res_hostipmismatch++;
1214: failrp(rp);
1215: } else {
1216: snprintf(tempstring, sizeof(tempstring), "Resolver: Reverse authentication complete: %s == \"%s\".",
1217: strlongip( &(rp->ip) ),nonull(rp->hostname));
1218: restell(tempstring);
1219: res_reversesuccess++;
1220: passrp(rp,ttl);
1221: return;
1222: }
1223: break;
1224: case T_PTR:
1225: case T_CNAME:
1226: *namestring = '\0';
1227: r = dn_expand(s,s + l,c,namestring,MAXDNAME);
1228: if (r == -1) {
1229: restell("Resolver error: dn_expand() failed while expanding domain in rdata.");
1230: return;
1231: }
1232: if (debug) {
1233: snprintf(tempstring, sizeof(tempstring), "Resolver: Answered domain: \"%s\"",namestring);
1234: restell(tempstring);
1235: }
1236: if (r > HostnameLength) {
1237: restell("Resolver error: Domain name too long.");
1238: failrp(rp);
1239: return;
1240: }
1241: if (datatype == T_CNAME) {
1242: strcpy(stackstring,namestring);
1243: break;
1244: }
1245: if (!rp->hostname) {
1246: rp->hostname = (char *)statmalloc(strlen(namestring) + 1);
1247: if (!rp->hostname) {
1248: fprintf(stderr,"statmalloc() error: %s\n",strerror(errno));
1249: exit(-1);
1250: }
1251: strcpy(rp->hostname,namestring);
1252: linkresolvehost(rp);
1253: passrp(rp,ttl);
1254: res_iplookupsuccess++;
1255: }
1256: break;
1257: default:
1258: snprintf(tempstring, sizeof(tempstring), "Resolver error: Received unimplemented data type: %u (%s)",
1259: datatype,datatype < ResourcetypeCount ?
1260: resourcetypes[datatype] : resourcetypes[ResourcetypeCount]);
1261: restell(tempstring);
1262: }
1263: } else {
1264: if (debug) {
1265: snprintf(tempstring, sizeof(tempstring), "Resolver: Ignoring resource type %u. (%s)",
1266: datatype,datatype < ResourcetypeCount ?
1267: resourcetypes[datatype] : resourcetypes[ResourcetypeCount]);
1268: restell(tempstring);
1269: }
1270: }
1271: c+= rdatalength;
1272: }
1273: } else
1274: restell("Resolver error: No error returned but no answers given.");
1275: break;
1276: case NXDOMAIN:
1277: if (debug)
1278: restell("Resolver: Host not found.");
1279: res_nxdomain++;
1280: failrp(rp);
1281: break;
1282: default:
1283: snprintf(tempstring, sizeof(tempstring), "Resolver: Received error response %u. (%s)",
1284: getheader_rcode(hp),getheader_rcode(hp) < ResponsecodeCount ?
1285: responsecodes[getheader_rcode(hp)] : responsecodes[ResponsecodeCount]);
1286: restell(tempstring);
1287: res_nserror++;
1288: }
1289: }
1290:
1291:
1292: void dns_ack(void)
1293: {
1294: int r,i;
1295:
1296: r = recvfrom(resfd,(byte *)resrecvbuf,MaxPacketsize,0,
1297: from, &fromlen);
1298: if (r > 0) {
1299: /* Check to see if this server is actually one we sent to */
1300: if ( addrcmp( (void *) &(from4->sin_addr), (void *) &localhost,
1301: (int) AF_INET ) == 0 ) {
1302: for (i = 0;i < myres.nscount;i++)
1303: if ( addrcmp( (void *) &(myres.nsaddr_list[i].sin_addr),
1304: (void *) &(from4->sin_addr), (int) AF_INET ) == 0 ||
1305: addrcmp( (void *) &(myres.nsaddr_list[i].sin_addr),
1306: (void *) &unspec_addr, (int) AF_INET ) == 0 ) /* 0.0.0.0 replies as 127.0.0.1 */
1307: break;
1308: } else
1309: for (i = 0;i < myres.nscount;i++)
1310: if ( addrcmp( (void *) &(myres.nsaddr_list[i].sin_addr),
1311: (void *) &(from4->sin_addr), AF_INET ) == 0 )
1312: break;
1313: if (i == myres.nscount) {
1314: snprintf(tempstring, sizeof(tempstring), "Resolver error: Received reply from unknown source: %s",
1315: inet_ntoa(from4->sin_addr ));
1316: restell(tempstring);
1317: } else
1318: parserespacket((byte *)resrecvbuf,r);
1319: } else {
1320: snprintf(tempstring, sizeof(tempstring), "Resolver: Socket error: %s",strerror(errno));
1321: restell(tempstring);
1322: }
1323: }
1324: #ifdef ENABLE_IPV6
1325: void dns_ack6(void)
1326: {
1327: int r,i;
1328: static char addrstr[INET6_ADDRSTRLEN];
1329:
1330: r = recvfrom(resfd6,(byte *)resrecvbuf,MaxPacketsize,0,
1331: from, &fromlen);
1332: if (r > 0) {
1333: /* Check to see if this server is actually one we sent to */
1334: if ( addrcmp( (void *) &(from6->sin6_addr), (void *) &localhost6,
1335: (int) AF_INET6 ) == 0 ) {
1336: for (i = 0;i < NSCOUNT6;i++) {
1337: if (!NSSOCKADDR6(i))
1338: continue;
1339:
1340: if ( addrcmp( (void *) &(NSSOCKADDR6(i)->sin6_addr),
1341: (void *) &(from6->sin6_addr), (int) AF_INET6 ) == 0 ||
1342: addrcmp( (void *) &(NSSOCKADDR6(i)->sin6_addr),
1343: (void *) &unspec_addr, (int) AF_INET6 ) == 0 ) /* 0.0.0.0 replies as 127.0.0.1 */
1344: break;
1345: }
1346: } else
1347: for (i = 0;i < NSCOUNT6;i++) {
1348: if (!NSSOCKADDR6(i))
1349: continue;
1350: if ( addrcmp( (void *) &(NSSOCKADDR6(i)->sin6_addr),
1351: (void *) &(from6->sin6_addr), AF_INET6 ) == 0 )
1352: break;
1353: }
1354: if (i == NSCOUNT6) {
1355: snprintf(tempstring, sizeof(tempstring),
1356: "Resolver error: Received reply from unknown source: %s",
1357: inet_ntop( AF_INET6, &(from6->sin6_addr), addrstr,
1358: sizeof addrstr ));
1359: restell(tempstring);
1360: } else
1361: parserespacket((byte *)resrecvbuf,r);
1362: } else {
1363: snprintf(tempstring, sizeof(tempstring), "Resolver: Socket error: %s",strerror(errno));
1364: restell(tempstring);
1365: }
1366: }
1367: #endif
1368:
1369:
1370: int istime(double x,double *sinterval)
1371: {
1372: if (x) {
1373: if (x > sweeptime) {
1374: if (*sinterval > x - sweeptime)
1375: *sinterval = x - sweeptime;
1376: } else
1377: return 1;
1378: }
1379: return 0;
1380: }
1381:
1382:
1383: void dns_events(double *sinterval)
1384: {
1385: struct resolve *rp,*nextrp;
1386:
1387: for (rp = expireresolves;(rp) && (sweeptime >= rp->expiretime);rp = nextrp) {
1388: nextrp = rp->next;
1389: switch (rp->state) {
1390: case STATE_FINISHED: /* TTL has expired */
1391: case STATE_FAILED: /* Fake TTL has expired */
1392: if (debug) {
1393: snprintf(tempstring, sizeof(tempstring), "Resolver: Cache record for \"%s\" (%s) has expired. (state: %u) Marked for expire at: %g, time: %g.",
1394: nonull(rp->hostname), strlongip( &(rp->ip) ),
1395: rp->state, rp->expiretime, sweeptime);
1396: restell(tempstring);
1397: }
1398: unlinkresolve(rp);
1399: break;
1400: case STATE_PTRREQ1: /* First T_PTR send timed out */
1401: resendrequest(rp,T_PTR);
1402: restell("Resolver: Send #2 for \"PTR\" query...");
1403: rp->state++;
1404: rp->expiretime = sweeptime + ResRetryDelay2;
1405: (void)istime(rp->expiretime,sinterval);
1406: res_resend++;
1407: break;
1408: case STATE_PTRREQ2: /* Second T_PTR send timed out */
1409: resendrequest(rp,T_PTR);
1410: restell("Resolver: Send #3 for \"PTR\" query...");
1411: rp->state++;
1412: rp->expiretime = sweeptime + ResRetryDelay3;
1413: (void)istime(rp->expiretime,sinterval);
1414: res_resend++;
1415: break;
1416: case STATE_PTRREQ3: /* Third T_PTR timed out */
1417: restell("Resolver: \"PTR\" query timed out.");
1418: failrp(rp);
1419: (void)istime(rp->expiretime,sinterval);
1420: res_timeout++;
1421: break;
1422: }
1423: }
1424: if (expireresolves)
1425: (void)istime(expireresolves->expiretime,sinterval);
1426: }
1427:
1428:
1429: char *dns_lookup2(ip_t * ip)
1430: {
1431: struct resolve *rp;
1432:
1433: if ((rp = findip(ip))) {
1434: if ((rp->state == STATE_FINISHED) || (rp->state == STATE_FAILED)) {
1435: if ((rp->state == STATE_FINISHED) && (rp->hostname)) {
1436: if (debug) {
1437: snprintf(tempstring, sizeof(tempstring), "Resolver: Used cached record: %s == \"%s\".\n",
1438: strlongip(ip),rp->hostname);
1439: restell(tempstring);
1440: }
1441: return rp->hostname;
1442: } else {
1443: if (debug) {
1444: snprintf(tempstring, sizeof(tempstring), "Resolver: Used failed record: %s == ???\n",
1445: strlongip(ip));
1446: restell(tempstring);
1447: }
1448: return NULL;
1449: }
1450: }
1451: return NULL;
1452: }
1453: if (debug)
1454: fprintf(stderr,"Resolver: Added to new record.\n");
1455: rp = allocresolve();
1456: rp->state = STATE_PTRREQ1;
1457: rp->expiretime = sweeptime + ResRetryDelay1;
1458: addrcpy( (void *) &(rp->ip), (void *) ip, af );
1459: linkresolve(rp);
1460: addrcpy( (void *) &(rp->ip), (void *) ip, af );
1461: linkresolveip(rp);
1462: sendrequest(rp,T_PTR);
1463: return NULL;
1464: }
1465:
1466:
1467: char *dns_lookup(ip_t * ip)
1468: {
1469: char *t;
1470:
1471: if (!dns) return NULL;
1472: t = dns_lookup2(ip);
1473: return (t && use_dns) ? t : NULL;
1474: }
1475:
1476: #ifdef ENABLE_IPV6
1477: /* Returns an ip6.arpa character string. */
1478: void addr2ip6arpa( ip_t * ip, char * buf ) {
1479: unsigned char * p = (unsigned char *) ip;
1480: char * b = buf;
1481: int i;
1482:
1483: for ( i = sizeof (struct in6_addr) - 1; i >= 0; i-- ) {
1484: sprintf( b, "%x.%x.", p[i] % 16, p[i] >> 4 );
1485: b += 4;
1486: }
1487: sprintf( b, "ip6.arpa" );
1488: return;
1489: }
1490: #endif
1491:
1492: /* Resolve an IP address to a hostname. */
1493: struct hostent *addr2host( const char *addr, int af ) {
1494: int len = 0;
1495: switch ( af ) {
1496: case AF_INET:
1497: len = sizeof( struct in_addr );
1498: break;
1499: #ifdef ENABLE_IPV6
1500: case AF_INET6:
1501: len = sizeof( struct in6_addr );
1502: break;
1503: #endif
1504: }
1505: return gethostbyaddr( addr, len, af );
1506: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[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