/* $OpenBSD: host.c,v 1.3 1997/04/13 21:25:50 provos Exp $ */ /* * Copyright (c) 1985, 1989 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that: (1) source distributions retain this entire copyright * notice and comment, and (2) distributions including binaries display * the following acknowledgement: ``This product includes software * developed by the University of California, Berkeley and its contributors'' * in the documentation or other materials provided with the distribution * and in all advertising materials mentioning features or use of this * software. Neither the name of the University nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ /* * Originally, this program came from Rutgers University, however it * is based on nslookup and other pieces of named tools, so it needs * that copyright notice. */ /* * Rewritten by Eric Wassenaar, Nikhef-H, * * The officially maintained source of this program is available * via anonymous ftp from machine 'ftp.nikhef.nl' [192.16.199.1] * in the directory '/pub/network' as 'host.tar.Z' * * You are kindly requested to report bugs and make suggestions * for improvements to the author at the given email address, * and to not re-distribute your own modifications to others. */ #ifndef lint static char Version[] = "@(#)host.c e07@nikhef.nl (Eric Wassenaar) 961013"; #endif #if defined(apollo) && defined(lint) #define __attribute(x) #endif #define justfun /* this is only for fun */ #undef obsolete /* old code left as a reminder */ #undef notyet /* new code for possible future use */ /* * New features * * - Major overhaul of the entire code. * - Very rigid error checking, with more verbose error messages. * - Zone listing section completely rewritten. * - It is now possible to do recursive listings into delegated zones. * - Maintain resource record statistics during zone listings. * - Maintain count of hosts during zone listings. * - Check for various extraneous conditions during zone listings. * - Check for illegal domain names containing invalid characters. * - Verify that certain domain names represent canonical host names. * - Perform ttl consistency checking during zone listings. * - Exploit multiple server addresses if available. * - Option to exploit only primary server for zone transfers. * - Option to exclude info from names that do not reside in a zone. * - Implement timeout handling during connect and read. * - Write resource record output to optional log file. * - Special MB tracing by recursively expanding MR and MG records. * - Special mode to check SOA records at each nameserver for a zone. * - Special mode to check reverse mappings of host addresses. * - Extended syntax allows multiple arguments on command line or stdin. * - Configurable default options in HOST_DEFAULTS environment variable. * - Implement new resource record types from RFC 1183 and 1348. * - Basic experimental NSAP support as defined in RFC 1637. * - Implement new resource record types from RFC 1664 and 1712. * - Implement new resource record types from RFC 1876 and 1886. * - Code is extensively documented. */ /* * Publication history * * This information has been moved to the RELEASE_NOTES file. */ /* * Compilation options * * This program usually compiles without special compilation options, * but for some platforms you may have to define special settings. * See the Makefile and the header file port.h for details. */ /* * Miscellaneous notes * * This program should be linked explicitly with the BIND resolver library * in case the default gethostbyname() or gethostbyaddr() routines use a * non-standard strategy for retrieving information. These functions in the * resolver library call on the nameserver, and fall back on the hosts file * only if no nameserver is running (ECONNREFUSED). * * You may also want to link this program with the BIND resolver library if * your default library has not been compiled with DEBUG printout enabled. * * The version of the resolver should be BIND 4.8.2 or later. The crucial * include files are , (resolv.h>, . These files * are assumed to be present in the /usr/include directory. * * The resolver code depends on the definition of the BSD pre-processor * variable. This variable is usually defined in the file . * * The definition of this variable determines the method how to handle * datagram connections. This may not work properly on all platforms. * * The hostent struct defined in is assumed to handle multiple * addresses in h_addr_list[]. Usually this is true if BSD >= 43. * * Your nameserver may not handle queries about top-level zones properly * if the "domain" directive is present in the named.boot file. It will * append the default domain to single names for which no data is cached. * * The treatment of TXT records has changed from 4.8.2 to 4.8.3. Formerly, * the data consisted simply of the text string. Now, the text string is * preceded by the character count with a maximum of 255, and multiple * strings are embedded if the total character count exceeds 255. * We handle only the new situation in this program, assuming that nobody * uses TXT records before 4.8.3 (unfortunately this is not always true: * current vendor supplied software may sometimes be even pre-BIND 4.8.2). * * Note that in 4.8.3 PACKETSZ from nameser.h is still at 512, which is * the maximum possible packet size for datagrams, whereas MAXDATA from * db.h has increased from 256 to 2048. The resolver defines MAXPACKET * as 1024. The nameserver reads queries in a buffer of size BUFSIZ. * * The gethostbyname() routine in 4.8.3 interprets dotted quads (if not * terminated with a dot) and simulates a gethostbyaddr(), but we will * not rely on it, and handle dotted quads ourselves. * * On some systems a bug in the _doprnt() routine exists which prevents * printf("%.*s", n, string) to be printed correctly if n == 0. * * This program has not been optimized for speed. Especially the memory * management is simple and straightforward. */ /* * Terminology used * * Gateway hosts. * These are hosts that have more than one address registered under * the same name. Obviously we cannot recognize a gateway host if it * has different names associated with its different addresses. * * Duplicate hosts. * These are non-gateway hosts of which the address was found earlier * but with a different name, possibly in a totally different zone. * Such hosts should not be counted again in the overall host count. * This situation notably occurs in e.g. the "ac.uk" domain which has * many names registered in both the long and the abbreviated form, * such as 'host.department.university.ac.uk' and 'host.dept.un.ac.uk'. * This is probably not an error per se. It is an error if some domain * has registered a foreign address under a name within its own domain. * To recognize duplicate hosts when traversing many zones, we have to * maintain a global list of host addresses. To simplify things, only * single-address hosts are handled as such. * * Extrazone hosts. * These are hosts which belong to a zone but which are not residing * directly within the zone under consideration and which are not * glue records for a delegated zone of the given zone. E.g. if we are * processing the zone 'bar' and find 'host.foo.bar' but 'foo.bar' is not * an NS registered delegated zone of 'bar' then it is considered to be * an extrazone host. This is not necessarily an error, but it could be. * * Lame delegations. * If we query the SOA record of a zone at a supposedly authoritative * nameserver for that zone (listed in the NS records for the zone), * the SOA record should be present and the answer authoritative. * If not, we flag a lame delegation of the zone to that nameserver. * This may need refinement in some special cases. * A lame delegation is also flagged if we discover that a nameserver * mentioned in an NS record does not exist when looking up its address. * * Primary nameserver. * This utility assumes that the first domain name in the RHS of the * SOA record for a zone contains the name of the primary nameserver * (or one of the primary nameservers) for that zone. Unfortunately, * this field has not been unambiguously defined. Nevertheless, many * hostmasters interpret the definitions given in RFC 1033 and 1035 * as such, and therefore host will continue doing so. Interpretation * as the machine that holds the zone data disk file is pretty useless. */ /* * Usage: host [options] name [server] * Usage: host [options] -x [name ...] * Usage: host [options] -X server [name ...] * * Regular command line options: * ---------------------------- * * -t type specify query type; default is T_A for normal mode * -a specify query type T_ANY * -v print verbose messages (-vv is very verbose) * -d print debugging output (-dd prints even more) * * Special mode options. * -------------------- * * -l special mode to generate zone listing for a zone * -L level do recursive zone listing/checking this level deep * -p use primary nameserver of zone for zone transfers * -P server give priority to preferred servers for zone transfers * -N zone do not perform zone transfer for these explicit zones * -S print zone resource record statistics * -H special mode to count hosts residing in a zone * -G same as -H but lists gateway hosts in addition * -E same as -H but lists extrazone hosts in addition * -D same as -H but lists duplicate hosts in addition * -C special mode to check SOA records for a zone * -A special mode to check reverse mappings of host addresses * * Miscellaneous options. * --------------------- * * -f filename log resource record output also in given file * -F filename same as -f, but exchange role of stdout and log file * -I chars chars are not considered illegal in domain names * -i generate reverse in-addr.arpa query for dotted quad * -n generate reverse nsap.int query for dotted nsap address * -q be quiet about some non-fatal errors * -T print ttl value during non-verbose output * -Z print selected RR output in full zone file format * * Seldom used options. * ------------------- * * -c class specify query class; default is C_IN * -e exclude info from names that do not reside in the zone * -m specify query type T_MAILB and trace MB records * -o suppress resource record output to stdout * -r do not use recursion when querying nameserver * -R repeatedly add search domains to qualify queryname * -s secs specify timeout value in seconds; default is 2 * 5 * -u use virtual circuit instead of datagram for queries * -w wait until nameserver becomes available * * Undocumented options. (Experimental, subject to change) * -------------------- * * -g length only select names that are at least this long * -B enforce full BIND behavior during DNSRCH * -M special mode to list mailable delegated zones of zone * -W special mode to list wildcard records in a zone * -z special mode to list delegated zones in a zone */ static char Usage[] = "\ Usage: host [-v] [-a] [-t querytype] [options] name [server]\n\ Listing: host [-v] [-a] [-t querytype] [options] -l zone [server]\n\ Hostcount: host [-v] [options] -H [-D] [-E] [-G] zone\n\ Check soa: host [-v] [options] -C zone\n\ Addrcheck: host [-v] [options] -A host\n\ Listing options: [-L level] [-S] [-A] [-p] [-P prefserver] [-N skipzone]\n\ Common options: [-d] [-f|-F filename] [-I chars] [-i|-n] [-q] [-T] [-Z]\n\ Other options: [-c class] [-e] [-m] [-o] [-r] [-R] [-s secs] [-u] [-w]\n\ Extended usage: [-x [name ...]] [-X server [name ...]]\ "; #include #include #include #include #include #include /* not always automatically included */ #include #include #include #undef NOERROR /* in on solaris 2.x */ #include #include #include #include "port.h" /* various portability definitions */ #include "conf.h" /* various configuration definitions */ #include "type.h" /* types should be in */ #include "exit.h" /* exit codes come from */ typedef int bool; /* boolean type */ #define TRUE 1 #define FALSE 0 #ifndef NO_DATA #define NO_DATA NO_ADDRESS /* used here only in case authoritative */ #endif #define NO_RREC (NO_DATA + 1) /* used for non-authoritative NO_DATA */ #define NO_HOST (NO_DATA + 2) /* used for non-authoritative HOST_NOT_FOUND */ #define QUERY_REFUSED (NO_DATA + 3) /* query was refused by server */ #define SERVER_FAILURE (NO_DATA + 4) /* instead of TRY_AGAIN upon SERVFAIL */ #define HOST_NOT_CANON (NO_DATA + 5) /* host name is not canonical */ #define T_NONE 0 /* yet unspecified resource record type */ #define T_FIRST T_A /* first possible type in resource record */ #define T_LAST (T_IXFR - 1) /* last possible type in resource record */ #ifndef NOCHANGE #define NOCHANGE 0xf /* compatibility with older BIND versions */ #endif #define NOT_DOTTED_QUAD ((ipaddr_t)-1) #define BROADCAST_ADDR ((ipaddr_t)0xffffffff) #define LOCALHOST_ADDR ((ipaddr_t)0x7f000001) #if PACKETSZ > 8192 #define MAXPACKET PACKETSZ /* PACKETSZ should be the max udp size (512) */ #else #define MAXPACKET 8192 /* but tcp packets can be considerably larger */ #endif typedef union { HEADER header; u_char packet[MAXPACKET]; } querybuf; #ifndef HFIXEDSZ #define HFIXEDSZ 12 /* actually sizeof(HEADER) */ #endif #define MAXDLEN (MAXPACKET - HFIXEDSZ) /* upper bound for dlen */ #include "rrec.h" /* resource record structures */ #define input /* read-only input parameter */ #define output /* modified output parameter */ #define STDIN 0 #define STDOUT 1 #define STDERR 2 #ifdef lint #define EXTERN #else #define EXTERN extern #endif EXTERN int errno; EXTERN int h_errno; /* defined in the resolver library */ EXTERN res_state_t _res; /* defined in res_init.c */ extern char *dbprefix; /* prefix for debug messages (send.c) */ extern char *version; /* program version number (vers.c) */ char **optargv = NULL; /* argument list including default options */ int optargc = 0; /* number of arguments in new argument list */ int errorcount = 0; /* global error count */ int record_stats[T_ANY+1]; /* count of resource records per type */ char cnamebuf[MAXDNAME+1]; char *cname = NULL; /* RHS name to which CNAME is aliased */ char mnamebuf[MAXDNAME+1]; char *mname = NULL; /* RHS name to which MR or MG is aliased */ char soanamebuf[MAXDNAME+1]; char *soaname = NULL; /* LHS domain name of SOA record */ char subnamebuf[MAXDNAME+1]; char *subname = NULL; /* LHS domain name of NS record */ char adrnamebuf[MAXDNAME+1]; char *adrname = NULL; /* LHS domain name of A record */ ipaddr_t address; /* internet address of A record */ char *listhost = NULL; /* actual host queried during zone listing */ char serverbuf[MAXDNAME+1]; char *server = NULL; /* name of explicit server to query */ char realnamebuf[2*MAXDNAME+2]; char *realname = NULL; /* the actual name that was queried */ FILE *logfile = NULL; /* default is stdout only */ bool logexchange = FALSE; /* exchange role of log file and stdout */ char *illegal = NULL; /* give warning about illegal domain names */ char *skipzone = NULL; /* zone(s) for which to skip zone transfer */ char *prefserver = NULL; /* preferred server(s) for zone listing */ char *queryname = NULL; /* the name about which to query */ int querytype = T_NONE; /* the type of the query */ int queryclass = C_IN; /* the class of the query */ ipaddr_t queryaddr; /* set if name to query is dotted quad */ int debug = 0; /* print resolver debugging output */ int verbose = 0; /* verbose mode for extra output */ #ifdef justfun int namelen = 0; /* select records exceeding this length */ #endif int recursive = 0; /* recursive listmode maximum level */ int recursion_level = 0; /* current recursion level */ int skip_level = 0; /* level beyond which to skip checks */ int print_level = 0; /* level below which to skip verbose output */ bool quiet = FALSE; /* suppress non-fatal warning messages */ bool reverse = FALSE; /* generate reverse in-addr.arpa queries */ bool revnsap = FALSE; /* generate reverse nsap.int queries */ bool primary = FALSE; /* use primary server for zone transfers */ bool suppress = FALSE; /* suppress resource record output */ bool dotprint = FALSE; /* print trailing dot in non-listing mode */ bool ttlprint = FALSE; /* print ttl value in non-verbose mode */ bool waitmode = FALSE; /* wait until server becomes available */ bool mailmode = FALSE; /* trace MG and MR into MB records */ bool addrmode = FALSE; /* check reverse mappings of addresses */ bool listmode = FALSE; /* generate zone listing of a zone */ bool hostmode = FALSE; /* count real hosts residing within zone */ bool duplmode = FALSE; /* list duplicate hosts within zone */ bool extrmode = FALSE; /* list extrazone hosts within zone */ bool gatemode = FALSE; /* list gateway hosts within zone */ bool checkmode = FALSE; /* check SOA records at each nameserver */ bool mxdomains = FALSE; /* list MX records for each delegated zone */ bool wildcards = FALSE; /* list only wildcard records in a zone */ bool listzones = FALSE; /* list only delegated zones in a zone */ bool exclusive = FALSE; /* exclude records that are not in zone */ bool recurskip = FALSE; /* skip certain checks during recursion */ bool statistics = FALSE; /* print resource record statistics */ bool bindcompat = FALSE; /* enforce full BIND DNSRCH compatibility */ bool classprint = FALSE; /* print class value in non-verbose mode */ #include "defs.h" /* declaration of functions */ #define is_xdigit(c) (isascii(c) && isxdigit(c)) #define is_space(c) (isascii(c) && isspace(c)) #define is_alnum(c) (isascii(c) && isalnum(c)) #define is_upper(c) (isascii(c) && isupper(c)) #define lowercase(c) (is_upper(c) ? tolower(c) : (c)) #define lower(c) (((c) >= 'A' && (c) <= 'Z') ? (c) + 'a' - 'A' : (c)) #define hexdigit(n) (((n) < 10) ? '0' + (n) : 'A' + (n) - 10); #define bitset(a,b) (((a) & (b)) != 0) #define sameword(a,b) (strcasecmp(a,b) == 0) #define samepart(a,b) (strncasecmp(a,b,strlen(b)) == 0) #define samehead(a,b) (strncasecmp(a,b,sizeof(b)-1) == 0) #define fakename(a) (samehead(a,"localhost.") || samehead(a,"loopback.")) #define nulladdr(a) (((a) == 0) || ((a) == BROADCAST_ADDR)) #define fakeaddr(a) (nulladdr(a) || ((a) == htonl(LOCALHOST_ADDR))) #define incopy(a) *((struct in_addr *)(a)) #define querysize(n) (((n) > sizeof(querybuf)) ? sizeof(querybuf) : (n)) #define newlist(a,n,t) (t *)xalloc((ptr_t *)(a), (siz_t)((n)*sizeof(t))) #define newstruct(t) (t *)xalloc((ptr_t *)NULL, (siz_t)(sizeof(t))) #define newstring(s) (char *)xalloc((ptr_t *)NULL, (siz_t)(strlen(s)+1)) #define newstr(s) strcpy(newstring(s), s) #define xfree(a) (void) free((ptr_t *)(a)) #define strlength(s) (int)strlen(s) #define in_string(s,c) (index(s,c) != NULL) #define is_quoted(a,b) (((a) > (b)) && ((a)[-1] == '\\')) #define plural(n) (((n) == 1) ? "" : "s") #define plurale(n) (((n) == 1) ? "" : "es") #ifdef DEBUG #define assert(condition)\ {\ if (!(condition))\ {\ (void) fprintf(stderr, "assertion botch: ");\ (void) fprintf(stderr, "%s(%d): ", __FILE__, __LINE__);\ (void) fprintf(stderr, "%s\n", "condition");\ exit(EX_SOFTWARE);\ }\ } #else #define assert(condition) #endif /* ** MAIN -- Start of program host ** ----------------------------- ** ** Exits: ** EX_SUCCESS Operation successfully completed ** EX_UNAVAILABLE Could not obtain requested information ** EX_CANTCREAT Could not create specified log file ** EX_NOINPUT No input arguments were found ** EX_NOHOST Could not lookup explicit server ** EX_OSERR Could not obtain resources ** EX_USAGE Improper parameter/option specified ** EX_SOFTWARE Assertion botch in DEBUG mode */ int main(argc, argv) input int argc; input char *argv[]; { register char *option; res_state_t new_res; /* new resolver database */ int result; /* result status of action taken */ char *program; /* name that host was called with */ char *servername = NULL; /* name of explicit server */ char *logfilename = NULL; /* name of log file */ bool extended = FALSE; /* accept extended argument syntax */ assert(sizeof(int) >= 4); /* probably paranoid */ #ifdef obsolete assert(sizeof(u_short) == 2); /* perhaps less paranoid */ assert(sizeof(ipaddr_t) == 4); /* but this is critical */ #endif /* * Synchronize stdout and stderr in case output is redirected. */ linebufmode(stdout); /* * Initialize resolver, set new defaults. See show_res() for details. * The old defaults are (RES_RECURSE | RES_DEFNAMES | RES_DNSRCH) */ (void) res_init(); _res.options |= RES_DEFNAMES; /* qualify single names */ _res.options &= ~RES_DNSRCH; /* dotted names are qualified */ _res.options |= RES_RECURSE; /* request nameserver recursion */ _res.options &= ~RES_DEBUG; /* turn off debug printout */ _res.options &= ~RES_USEVC; /* do not use virtual circuit */ _res.retry = DEF_RETRIES; /* number of datagram retries */ _res.retrans = DEF_RETRANS; /* timeout in secs between retries */ /* initialize packet id */ _res.id = res_randomid(); /* save new defaults */ new_res = _res; /* * Check whether host was called with a different name. * Interpolate default options and parameters. */ if (argc < 1 || argv[0] == NULL) fatal(Usage); option = getenv("HOST_DEFAULTS"); if (option != NULL) { set_defaults(option, argc, argv); argc = optargc; argv = optargv; } program = rindex(argv[0], '/'); if (program++ == NULL) program = argv[0]; /* check for resource record names */ querytype = parse_type(program); if (querytype < 0) querytype = T_NONE; /* check for zone listing abbreviation */ if (sameword(program, "zone")) listmode = TRUE; /* * Scan command line options and flags. */ while (argc > 1 && argv[1] != NULL && argv[1][0] == '-') { for (option = &argv[1][1]; *option != '\0'; option++) { switch (*option) { case 'w' : waitmode = TRUE; new_res.retry = DEF_RETRIES; new_res.retrans = DEF_RETRANS; break; case 's' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing timeout value"); new_res.retry = DEF_RETRIES; new_res.retrans = atoi(argv[2]); if (new_res.retrans <= 0) fatal("Invalid timeout value %s", argv[2]); argv++; argc--; break; case 'r' : new_res.options &= ~RES_RECURSE; break; case 'B' : bindcompat = TRUE; /*FALLTHROUGH*/ case 'R' : new_res.options |= RES_DNSRCH; break; case 'u' : new_res.options |= RES_USEVC; break; case 'd' : new_res.options |= RES_DEBUG; debug++; /* increment debugging level */ break; case 'v' : verbose++; /* increment verbosity level */ break; case 'q' : quiet = TRUE; break; case 'i' : reverse = TRUE; break; case 'n' : revnsap = TRUE; break; case 'p' : primary = TRUE; break; case 'o' : suppress = TRUE; break; case 'e' : exclusive = TRUE; break; case 'S' : statistics = TRUE; break; case 'T' : ttlprint = TRUE; break; case 'Z' : dotprint = TRUE; ttlprint = TRUE; classprint = TRUE; break; case 'A' : addrmode = TRUE; break; case 'D' : case 'E' : case 'G' : case 'H' : if (*option == 'D') duplmode = TRUE; if (*option == 'E') extrmode = TRUE; if (*option == 'G') gatemode = TRUE; hostmode = TRUE; listmode = TRUE; if (querytype == T_NONE) querytype = -1; /* suppress zone data output */ break; case 'C' : checkmode = TRUE; listmode = TRUE; if (querytype == T_NONE) querytype = -1; /* suppress zone data output */ break; case 'z' : listzones = TRUE; listmode = TRUE; if (querytype == T_NONE) querytype = -1; /* suppress zone data output */ break; case 'M' : mxdomains = TRUE; listmode = TRUE; if (querytype == T_NONE) querytype = -1; /* suppress zone data output */ break; case 'W' : wildcards = TRUE; listmode = TRUE; if (querytype == T_NONE) querytype = T_MX; break; case 'L' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing recursion level"); recursive = atoi(argv[2]); if (recursive <= 0) fatal("Invalid recursion level %s", argv[2]); argv++; argc--; /*FALLTHROUGH*/ case 'l' : listmode = TRUE; break; case 'c' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing query class"); queryclass = parse_class(argv[2]); if (queryclass < 0) fatal("Invalid query class %s", argv[2]); argv++; argc--; break; case 't' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing query type"); querytype = parse_type(argv[2]); if (querytype < 0) fatal("Invalid query type %s", argv[2]); argv++; argc--; break; case 'a' : querytype = T_ANY; /* filter anything available */ break; case 'm' : mailmode = TRUE; querytype = T_MAILB; /* filter MINFO/MG/MR/MB data */ break; case 'I' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing allowed chars"); illegal = argv[2]; argv++; argc--; break; case 'P' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing preferred server"); prefserver = argv[2]; argv++; argc--; break; case 'N' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing zone to be skipped"); skipzone = argv[2]; argv++; argc--; break; case 'F' : logexchange = TRUE; /*FALLTHROUGH*/ case 'f' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing log file name"); logfilename = argv[2]; argv++; argc--; break; case 'X' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing server name"); servername = argv[2]; argv++; argc--; /*FALLTHROUGH*/ case 'x' : extended = TRUE; break; #ifdef justfun case 'g' : if (argv[2] == NULL || argv[2][0] == '-') fatal("Missing minimum length"); namelen = atoi(argv[2]); if (namelen <= 0) fatal("Invalid minimum length %s", argv[2]); argv++; argc--; break; #endif case 'V' : printf("Version %s\n", version); exit(EX_SUCCESS); default: fatal(Usage); } } argv++; argc--; } /* * Check the remaining arguments. */ /* old syntax must have at least one argument */ if (!extended && (argc < 2 || argv[1] == NULL || argc > 3)) fatal(Usage); /* old syntax has explicit server as second argument */ if (!extended && (argc > 2 && argv[2] != NULL)) servername = argv[2]; /* * Open log file if requested. */ if (logfilename != NULL) set_logfile(logfilename); /* * Set default preferred server for zone listings, if not specified. */ if (listmode && (prefserver == NULL)) prefserver = myhostname(); /* * Check for possible alternative server. Use new resolver defaults. */ if (servername != NULL) set_server(servername); /* * Do final resolver initialization. * Show resolver parameters and special environment options. */ /* set new resolver values changed by command options */ _res.retry = new_res.retry; _res.retrans = new_res.retrans; _res.options = new_res.options; /* show the new resolver database */ if (verbose > 1 || debug > 1) show_res(); /* show customized default domain */ option = getenv("LOCALDOMAIN"); if (option != NULL && verbose > 1) printf("Explicit local domain %s\n\n", option); /* * Process command line argument(s) depending on syntax. */ if (!extended) /* only one argument */ result = process_name(argv[1]); else if (argc < 2) /* no arguments */ result = process_file(stdin); else /* multiple command line arguments */ result = process_argv(argc, argv); /* * Report result status of action taken. */ exit(result); /*NOTREACHED*/ } /* ** SET_DEFAULTS -- Interpolate default options and parameters in argv ** ------------------------------------------------------------------ ** ** The HOST_DEFAULTS environment variable gives customized options. ** ** Returns: ** None. ** ** Outputs: ** Creates ``optargv'' vector with ``optargc'' arguments. */ void set_defaults(option, argc, argv) input char *option; /* option string */ input int argc; /* original command line arg count */ input char *argv[]; /* original command line arguments */ { register char *p, *q; register int i; /* * Allocate new argument vector. */ optargv = newlist(NULL, 2, char *); optargv[0] = argv[0]; optargc = 1; /* * Construct argument list from option string. */ for (q = "", p = newstr(option); *p != '\0'; p = q) { while (is_space(*p)) p++; if (*p == '\0') break; for (q = p; *q != '\0' && !is_space(*q); q++) continue; if (*q != '\0') *q++ = '\0'; optargv = newlist(optargv, optargc+2, char *); optargv[optargc] = p; optargc++; } /* * Append command line arguments. */ for (i = 1; i < argc && argv[i] != NULL; i++) { optargv = newlist(optargv, optargc+2, char *); optargv[optargc] = argv[i]; optargc++; } /* and terminate */ optargv[optargc] = NULL; } /* ** PROCESS_ARGV -- Process command line arguments ** ---------------------------------------------- ** ** Returns: ** EX_SUCCESS if information was obtained successfully. ** Appropriate exit code otherwise. */ int process_argv(argc, argv) input int argc; input char *argv[]; { register int i; int result; /* result status of action taken */ int excode = EX_NOINPUT; /* overall result status */ for (i = 1; i < argc && argv[i] != NULL; i++) { /* process a single argument */ result = process_name(argv[i]); /* maintain overall result */ if (result != EX_SUCCESS || excode == EX_NOINPUT) excode = result; } /* return overall result */ return(excode); } /* ** PROCESS_FILE -- Process arguments from input file ** ------------------------------------------------- ** ** Returns: ** EX_SUCCESS if information was obtained successfully. ** Appropriate exit code otherwise. */ int process_file(fp) input FILE *fp; /* input file with query names */ { register char *p, *q; char buf[BUFSIZ]; int result; /* result status of action taken */ int excode = EX_NOINPUT; /* overall result status */ while (fgets(buf, sizeof(buf), fp) != NULL) { p = index(buf, '\n'); if (p != NULL) *p = '\0'; /* extract names separated by whitespace */ for (q = "", p = buf; *p != '\0'; p = q) { while (is_space(*p)) p++; /* ignore comment lines */ if (*p == '\0' || *p == '#' || *p == ';') break; for (q = p; *q != '\0' && !is_space(*q); q++) continue; if (*q != '\0') *q++ = '\0'; /* process a single argument */ result = process_name(p); /* maintain overall result */ if (result != EX_SUCCESS || excode == EX_NOINPUT) excode = result; } } /* return overall result */ return(excode); } /* ** PROCESS_NAME -- Process a single command line argument ** ------------------------------------------------------ ** ** Returns: ** EX_SUCCESS if information was obtained successfully. ** Appropriate exit code otherwise. ** ** Wrapper for execute_name() to hide administrative tasks. */ int process_name(name) input char *name; /* command line argument */ { int result; /* result status of action taken */ static int save_querytype; static bool save_reverse; static bool firstname = TRUE; /* separate subsequent pieces of output */ if (!firstname && (verbose || debug || checkmode)) printf("\n"); /* * Some global variables are redefined further on. Save their initial * values in the first pass, and restore them during subsequent passes. */ if (firstname) { save_querytype = querytype; save_reverse = reverse; firstname = FALSE; } else { querytype = save_querytype; reverse = save_reverse; } /* * Do the real work. */ result = execute_name(name); return(result); } /* ** EXECUTE_NAME -- Process a single command line argument ** ------------------------------------------------------ ** ** Returns: ** EX_SUCCESS if information was obtained successfully. ** Appropriate exit code otherwise. ** ** Outputs: ** Defines ``queryname'' and ``queryaddr'' appropriately. ** ** Side effects: ** May redefine ``querytype'' and ``reverse'' if necessary. */ int execute_name(name) input char *name; /* command line argument */ { bool result; /* result status of action taken */ /* check for nonsense input name */ if (strlength(name) > MAXDNAME) { errmsg("Query name %s too long", name); return(EX_USAGE); } /* * Analyze the name and type to be queried about. * The name can be an ordinary domain name, or an internet address * in dotted quad notation. If the -n option is given, the name is * supposed to be a dotted nsap address. * Furthermore, an empty input name is treated as the root domain. */ queryname = name; if (queryname[0] == '\0') queryname = "."; if (sameword(queryname, ".")) queryaddr = NOT_DOTTED_QUAD; else queryaddr = inet_addr(queryname); /* * Generate reverse in-addr.arpa query if so requested. * The input name must be a dotted quad, and be convertible. */ if (reverse) { if (queryaddr == NOT_DOTTED_QUAD) name = NULL; else name = in_addr_arpa(queryname); if (name == NULL) { errmsg("Invalid dotted quad %s", queryname); return(EX_USAGE); } /* redefine appropriately */ queryname = name; queryaddr = NOT_DOTTED_QUAD; } /* * Generate reverse nsap.int query if so requested. * The input name must be a dotted nsap, and be convertible. */ if (revnsap) { if (reverse) name = NULL; else name = nsap_int(queryname); if (name == NULL) { errmsg("Invalid nsap address %s", queryname); return(EX_USAGE); } /* redefine appropriately */ queryname = name; queryaddr = NOT_DOTTED_QUAD; /* this is also a reversed mapping domain */ reverse = TRUE; } /* * In regular mode, the querytype is used to formulate the nameserver * query, and any response is filtered out when processing the answer. * In listmode, the querytype is used to filter out the proper records. */ /* set querytype for regular mode if unspecified */ if ((querytype == T_NONE) && !listmode) { if ((queryaddr != NOT_DOTTED_QUAD) || reverse) querytype = T_PTR; else querytype = T_A; } /* * Check for incompatible options. */ /* cannot have dotted quad in listmode */ if (listmode && (queryaddr != NOT_DOTTED_QUAD)) { errmsg("Invalid query name %s", queryname); return(EX_USAGE); } /* must have regular name or dotted quad in addrmode */ if (!listmode && addrmode && reverse) { errmsg("Invalid query name %s", queryname); return(EX_USAGE); } /* show what we are going to query about */ if (verbose) show_types(queryname, querytype, queryclass); /* * All set. Perform requested function. */ result = execute(queryname, queryaddr); return(result ? EX_SUCCESS : EX_UNAVAILABLE); } /* ** EXECUTE -- Perform the requested function ** ----------------------------------------- ** ** Returns: ** TRUE if information was obtained successfully. ** FALSE otherwise. ** ** The whole environment has been set up and checked. */ bool execute(name, addr) input char *name; /* name to query about */ input ipaddr_t addr; /* explicit address of query */ { bool result; /* result status of action taken */ /* * Special mode to list contents of specified zone. */ if (listmode) { result = list_zone(name); return(result); } /* * Special mode to check reverse mappings of host addresses. */ if (addrmode) { if (addr == NOT_DOTTED_QUAD) result = check_addr(name); else result = check_name(addr); return(result); } /* * Regular mode to query about specified host. */ result = host_query(name, addr); return(result); } /* ** HOST_QUERY -- Regular mode to query about specified host ** -------------------------------------------------------- ** ** Returns: ** TRUE if information was obtained successfully. ** FALSE otherwise. */ bool host_query(name, addr) input char *name; /* name to query about */ input ipaddr_t addr; /* explicit address of query */ { struct hostent *hp; struct in_addr inaddr; char newnamebuf[MAXDNAME+1]; char *newname = NULL; /* name to which CNAME is aliased */ int ncnames = 0; /* count of CNAMEs in chain */ bool result; /* result status of action taken */ inaddr.s_addr = addr; result = FALSE; h_errno = TRY_AGAIN; /* retry until positive result or permanent failure */ while (result == FALSE && h_errno == TRY_AGAIN) { /* reset before each query to avoid stale data */ errno = 0; realname = NULL; if (addr == NOT_DOTTED_QUAD) { /* reset CNAME indicator */ cname = NULL; /* lookup the name in question */ if (newname == NULL) result = get_hostinfo(name, FALSE); else result = get_hostinfo(newname, TRUE); /* recurse on CNAMEs, but not too deep */ if (cname && (querytype != T_CNAME)) { newname = strcpy(newnamebuf, cname); if (ncnames++ > MAXCHAIN) { errmsg("Possible CNAME loop"); return(FALSE); } result = FALSE; h_errno = TRY_AGAIN; continue; } } else { hp = geth_byaddr((char *)&inaddr, INADDRSZ, AF_INET); if (hp != NULL) { print_host("Name", hp); result = TRUE; } } /* only retry if so requested */ if (!waitmode) break; } /* use actual name if available */ if (realname != NULL) name = realname; /* explain the reason of a failure */ if (result == FALSE) ns_error(name, querytype, queryclass, server); return(result); } /* ** MYHOSTNAME -- Determine our own fully qualified host name ** --------------------------------------------------------- ** ** Returns: ** Pointer to own host name. ** Aborts if host name could not be determined. */ char * myhostname() { struct hostent *hp; static char mynamebuf[MAXDNAME+1]; static char *myname = NULL; if (myname == NULL) { if (gethostname(mynamebuf, MAXDNAME) < 0) { perror("gethostname"); exit(EX_OSERR); } mynamebuf[MAXDNAME] = '\0'; hp = gethostbyname(mynamebuf); if (hp == NULL) { ns_error(mynamebuf, T_A, C_IN, server); errmsg("Error in looking up own name"); exit(EX_NOHOST); } /* cache the result */ myname = strncpy(mynamebuf, hp->h_name, MAXDNAME); myname[MAXDNAME] = '\0'; } return(myname); } /* ** SET_SERVER -- Override default nameserver with explicit server ** -------------------------------------------------------------- ** ** Returns: ** None. ** Aborts the program if an unknown host was given. ** ** Side effects: ** The global variable ``server'' is set to indicate ** that an explicit server is being used. ** ** The default nameserver addresses in the resolver database ** which are initialized by res_init() from /etc/resolv.conf ** are replaced with the (possibly multiple) addresses of an ** explicitly named server host. If a dotted quad is given, ** only that single address will be used. ** ** The answers from such server must be interpreted with some ** care if we don't know beforehand whether it can be trusted. */ void set_server(name) input char *name; /* name of server to be queried */ { register int i; struct hostent *hp; struct in_addr inaddr; ipaddr_t addr; /* explicit address of server */ /* check for nonsense input name */ if (strlength(name) > MAXDNAME) { errmsg("Server name %s too long", name); exit(EX_USAGE); } /* * Overrule the default nameserver addresses. */ addr = inet_addr(name); inaddr.s_addr = addr; if (addr == NOT_DOTTED_QUAD) { /* lookup all of its addresses; this must not fail */ hp = gethostbyname(name); if (hp == NULL) { ns_error(name, T_A, C_IN, server); errmsg("Error in looking up server name"); exit(EX_NOHOST); } for (i = 0; i < MAXNS && hp->h_addr_list[i]; i++) { nslist(i).sin_family = AF_INET; nslist(i).sin_port = htons(NAMESERVER_PORT); nslist(i).sin_addr = incopy(hp->h_addr_list[i]); } _res.nscount = i; } else { /* lookup the name, but use only the given address */ hp = gethostbyaddr((char *)&inaddr, INADDRSZ, AF_INET); nslist(0).sin_family = AF_INET; nslist(0).sin_port = htons(NAMESERVER_PORT); nslist(0).sin_addr = inaddr; _res.nscount = 1; } /* * Indicate the use of an explicit server. */ if (hp != NULL) { server = strncpy(serverbuf, hp->h_name, MAXDNAME); server[MAXDNAME] = '\0'; if (verbose) print_host("Server", hp); } else { server = strcpy(serverbuf, inet_ntoa(inaddr)); if (verbose) printf("Server: %s\n\n", server); } } /* ** SET_LOGFILE -- Initialize optional log file ** ------------------------------------------- ** ** Returns: ** None. ** Aborts the program if the file could not be created. ** ** Side effects: ** The global variable ``logfile'' is set to indicate ** that resource record output is to be written to it. ** ** Swap ordinary stdout and log file output if so requested. */ void set_logfile(filename) input char *filename; /* name of log file */ { if (logexchange) { logfile = fdopen(dup(STDOUT), "w"); if (logfile == NULL) { perror("fdopen"); exit(EX_OSERR); } if (freopen(filename, "w", stdout) == NULL) { perror(filename); exit(EX_CANTCREAT); } } else { logfile = fopen(filename, "w"); if (logfile == NULL) { perror(filename); exit(EX_CANTCREAT); } } } /* ** FATAL -- Abort program when illegal option encountered ** ------------------------------------------------------ ** ** Returns: ** Aborts after issuing error message. */ void /*VARARGS1*/ fatal(fmt, a, b, c, d) input char *fmt; /* format of message */ input char *a, *b, *c, *d; /* optional arguments */ { (void) fprintf(stderr, fmt, a, b, c, d); (void) fprintf(stderr, "\n"); exit(EX_USAGE); } /* ** ERRMSG -- Issue error message to error output ** --------------------------------------------- ** ** Returns: ** None. ** ** Side effects: ** Increments the global error count. */ void /*VARARGS1*/ errmsg(fmt, a, b, c, d) input char *fmt; /* format of message */ input char *a, *b, *c, *d; /* optional arguments */ { (void) fprintf(stderr, fmt, a, b, c, d); (void) fprintf(stderr, "\n"); /* flag an error */ errorcount++; } /* ** GET_HOSTINFO -- Principal routine to query about given name ** ----------------------------------------------------------- ** ** Returns: ** TRUE if requested info was obtained successfully. ** FALSE otherwise. ** ** This is the equivalent of the resolver module res_search(). ** ** In this program RES_DEFNAMES is always on, and RES_DNSRCH ** is off by default. This means that single names without dot ** are always, and only, tried within the own default domain, ** and compound names are assumed to be already fully qualified. ** ** The default BIND behavior can be simulated by turning on ** RES_DNSRCH with -R. The given name, whether or not compound, ** is then first tried within the possible search domains. ** ** Note. In the latter case, the search terminates in case the ** specified name exists but does not have the desired type. ** The BIND behavior is to continue the search. This can be ** simulated with the undocumented option -B. */ bool get_hostinfo(name, qualified) input char *name; /* name to query about */ input bool qualified; /* assume fully qualified if set */ { register char **domain; register char *cp; const char *hp; int dot; /* number of dots in query name */ bool result; /* result status of action taken */ char oldnamebuf[2*MAXDNAME+2]; char *oldname; /* saved actual name when NO_DATA */ int nodata = 0; /* NO_DATA status during DNSRCH */ int nquery = 0; /* number of extra search queries */ /* * Single dot means root zone. */ if (sameword(name, ".")) qualified = TRUE; /* * Names known to be fully qualified are just tried ``as is''. */ if (qualified) { result = get_domaininfo(name, (char *)NULL); return(result); } /* * Count number of dots. Move to the end of the name. */ for (dot = 0, cp = name; *cp != '\0'; cp++) if (*cp == '.') dot++; /* * Check for aliases of single name. * Note that the alias is supposed to be fully qualified. */ if (dot == 0 && (hp = hostalias(name)) != NULL) { if (verbose) printf("Aliased %s to %s\n", name, hp); result = get_domaininfo(hp, (char *)NULL); return(result); } /* * Trailing dot means absolute (fully qualified) address. */ if (dot != 0 && cp[-1] == '.') { cp[-1] = '\0'; result = get_domaininfo(name, (char *)NULL); cp[-1] = '.'; return(result); } /* * Append own default domain and other search domains if appropriate. */ if ((dot == 0 && bitset(RES_DEFNAMES, _res.options)) || (dot != 0 && bitset(RES_DNSRCH, _res.options))) { for (domain = _res.dnsrch; *domain; domain++) { result = get_domaininfo(name, *domain); if (result) return(result); /* keep count of extra search queries */ nquery++; /* in case nameserver not present */ if (errno == ECONNREFUSED) return(FALSE); /* if no further search desired (single name) */ if (!bitset(RES_DNSRCH, _res.options)) break; /* if name exists but has not requested type */ if (h_errno == NO_DATA || h_errno == NO_RREC) { if (bindcompat) { /* remember status and search up */ oldname = strcpy(oldnamebuf, realname); nodata = h_errno; continue; } return(FALSE); } /* retry only if name does not exist at all */ if (h_errno != HOST_NOT_FOUND && h_errno != NO_HOST) break; } } /* * Single name lookup failed. */ if (dot == 0) { /* unclear what actual name should be */ if (nquery != 1) realname = NULL; /* restore nodata status from search */ if (bindcompat && nodata) { realname = strcpy(realnamebuf, oldname); h_errno = nodata; } /* set status in case we never queried */ if (!bitset(RES_DEFNAMES, _res.options)) h_errno = HOST_NOT_FOUND; return(FALSE); } /* * Rest means fully qualified. */ result = get_domaininfo(name, (char *)NULL); /* restore nodata status from search */ if (!result && bindcompat && nodata) { realname = strcpy(realnamebuf, oldname); h_errno = nodata; } return(result); } /* ** GET_DOMAININFO -- Fetch and print desired info about name in domain ** ------------------------------------------------------------------- ** ** Returns: ** TRUE if requested info was obtained successfully. ** FALSE otherwise. ** ** Side effects: ** Sets global variable ``realname'' to actual name queried. ** ** This is the equivalent of the resolver module res_querydomain(). ** ** Things get a little complicated in case RES_DNSRCH is on. ** If we get an answer but the data is corrupted, an error will be ** returned and NO_RECOVERY will be set. This will terminate the ** extra search loop, but a compound name will still be tried as-is. ** The same holds if the query times out or we have a server failure, ** in which case an error will be returned and TRY_AGAIN will be set. ** For now we take this for granted. Normally RES_DNSRCH is disabled. ** In this default case we do only one query and we have no problem. */ bool get_domaininfo(name, domain) input char *name; /* name to query about */ input char *domain; /* domain to which name is relative */ { char namebuf[2*MAXDNAME+2]; /* buffer to store full domain name */ querybuf answer; register int n; bool result; /* result status of action taken */ /* * Show what we are about to query. */ if (verbose) { if (domain == NULL || domain[0] == '\0') printf("Trying %s", name); else printf("Trying %s within %s", name, domain); if (server && (verbose > 1)) printf(" at server %s", server); printf(" ...\n"); } /* * Construct the actual domain name. * A null domain means the given name is already fully qualified. * If the composite name is too long, res_mkquery() will fail. */ if (domain == NULL || domain[0] == '\0') (void) sprintf(namebuf, "%.*s", MAXDNAME, name); else (void) sprintf(namebuf, "%.*s.%.*s", MAXDNAME, name, MAXDNAME, domain); name = namebuf; /* * Fetch the desired info. */ n = get_info(&answer, name, querytype, queryclass); result = (n < 0) ? FALSE : TRUE; /* * Print the relevant data. * If we got a positive answer, the data may still be corrupted. */ if (result) result = print_info(&answer, n, name, querytype, queryclass, TRUE); /* * Remember the actual name that was queried. * Must be at the end to avoid clobbering during recursive calls. */ realname = strcpy(realnamebuf, name); return(result); } /* ** GET_INFO -- Basic routine to issue a nameserver query ** ----------------------------------------------------- ** ** Returns: ** Length of nameserver answer buffer, if obtained. ** -1 if an error occurred (h_errno is set appropriately). ** ** This is the equivalent of the resolver module res_query(). */ int get_info(answerbuf, name, type, class) output querybuf *answerbuf; /* location of buffer to store answer */ input char *name; /* full name to query about */ input int type; /* specific resource record type */ input int class; /* specific resource record class */ { querybuf query; HEADER *bp; int ancount; register int n; /* * Construct query, and send it to the nameserver. * res_send() will fail if no nameserver responded. In the BIND version the * possible values for errno are ECONNREFUSED and ETIMEDOUT. If we did get * an answer, errno should be reset, since res_send() may have left an errno * in case it has used datagrams. Our private version of res_send() will leave * also other error statuses, and will clear errno if an answer was obtained. */ errno = 0; /* reset before querying nameserver */ n = res_mkquery(QUERY, name, class, type, (qbuf_t *)NULL, 0, (rrec_t *)NULL, (qbuf_t *)&query, sizeof(querybuf)); if (n < 0) { if (debug) printf("%sres_mkquery failed\n", dbprefix); h_errno = NO_RECOVERY; return(-1); } n = res_send((qbuf_t *)&query, n, (qbuf_t *)answerbuf, sizeof(querybuf)); if (n < 0) { if (debug) printf("%sres_send failed\n", dbprefix); h_errno = TRY_AGAIN; return(-1); } errno = 0; /* reset after we got an answer */ if (n < HFIXEDSZ) { pr_error("answer length %s too short after %s query for %s", itoa(n), pr_type(type), name); h_errno = NO_RECOVERY; return(-1); } /* * Analyze the status of the answer from the nameserver. */ if ((verbose > print_level) || debug) print_status(answerbuf, n); bp = (HEADER *)answerbuf; ancount = ntohs(bp->ancount); if (bp->rcode != NOERROR || ancount == 0) { switch (bp->rcode) { case NXDOMAIN: /* distinguish between authoritative or not */ h_errno = bp->aa ? HOST_NOT_FOUND : NO_HOST; break; case NOERROR: /* distinguish between authoritative or not */ h_errno = bp->aa ? NO_DATA : NO_RREC; break; case SERVFAIL: h_errno = SERVER_FAILURE; /* instead of TRY_AGAIN */ break; case REFUSED: h_errno = QUERY_REFUSED; /* instead of NO_RECOVERY */ break; default: h_errno = NO_RECOVERY; /* FORMERR NOTIMP NOCHANGE */ break; } return(-1); } /* valid answer received, avoid buffer overrun */ h_errno = 0; return(querysize(n)); } /* ** PRINT_INFO -- Check resource records in answer and print relevant data ** ---------------------------------------------------------------------- ** ** Returns: ** TRUE if answer buffer was processed successfully. ** FALSE otherwise. ** ** Side effects: ** Will recurse on MAILB records if appropriate. ** See also side effects of the print_rrec() routine. */ bool print_info(answerbuf, answerlen, name, type, class, regular) input querybuf *answerbuf; /* location of answer buffer */ input int answerlen; /* length of answer buffer */ input char *name; /* full name we are querying about */ input int type; /* record type we are querying about */ input int class; /* record class we are querying about */ input bool regular; /* set if this is a regular lookup */ { HEADER *bp; int qdcount, ancount, nscount, arcount; u_char *msg, *eom; register u_char *cp; bp = (HEADER *)answerbuf; qdcount = ntohs(bp->qdcount); ancount = ntohs(bp->ancount); nscount = ntohs(bp->nscount); arcount = ntohs(bp->arcount); msg = (u_char *)answerbuf; eom = (u_char *)answerbuf + answerlen; cp = (u_char *)answerbuf + HFIXEDSZ; /* * Skip the query section in the response (present only in normal queries). */ if (qdcount) { while (qdcount > 0 && cp < eom) /* process all records */ { cp = skip_qrec(name, type, class, cp, msg, eom); if (cp == NULL) return(FALSE); qdcount--; } if (qdcount) { pr_error("invalid qdcount after %s query for %s", pr_type(type), name); h_errno = NO_RECOVERY; return(FALSE); } } /* * Process the actual answer section in the response. * During zone transfers, this is the only section available. */ if (ancount) { if ((type != T_AXFR) && verbose && !bp->aa) printf("The following answer is not authoritative:\n"); while (ancount > 0 && cp < eom) { /* reset for each record during zone listings */ soaname = NULL, subname = NULL, adrname = NULL, address = 0; print_level++; cp = print_rrec(name, type, class, cp, msg, eom, regular); print_level--; if (cp == NULL) return(FALSE); ancount--; /* update zone information during zone listings */ if (type == T_AXFR) update_zone(name); /* we trace down CNAME chains ourselves */ if (regular && !verbose && cname) return(TRUE); /* recursively expand MR/MG records into MB records */ if (regular && mailmode && mname) (void) get_recursive(&mname); } if (ancount) { pr_error("invalid ancount after %s query for %s", pr_type(type), name); h_errno = NO_RECOVERY; return(FALSE); } } /* * The nameserver and additional info section are normally not processed. * Both sections shouldn't exist in zone transfers. */ if (!verbose || exclusive) return(TRUE); if (nscount) { printf("Authoritative nameservers:\n"); while (nscount > 0 && cp < eom) { print_level++; cp = print_rrec(name, type, class, cp, msg, eom, FALSE); print_level--; if (cp == NULL) return(FALSE); nscount--; } if (nscount) { pr_error("invalid nscount after %s query for %s", pr_type(type), name); h_errno = NO_RECOVERY; return(FALSE); } } if (arcount) { printf("Additional information:\n"); while (arcount > 0 && cp < eom) { print_level++; cp = print_rrec(name, type, class, cp, msg, eom, FALSE); print_level--; if (cp == NULL) return(FALSE); arcount--; } if (arcount) { pr_error("invalid arcount after %s query for %s", pr_type(type), name); h_errno = NO_RECOVERY; return(FALSE); } } /* all sections were processed successfully */ return(TRUE); } /* ** PRINT_DATA -- Output resource record data if this record is wanted ** ------------------------------------------------------------------ ** ** Returns: ** None. ** ** Inputs: ** The global variable ``doprint'' is set by print_rrec() ** if we need to print the data. */ static bool doprint; /* indicates whether or not to print */ void /*VARARGS1*/ print_data(fmt, a, b, c, d) input char *fmt; /* format of message */ input char *a, *b, *c, *d; /* optional arguments */ { /* if (doprint) */ { if (!suppress) printf(fmt, a, b, c, d); if (logfile != NULL) (void) fprintf(logfile, fmt, a, b, c, d); } } #define doprintf(x)\ {\ if (doprint)\ {\ print_data x ;\ }\ } /* ** PRINT_RREC -- Decode single resource record and output relevant data ** -------------------------------------------------------------------- ** ** Returns: ** Pointer to position in answer buffer after current record. ** NULL if there was a format error in the current record. ** ** Outputs: ** The global variable ``doprint'' is set appropriately ** for use by print_data(). ** ** Side effects: ** Updates resource record statistics in record_stats[]. ** Sets ``soaname'' if this is an SOA record. ** Sets ``subname'' if this is an NS record. ** Sets ``adrname'' if this is an A record. ** Sets ``address'' if this is an A record. ** Sets ``cname'' if this is a valid CNAME record. ** Sets ``mname'' if this is a valid MAILB record. ** These variables must have been cleared before calling ** print_info() and may be checked afterwards. */ /* print domain names after certain conversions */ #define pr_name(x) pr_domain(x, listing) /* check the LHS record name of these records for invalid characters */ #define test_valid(t) (((t == T_A) && !reverse) || t == T_MX || t == T_AAAA) /* check the RHS domain name of these records for canonical host names */ #define test_canon(t) (t == T_NS || t == T_MX) u_char * print_rrec(name, qtype, qclass, cp, msg, eom, regular) input char *name; /* full name we are querying about */ input int qtype; /* record type we are querying about */ input int qclass; /* record class we are querying about */ register u_char *cp; /* current position in answer buf */ input u_char *msg, *eom; /* begin and end of answer buf */ input bool regular; /* set if this is a regular lookup */ { char rname[MAXDNAME+1]; /* record name in LHS */ char dname[MAXDNAME+1]; /* domain name in RHS */ int type, class, ttl, dlen; /* fixed values in every record */ u_char *eor; /* predicted position of next record */ bool classmatch; /* set if we want to see this class */ bool listing; /* set if this is a zone listing */ char *host = listhost; /* contacted host for zone listings */ register int n, c; struct in_addr inaddr; struct protoent *protocol; struct servent *service; /* * Pickup the standard values present in each resource record. */ n = expand_name(name, T_NONE, cp, msg, eom, rname); if (n < 0) return(NULL); cp += n; n = 3*INT16SZ + INT32SZ; if (check_size(rname, T_NONE, cp, msg, eom, n) < 0) return(NULL); type = _getshort(cp); cp += INT16SZ; class = _getshort(cp); cp += INT16SZ; ttl = _getlong(cp); cp += INT32SZ; dlen = _getshort(cp); cp += INT16SZ; eor = cp + dlen; /* * Decide whether or not to print this resource record. */ listing = (qtype == T_AXFR || qtype == T_IXFR) ? TRUE : FALSE; if (listing) { classmatch = want_class(class, queryclass); doprint = classmatch && want_type(type, querytype); } else { classmatch = want_class(class, C_ANY); doprint = classmatch && want_type(type, T_ANY); } if (doprint && exclusive && !indomain(rname, name, TRUE)) doprint = FALSE; if (doprint && exclusive && fakename(rname)) doprint = FALSE; if (doprint && wildcards && !in_string(rname, '*')) doprint = FALSE; #ifdef justfun if (namelen && (strlength(rname) < namelen)) doprint = FALSE; #endif /* * Print name and common values, if appropriate. */ doprintf(("%-20s", pr_name(rname))) if (verbose || ttlprint) doprintf(("\t%s", itoa(ttl))) if (verbose || classprint || (class != qclass)) doprintf(("\t%s", pr_class(class))) doprintf(("\t%s", pr_type(type))) /* * Update resource record statistics for zone listing. */ if (listing && classmatch) { if (type >= T_FIRST && type <= T_LAST) record_stats[type]++; } /* * Save the domain name of an SOA or NS or A record for zone listing. */ if (listing && classmatch) { if (type == T_A) adrname = strcpy(adrnamebuf, rname); else if (type == T_NS) subname = strcpy(subnamebuf, rname); else if (type == T_SOA) soaname = strcpy(soanamebuf, rname); } /* * Print type specific data, if appropriate. */ switch (type) { case T_A: if (class == C_IN || class == C_HS) { if (dlen == INADDRSZ) { bcopy((char *)cp, (char *)&inaddr, INADDRSZ); address = inaddr.s_addr; doprintf(("\t%s", inet_ntoa(inaddr))) cp += INADDRSZ; break; } #ifdef obsolete if (dlen == INADDRSZ + 1 + INT16SZ) { bcopy((char *)cp, (char *)&inaddr, INADDRSZ); address = inaddr.s_addr; doprintf(("\t%s", inet_ntoa(inaddr))) cp += INADDRSZ; n = *cp++; doprintf((" ; proto = %s", itoa(n))) n = _getshort(cp); doprintf((", port = %s", itoa(n))) cp += INT16SZ; break; } #endif address = 0; break; } address = 0; cp += dlen; break; case T_MX: if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf(("\t%s", itoa(n))) cp += INT16SZ; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; break; case T_NS: case T_PTR: case T_CNAME: n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf(("\t%s", pr_name(dname))) cp += n; break; case T_HINFO: if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t\"%s\"", stoa(cp, n, TRUE))) cp += n; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t\"%s\"", stoa(cp, n, TRUE))) cp += n; break; case T_SOA: n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf(("\t%s", pr_name(dname))) cp += n; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; n = 5*INT32SZ; if (check_size(rname, type, cp, msg, eor, n) < 0) break; doprintf((" (")) n = _getlong(cp); doprintf(("\n\t\t\t%s", utoa(n))) doprintf(("\t;serial (version)")) cp += INT32SZ; n = _getlong(cp); doprintf(("\n\t\t\t%s", itoa(n))) doprintf(("\t;refresh period (%s)", pr_time(n, FALSE))) cp += INT32SZ; n = _getlong(cp); doprintf(("\n\t\t\t%s", itoa(n))) doprintf(("\t;retry interval (%s)", pr_time(n, FALSE))) cp += INT32SZ; n = _getlong(cp); doprintf(("\n\t\t\t%s", itoa(n))) doprintf(("\t;expire time (%s)", pr_time(n, FALSE))) cp += INT32SZ; n = _getlong(cp); doprintf(("\n\t\t\t%s", itoa(n))) doprintf(("\t;default ttl (%s)", pr_time(n, FALSE))) cp += INT32SZ; doprintf(("\n\t\t\t)")) break; case T_WKS: if (check_size(rname, type, cp, msg, eor, INADDRSZ) < 0) break; bcopy((char *)cp, (char *)&inaddr, INADDRSZ); doprintf(("\t%s", inet_ntoa(inaddr))) cp += INADDRSZ; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; protocol = getprotobynumber(n); if (protocol != NULL) doprintf((" %s", protocol->p_name)) else doprintf((" %s", itoa(n))) doprintf((" (")) n = 0; while (cp < eor) { c = *cp++; do { if (c & 0200) { int port; port = htons(n); if (protocol != NULL) service = getservbyport(port, protocol->p_name); else service = NULL; if (service != NULL) doprintf((" %s", service->s_name)) else doprintf((" %s", itoa(n))) } c <<= 1; } while (++n & 07); } doprintf((" )")) break; #ifdef obsolete case T_TXT: /* if (dlen > 0) */ { doprintf(("\t\"%s\"", stoa(cp, dlen, TRUE))) cp += dlen; } break; #endif case T_TXT: if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t\"%s\"", stoa(cp, n, TRUE))) cp += n; while (cp < eor) { if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" \"%s\"", stoa(cp, n, TRUE))) cp += n; } break; case T_MINFO: n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf(("\t%s", pr_name(dname))) cp += n; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; break; case T_MB: case T_MG: case T_MR: case T_MD: case T_MF: n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf(("\t%s", pr_name(dname))) cp += n; break; case T_UID: case T_GID: if (dlen == INT32SZ) { n = _getlong(cp); doprintf(("\t%s", itoa(n))) cp += INT32SZ; } break; case T_UINFO: doprintf(("\t\"%s\"", stoa(cp, dlen, TRUE))) cp += dlen; break; case T_RP: n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf(("\t%s", pr_name(dname))) cp += n; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; break; case T_RT: if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf(("\t%s", itoa(n))) cp += INT16SZ; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; break; case T_AFSDB: if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf(("\t%s", itoa(n))) cp += INT16SZ; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; break; case T_X25: if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t%s", stoa(cp, n, FALSE))) cp += n; break; case T_ISDN: if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t%s", stoa(cp, n, FALSE))) cp += n; if (cp < eor) { if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" %s", stoa(cp, n, FALSE))) cp += n; } break; case T_NSAP: doprintf(("\t0x%s", nsap_ntoa(cp, dlen))) cp += dlen; break; case T_NSAPPTR: n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf(("\t%s", pr_name(dname))) cp += n; break; case T_PX: if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf(("\t%s", itoa(n))) cp += INT16SZ; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; break; case T_GPOS: if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t%s", stoa(cp, n, FALSE))) cp += n; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t%s", stoa(cp, n, FALSE))) cp += n; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t%s", stoa(cp, n, FALSE))) cp += n; break; case T_LOC: if ((n = *cp) != T_LOC_VERSION) { pr_error("invalid version %s in %s record for %s", itoa(n), pr_type(type), rname); cp += dlen; break; } n = INT32SZ + 3*INT32SZ; if (check_size(rname, type, cp, msg, eor, n) < 0) break; c = _getlong(cp); cp += INT32SZ; n = _getlong(cp); doprintf(("\t%s ", pr_spherical(n, "N", "S"))) cp += INT32SZ; n = _getlong(cp); doprintf((" %s ", pr_spherical(n, "E", "W"))) cp += INT32SZ; n = _getlong(cp); doprintf((" %sm ", pr_vertical(n, "", "-"))) cp += INT32SZ; doprintf((" %sm", pr_precision((c >> 16) & 0xff))) doprintf((" %sm", pr_precision((c >> 8) & 0xff))) doprintf((" %sm", pr_precision((c >> 0) & 0xff))) break; case T_UNSPEC: case T_NULL: cp += dlen; break; case T_AAAA: if (dlen == IPNGSIZE) { doprintf(("\t%s", ipng_ntoa(cp))) cp += IPNGSIZE; } break; case T_SIG: if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf(("\t%s", pr_type(n))) cp += INT16SZ; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" %s", itoa(n))) n = 1 + 3*INT32SZ + INT16SZ; if (check_size(rname, type, cp, msg, eor, n) < 0) break; doprintf((" (")) n = *cp++; doprintf(("\n\t\t\t; %s", itoa(n))) doprintf(("\t\t;labels")) n = _getlong(cp); doprintf(("\n\t\t\t%s", itoa(n))) doprintf(("\t\t;original ttl")) cp += INT32SZ; n = _getlong(cp); doprintf(("\n\t\t\t%s", pr_date(n))) doprintf(("\t;signature expiration")) cp += INT32SZ; n = _getlong(cp); doprintf(("\n\t\t\t%s", pr_date(n))) doprintf(("\t;signature signed time")) cp += INT32SZ; n = _getshort(cp); doprintf(("\n\t\t\t%s", itoa(n))) doprintf(("\t\t;key footprint")) cp += INT16SZ; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf(("\n\t\t\t%s", pr_name(dname))) cp += n; if (cp < eor) { register char *buf; register int size; n = eor - cp; buf = base_ntoa(cp, n); size = strlength(buf); cp += n; while ((n = (size > 64) ? 64 : size) > 0) { doprintf(("\n\t%s", stoa((u_char *)buf, n, FALSE))) buf += n; size -= n; } } doprintf(("\n\t\t\t)")) break; case T_KEY: if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf(("\t0x%s", xtoa(n))) cp += INT16SZ; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" %s", itoa(n))) if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" %s", itoa(n))) if (cp < eor) { register char *buf; register int size; n = eor - cp; buf = base_ntoa(cp, n); size = strlength(buf); cp += n; doprintf((" (")) while ((n = (size > 64) ? 64 : size) > 0) { doprintf(("\n\t%s", stoa((u_char *)buf, n, FALSE))) buf += n; size -= n; } doprintf(("\n\t\t\t)")) } break; case T_NXT: n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf(("\t%s", pr_name(dname))) cp += n; n = 0; while (cp < eor) { c = *cp++; do { if (c & 0200) { doprintf((" %s", pr_type(n))) } c <<= 1; } while (++n & 07); } break; case T_SRV: if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf(("\t%s", itoa(n))) cp += INT16SZ; if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf((" %s", itoa(n))) cp += INT16SZ; if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf((" %s", itoa(n))) cp += INT16SZ; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; break; case T_EID: case T_NIMLOC: case T_ATMA: doprintf(("\t\"not yet implemented\"")) cp += dlen; break; case T_NAPTR: if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf(("\t%s", itoa(n))) cp += INT16SZ; if (check_size(rname, type, cp, msg, eor, INT16SZ) < 0) break; n = _getshort(cp); doprintf((" %s", itoa(n))) cp += INT16SZ; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" \"%s\"", stoa(cp, n, TRUE))) cp += n; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" \"%s\"", stoa(cp, n, TRUE))) cp += n; if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" \"%s\"", stoa(cp, n, TRUE))) cp += n; n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) break; doprintf((" %s", pr_name(dname))) cp += n; break; #ifdef notyet case T_TSIG: if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf(("\t\"%s\"", stoa(cp, n, TRUE))) cp += n; while (cp < eor) { if (check_size(rname, type, cp, msg, eor, 1) < 0) break; n = *cp++; doprintf((" \"%s\"", stoa(cp, n, TRUE))) cp += n; } break; #endif default: doprintf(("\t\"???\"")) cp += dlen; break; } /* * End of specific data type processing. * Terminate resource record printout. */ doprintf(("\n")) /* * Check whether we have reached the exact end of this resource record. * If not, we cannot be sure that the record has been decoded correctly, * and therefore the subsequent tests will be skipped. */ if (cp != eor) { pr_error("size error in %s record for %s, off by %s", pr_type(type), rname, itoa(cp - eor)); /* we believe value of dlen; should perhaps return(NULL) */ return(eor); } /* * Save the CNAME alias for cname chain tracing. * Save the MR or MG alias for MB chain tracing. * These features can be enabled only in normal mode. */ if (regular && classmatch) { if (type == T_CNAME) cname = strcpy(cnamebuf, dname); else if (type == T_MR || type == T_MG) mname = strcpy(mnamebuf, dname); } /* * Suppress the subsequent checks in quiet mode. * This can safely be done as there are no side effects. * It may speedup things, and nothing would be printed anyway. */ if (quiet) return(cp); /* * In zone listings, resource records with the same name/type/class * must have the same ttl value. Maintain and check list of record info. * This is done on a per-zone basis. */ if (listing && !check_ttl(rname, type, class, ttl)) { pr_warning("%s %s records have different ttl within %s from %s", rname, pr_type(type), name, host); } /* * Check validity of 'host' related domain names in certain resource records. * These include LHS record names and RHS domain names of selected records. * Currently underscores are not reported during deep recursive listings. */ if (test_valid(type) && !valid_name(rname, TRUE, FALSE, recurskip)) { pr_warning("%s %s record has illegal name", rname, pr_type(type)); } if (test_canon(type) && !valid_name(dname, FALSE, FALSE, recurskip)) { pr_warning("%s %s host %s has illegal name", rname, pr_type(type), dname); } /* * The RHS of various resource records should refer to a canonical host name, * i.e. it should exist and have an A record and not be a CNAME. * Currently this test is suppressed during deep recursive zone listings. */ if (!recurskip && test_canon(type) && ((n = check_canon(dname)) != 0)) { /* only report definitive target host failures */ if (n == HOST_NOT_FOUND) pr_warning("%s %s host %s does not exist", rname, pr_type(type), dname); else if (n == NO_DATA) pr_warning("%s %s host %s has no A record", rname, pr_type(type), dname); else if (n == HOST_NOT_CANON) pr_warning("%s %s host %s is not canonical", rname, pr_type(type), dname); /* authoritative failure to find nameserver target host */ if (type == T_NS && (n == NO_DATA || n == HOST_NOT_FOUND)) { if (server == NULL) errmsg("%s has lame delegation to %s", rname, dname); } } /* * On request, reverse map the address of an A record, and verify that * it is registered and maps back to the name of the A record. * Currently this option has effect here only during zone listings. */ if (addrmode && ((type == T_A) && !reverse) && !fakeaddr(address)) { host = mapreverse(rname, inaddr); if (host == NULL) pr_warning("%s address %s is not registered", rname, inet_ntoa(inaddr)); else if (host != rname) pr_warning("%s address %s maps to %s", rname, inet_ntoa(inaddr), host); } /* * This record was processed successfully. */ return(cp); } /* ** SKIP_QREC -- Skip the query record in the nameserver answer buffer ** ------------------------------------------------------------------ ** ** Returns: ** Pointer to position in answer buffer after current record. ** NULL if there was a format error in the current record. */ u_char * skip_qrec(name, qtype, qclass, cp, msg, eom) input char *name; /* full name we are querying about */ input int qtype; /* record type we are querying about */ input int qclass; /* record class we are querying about */ register u_char *cp; /* current position in answer buf */ input u_char *msg, *eom; /* begin and end of answer buf */ { char rname[MAXDNAME+1]; /* record name in LHS */ int type, class; /* fixed values in query record */ register int n; /* * Pickup the standard values present in the query section. */ n = expand_name(name, T_NONE, cp, msg, eom, rname); if (n < 0) return(NULL); cp += n; n = 2*INT16SZ; if (check_size(rname, T_NONE, cp, msg, eom, n) < 0) return(NULL); type = _getshort(cp); cp += INT16SZ; class = _getshort(cp); cp += INT16SZ; #ifdef lint if (verbose) printf("%-20s\t%s\t%s\n", rname, pr_class(class), pr_type(type)); #endif /* * The values in the answer should match those in the query. * If there is a mismatch, we just signal an error, but don't abort. * For regular queries there is exactly one record in the query section. */ if (!sameword(rname, name)) pr_error("invalid answer name %s after %s query for %s", rname, pr_type(qtype), name); if (type != qtype) pr_error("invalid answer type %s after %s query for %s", pr_type(type), pr_type(qtype), name); if (class != qclass) pr_error("invalid answer class %s after %s query for %s", pr_class(class), pr_type(qtype), name); return(cp); } /* ** GET_RECURSIVE -- Wrapper for get_hostinfo() during recursion ** ------------------------------------------------------------ ** ** Returns: ** TRUE if requested info was obtained successfully. ** FALSE otherwise. */ bool get_recursive(name) input char **name; /* name to query about */ { static int level = 0; /* recursion level */ char newnamebuf[MAXDNAME+1]; char *newname; /* new name to look up */ bool result; /* result status of action taken */ int save_errno; int save_herrno; if (level > MAXCHAIN) { errmsg("Recursion too deep"); return(FALSE); } /* save local copy, and reset indicator */ newname = strcpy(newnamebuf, *name); *name = NULL; save_errno = errno; save_herrno = h_errno; level++; result = get_hostinfo(newname, TRUE); level--; errno = save_errno; h_errno = save_herrno; return(result); } /* * Nameserver information. * Stores names and addresses of all servers that are to be queried * for a zone transfer of the desired zone. Normally these are the * authoritative primary and/or secondary nameservers for the zone. */ char nsname[MAXNSNAME][MAXDNAME+1]; /* nameserver host name */ struct in_addr ipaddr[MAXNSNAME][MAXIPADDR]; /* nameserver addresses */ int naddrs[MAXNSNAME]; /* count of addresses */ int nservers = 0; /* count of nameservers */ #ifdef notyet typedef struct srvr_data { char sd_nsname[MAXDNAME+1]; /* nameserver host name */ struct in_addr sd_ipaddr[MAXIPADDR]; /* nameserver addresses */ int sd_naddrs; /* count of addresses */ } srvr_data_t; srvr_data_t nsinfo[MAXNSNAME]; /* nameserver info */ #endif bool authserver; /* server is supposed to be authoritative */ bool lameserver; /* server could not provide SOA service */ /* * Host information. * Stores names and (single) addresses encountered during the zone listing * of all A records that belong to the zone. Non-authoritative glue records * that do not belong to the zone are not stored. Glue records that belong * to a delegated zone will be filtered out later during the host count scan. * The host names are allocated dynamically. * The list itself is also allocated dynamically, to avoid static limits, * and to keep the initial bss of the executable to a reasonable size. * Allocation is done in chunks, to reduce considerable malloc overhead. * Note that the list will not shrink during recursive processing. */ #ifdef obsolete char *hostname[MAXHOSTS]; /* host name of host in zone */ ipaddr_t hostaddr[MAXHOSTS]; /* first host address */ bool multaddr[MAXHOSTS]; /* set if this is a multiple address host */ #endif typedef struct host_data { char *hd_hostname; /* host name of host in zone */ ipaddr_t hd_hostaddr; /* first host address */ bool hd_multaddr; /* set if this is a multiple address host */ } host_data_t; host_data_t *hostlist = NULL; /* info on hosts in zone */ int hostcount = 0; /* count of hosts in zone */ int maxhosts = 0; /* number of allocated hostlist entries */ #define MAXHOSTINCR 4096 /* chunk size to increment hostlist */ #define hostname(i) hostlist[i].hd_hostname #define hostaddr(i) hostlist[i].hd_hostaddr #define multaddr(i) hostlist[i].hd_multaddr /* * Delegated zone information. * Stores the names of the delegated zones encountered during the zone * listing. The names and the list itself are allocated dynamically. */ char **zonename = NULL; /* names of delegated zones within zone */ int zonecount = 0; /* count of delegated zones within zone */ /* * Address information. * Stores the (single) addresses of hosts found in all zones traversed. * Used to search for duplicate hosts (same address but different name). * The list of addresses is allocated dynamically, and remains allocated. * This has now been implemented as a hashed list, using the low-order * address bits as the hash key. */ #ifdef obsolete ipaddr_t *addrlist = NULL; /* global list of addresses */ int addrcount = 0; /* count of global addresses */ #endif /* * SOA record information. */ soa_data_t soa; /* buffer to store soa data */ int soacount = 0; /* count of SOA records during listing */ /* * Nameserver preference. * As per BIND 4.9.* resource records may be returned after round-robin * reshuffling each time they are retrieved. For NS records, this may * lead to an unfavorable order for doing zone transfers. * We apply some heuristic to sort the NS records according to their * preference with respect to a given list of preferred server domains. */ int nsrank[MAXNSNAME]; /* nameserver ranking after sorting */ int nspref[MAXNSNAME]; /* nameserver preference value */ /* ** LIST_ZONE -- Basic routine to do complete zone listing and checking ** ------------------------------------------------------------------- ** ** Returns: ** TRUE if the requested info was processed successfully. ** FALSE otherwise. */ int total_calls = 0; /* number of calls for zone processing */ int total_check = 0; /* number of zones successfully processed */ int total_tries = 0; /* number of zone transfer attempts */ int total_zones = 0; /* number of successful zone transfers */ int total_hosts = 0; /* number of hosts in all traversed zones */ int total_dupls = 0; /* number of duplicates in all zones */ #ifdef justfun char longname[MAXDNAME+1]; /* longest host name found */ int longsize = 0; /* size of longest host name */ #endif bool list_zone(name) input char *name; /* name of zone to process */ { register int n; register int i; int nzones; /* count of delegated zones */ int nhosts; /* count of real host names */ int ndupls; /* count of duplicate hosts */ int nextrs; /* count of extrazone hosts */ int ngates; /* count of gateway hosts */ total_calls += 1; /* update zone processing calls */ /* * Normalize to not have trailing dot, unless it is the root zone. */ n = strlength(name); if (n > 1 && name[n-1] == '.') name[n-1] = '\0'; /* * Indicate whether we are processing an in-addr.arpa reverse zone. * In this case we will suppress accumulating host count statistics. */ reverse = indomain(name, ARPA_ROOT, FALSE); /* * Suppress various checks if working beyond the recursion skip level. * This affects processing in print_rrec(). It may need refinement. */ recurskip = ((recursion_level > skip_level) && !addrmode) ? TRUE : FALSE; /* * Find the nameservers for the given zone. */ (void) find_servers(name); if (nservers < 1) { errmsg("No nameservers for %s found", name); return(FALSE); } /* * Make sure we have an address for at least one nameserver. */ for (n = 0; n < nservers; n++) if (naddrs[n] > 0) break; if (n >= nservers) { errmsg("No addresses of nameservers for %s found", name); return(FALSE); } /* * Without an explicit server on the command line, the servers we * have looked up are supposed to be authoritative for the zone. */ authserver = (server && !primary) ? FALSE : TRUE; /* * Check SOA records at each of the nameservers if so requested. */ if (checkmode) { do_check(name); total_check += 1; /* update zones processed */ /* all done if maximum recursion level reached */ if (!recursive || (recursion_level >= recursive)) return((errorcount == 0) ? TRUE : FALSE); } /* * The zone transfer for certain zones can be skipped. * Currently this must be indicated on the command line. */ if (skip_transfer(name)) { if (verbose || statistics || checkmode || hostmode) printf("Skipping zone transfer for %s\n", name); return(FALSE); } /* * Ask zone transfer to the nameservers, until one responds. */ total_tries += 1; /* update zone transfer attempts */ if (!do_transfer(name)) return(FALSE); total_zones += 1; /* update successful zone transfers */ /* * Print resource record statistics if so requested. */ if (statistics) print_statistics(name, querytype, queryclass); /* * Accumulate host count statistics for this zone. * Do this only in modes in which such output would be printed. */ nzones = zonecount; nhosts = 0, ndupls = 0, nextrs = 0, ngates = 0; i = (verbose || statistics || hostmode) ? 0 : hostcount; for (n = i; n < hostcount; n++) { /* skip fake hosts using a very rudimentary test */ if (fakename(hostname(n)) || fakeaddr(hostaddr(n))) continue; #ifdef justfun /* save longest host name encountered so far */ if (verbose && ((i = strlength(hostname(n))) > longsize)) { longsize = i; (void) strcpy(longname, hostname(n)); } #endif /* skip apparent glue records */ if (gluerecord(hostname(n), name, zonename, nzones)) { if (verbose > 1) printf("%s is glue record\n", hostname(n)); continue; } /* otherwise count as host */ nhosts++; /* * Mark hosts not residing directly in the zone as extrazone host. */ if (!samedomain(hostname(n), name, TRUE)) { nextrs++; if (extrmode || (verbose > 1)) printf("%s is extrazone host\n", hostname(n)); } /* * Mark hosts with more than one address as gateway host. * These are not checked for duplicate addresses. */ if (multaddr(n)) { ngates++; if (gatemode || (verbose > 1)) printf("%s is gateway host\n", hostname(n)); } /* * Compare single address hosts against global list of addresses. * Multiple address hosts are too complicated to handle this way. */ else if (check_dupl(hostaddr(n))) { struct in_addr inaddr; inaddr.s_addr = hostaddr(n); ndupls++; if (duplmode || (verbose > 1)) printf("%s is duplicate host with address %s\n", hostname(n), inet_ntoa(inaddr)); } } /* * Print statistics for this zone. */ if (verbose || statistics || hostmode) { printf("Found %d host%s within %s\n", nhosts, plural(nhosts), name); if ((ndupls > 0) || duplmode || (verbose > 1)) printf("Found %d duplicate host%s within %s\n", ndupls, plural(ndupls), name); if ((nextrs > 0) || extrmode || (verbose > 1)) printf("Found %d extrazone host%s within %s\n", nextrs, plural(nextrs), name); if ((ngates > 0) || gatemode || (verbose > 1)) printf("Found %d gateway host%s within %s\n", ngates, plural(ngates), name); } total_hosts += nhosts; /* update total number of hosts */ total_dupls += ndupls; /* update total number of duplicates */ if (!checkmode) total_check += 1; /* update zones processed */ if (verbose || statistics) printf("Found %d delegated zone%s within %s\n", nzones, plural(nzones), name); /* * Sort the encountered delegated zones alphabetically. * Note that this precludes further use of the zone_index() function. */ if ((nzones > 1) && (recursive || listzones || mxdomains)) qsort((ptr_t *)zonename, nzones, sizeof(char *), compare_name); /* * The names of the hosts were allocated dynamically. */ for (n = 0; n < hostcount; n++) xfree(hostname(n)); /* * Check for mailable delegated zones within this zone. * This is based on ordinary MX lookup, and not on the MX info * which may be present in the zone listing, to reduce zone transfers. */ if (mxdomains) { if (recursion_level == 0) { if (verbose) printf("\n"); if (!get_mxrec(name)) ns_error(name, T_MX, queryclass, server); } for (n = 0; n < nzones; n++) { if (verbose) printf("\n"); if (!get_mxrec(zonename[n])) ns_error(zonename[n], T_MX, queryclass, server); } } /* * Do recursion on delegated zones if requested and any were found. * Temporarily save zonename list, and force allocation of new list. */ if (recursive && (recursion_level < recursive)) { for (n = 0; n < nzones; n++) { char **newzone; /* local copy of list */ newzone = zonename; zonename = NULL; /* allocate new list */ if (verbose || statistics || checkmode || hostmode) printf("\n"); if (listzones) { for (i = 0; i <= recursion_level; i++) printf("%s", (i == 0) ? "\t" : " "); printf("%s\n", newzone[n]); } if (verbose) printf("Entering zone %s\n", newzone[n]); recursion_level++; (void) list_zone(newzone[n]); recursion_level--; zonename = newzone; /* restore */ } } else if (listzones) { for (n = 0; n < nzones; n++) { for (i = 0; i <= recursion_level; i++) printf("%s", (i == 0) ? "\t" : " "); printf("%s\n", zonename[n]); } } /* * The names of the delegated zones were allocated dynamically. * The list of delegated zone names was also allocated dynamically. */ for (n = 0; n < nzones; n++) xfree(zonename[n]); if (zonename != NULL) xfree(zonename); zonename = NULL; /* * Print final overall statistics. */ if (recursive && (recursion_level == 0)) { if (verbose || statistics || checkmode || hostmode) printf("\n"); if (verbose || statistics || hostmode) printf("Encountered %d host%s in %d zone%s within %s\n", total_hosts, plural(total_hosts), total_zones, plural(total_zones), name); if (verbose || statistics || hostmode) printf("Encountered %d duplicate host%s in %d zone%s within %s\n", total_dupls, plural(total_dupls), total_zones, plural(total_zones), name); if (verbose || statistics || checkmode) printf("Transferred %d zone%s out of %d attempt%s\n", total_zones, plural(total_zones), total_tries, plural(total_tries)); if (verbose || statistics || checkmode) printf("Processed %d zone%s out of %d request%s\n", total_check, plural(total_check), total_calls, plural(total_calls)); #ifdef justfun if (verbose && (longsize > 0)) printf("Longest hostname %s\t%d\n", longname, longsize); #endif } /* indicate whether any errors were encountered */ return((errorcount == 0) ? TRUE : FALSE); } /* ** FIND_SERVERS -- Fetch names and addresses of authoritative servers ** ------------------------------------------------------------------ ** ** Returns: ** TRUE if servers could be determined successfully. ** FALSE otherwise. ** ** Inputs: ** The global variable ``server'', if set, contains the ** name of the explicit server to be contacted. ** The global variable ``primary'', if set, indicates ** that we must use the primary nameserver for the zone. ** If both are set simultaneously, the explicit server ** is contacted to retrieve the desired servers. ** ** Outputs: ** The count of nameservers is stored in ``nservers''. ** Names are stored in the nsname[] database. ** Addresses are stored in the ipaddr[] database. ** Address counts are stored in the naddrs[] database. */ bool find_servers(name) input char *name; /* name of zone to find servers for */ { struct hostent *hp; register int n, i; /* * Use the explicit server if given on the command line. * Its addresses are stored in the resolver state struct. * This server may not be authoritative for the given zone. */ if (server && !primary) { (void) strcpy(nsname[0], server); for (i = 0; i < MAXIPADDR && i < _res.nscount; i++) ipaddr[0][i] = nslist(i).sin_addr; naddrs[0] = i; nservers = 1; return(TRUE); } /* * Fetch primary nameserver info if so requested. * Get its name from the SOA record for the zone, and do a regular * host lookup to fetch its addresses. We are assuming here that the * SOA record is a proper one. This is not necessarily true. * Obviously this server should be authoritative. */ if (primary && !server) { char *primaryname; primaryname = get_primary(name); if (primaryname == NULL) { ns_error(name, T_SOA, queryclass, server); nservers = 0; return(FALSE); } hp = geth_byname(primaryname); if (hp == NULL) { ns_error(primaryname, T_A, C_IN, server); nservers = 0; return(FALSE); } primaryname = strncpy(nsname[0], hp->h_name, MAXDNAME); primaryname[MAXDNAME] = '\0'; for (i = 0; i < MAXIPADDR && hp->h_addr_list[i]; i++) ipaddr[0][i] = incopy(hp->h_addr_list[i]); naddrs[0] = i; if (verbose) printf("Found %d address%s for %s\n", naddrs[0], plurale(naddrs[0]), nsname[0]); nservers = 1; return(TRUE); } /* * Otherwise we have to find the nameservers for the zone. * These are supposed to be authoritative, but sometimes we * encounter lame delegations, perhaps due to misconfiguration. */ if (!get_servers(name)) { ns_error(name, T_NS, queryclass, server); nservers = 0; return(FALSE); } /* * Usually we'll get addresses for all the servers in the additional * info section. But in case we don't, look up their addresses. * Addresses could be missing because there is no room in the answer. * No address is present if the name of a server is not canonical. * If we get no addresses by extra query, and this is authoritative, * we flag a lame delegation to that server. */ for (n = 0; n < nservers; n++) { if (naddrs[n] == 0) { hp = geth_byname(nsname[n]); if (hp != NULL) { for (i = 0; i < MAXIPADDR && hp->h_addr_list[i]; i++) ipaddr[n][i] = incopy(hp->h_addr_list[i]); naddrs[n] = i; } if (verbose) printf("Found %d address%s for %s by extra query\n", naddrs[n], plurale(naddrs[n]), nsname[n]); if (hp == NULL) { /* server name lookup failed */ ns_error(nsname[n], T_A, C_IN, server); /* authoritative denial: probably misconfiguration */ if (h_errno == NO_DATA || h_errno == HOST_NOT_FOUND) { if (server == NULL) errmsg("%s has lame delegation to %s", name, nsname[n]); } } if ((hp != NULL) && !sameword(hp->h_name, nsname[n])) pr_warning("%s nameserver %s is not canonical (%s)", name, nsname[n], hp->h_name); } else { if (verbose) printf("Found %d address%s for %s\n", naddrs[n], plurale(naddrs[n]), nsname[n]); } } /* * Issue warning if only one server has been discovered. * This is not an error per se, but not much redundancy in that case. */ if (nservers == 1) pr_warning("%s has only one nameserver %s", name, nsname[0]); return((nservers > 0) ? TRUE : FALSE); } /* ** GET_SERVERS -- Fetch names and addresses of authoritative servers ** ----------------------------------------------------------------- ** ** Returns: ** TRUE if servers could be determined successfully. ** FALSE otherwise. ** ** Side effects: ** The count of nameservers is stored in ``nservers''. ** Names are stored in the nsname[] database. ** Addresses are stored in the ipaddr[] database. ** Address counts are stored in the naddrs[] database. */ bool get_servers(name) input char *name; /* name of zone to find servers for */ { querybuf answer; register int n; bool result; /* result status of action taken */ if (verbose) printf("Finding nameservers for %s ...\n", name); n = get_info(&answer, name, T_NS, queryclass); if (n < 0) return(FALSE); if (verbose > 1) (void) print_info(&answer, n, name, T_NS, queryclass, FALSE); result = get_nsinfo(&answer, n, name); return(result); } /* ** GET_NSINFO -- Extract nameserver data from nameserver answer buffer ** ------------------------------------------------------------------- ** ** Returns: ** TRUE if the answer buffer was processed successfully. ** FALSE otherwise. ** ** Outputs: ** The count of nameservers is stored in ``nservers''. ** Names are stored in the nsname[] database. ** Addresses are stored in the ipaddr[] database. ** Address counts are stored in the naddrs[] database. */ bool get_nsinfo(answerbuf, answerlen, name) input querybuf *answerbuf; /* location of answer buffer */ input int answerlen; /* length of answer buffer */ input char *name; /* name of zone to find servers for */ { HEADER *bp; int qdcount, ancount, nscount, arcount, rrcount; u_char *msg, *eom; register u_char *cp; register int i; nservers = 0; /* count of nameservers */ bp = (HEADER *)answerbuf; qdcount = ntohs(bp->qdcount); ancount = ntohs(bp->ancount); nscount = ntohs(bp->nscount); arcount = ntohs(bp->arcount); msg = (u_char *)answerbuf; eom = (u_char *)answerbuf + answerlen; cp = (u_char *)answerbuf + HFIXEDSZ; if (qdcount > 0 && cp < eom) /* should be exactly one record */ { cp = skip_qrec(name, T_NS, queryclass, cp, msg, eom); if (cp == NULL) return(FALSE); qdcount--; } if (qdcount) { pr_error("invalid qdcount after %s query for %s", pr_type(T_NS), name); h_errno = NO_RECOVERY; return(FALSE); } /* * If the answer is authoritative, the names are found in the * answer section, and the nameserver section is empty. * If not, there may be duplicate names in both sections. * Addresses are found in the additional info section both cases. */ rrcount = ancount + nscount + arcount; while (rrcount > 0 && cp < eom) { char rname[MAXDNAME+1]; char dname[MAXDNAME+1]; int type, class, ttl, dlen; u_char *eor; register int n; struct in_addr inaddr; n = expand_name(name, T_NONE, cp, msg, eom, rname); if (n < 0) return(FALSE); cp += n; n = 3*INT16SZ + INT32SZ; if (check_size(rname, T_NONE, cp, msg, eom, n) < 0) return(FALSE); type = _getshort(cp); cp += INT16SZ; class = _getshort(cp); cp += INT16SZ; ttl = _getlong(cp); cp += INT32SZ; dlen = _getshort(cp); cp += INT16SZ; eor = cp + dlen; #ifdef lint if (verbose) printf("%-20s\t%d\t%s\t%s\n", rname, ttl, pr_class(class), pr_type(type)); #endif if ((type == T_NS) && sameword(rname, name)) { n = expand_name(rname, type, cp, msg, eom, dname); if (n < 0) return(FALSE); cp += n; for (i = 0; i < nservers; i++) if (sameword(nsname[i], dname)) break; /* duplicate */ if (i >= nservers && nservers < MAXNSNAME) { (void) strcpy(nsname[nservers], dname); naddrs[nservers] = 0; nservers++; } } else if ((type == T_A) && (dlen == INADDRSZ)) { for (i = 0; i < nservers; i++) if (sameword(nsname[i], rname)) break; /* found */ if (i < nservers && naddrs[i] < MAXIPADDR) { bcopy((char *)cp, (char *)&inaddr, INADDRSZ); ipaddr[i][naddrs[i]] = inaddr; naddrs[i]++; } cp += dlen; } else { /* just ignore other records */ cp += dlen; } if (cp != eor) { pr_error("size error in %s record for %s, off by %s", pr_type(type), rname, itoa(cp - eor)); h_errno = NO_RECOVERY; return(FALSE); } rrcount--; } if (rrcount) { pr_error("invalid rrcount after %s query for %s", pr_type(T_NS), name); h_errno = NO_RECOVERY; return(FALSE); } /* set proper status if no answers found */ h_errno = (nservers > 0) ? 0 : TRY_AGAIN; return(TRUE); } /* ** SORT_SERVERS -- Sort set of nameservers according to preference ** --------------------------------------------------------------- ** ** Returns: ** None. ** ** Inputs: ** Set of nameservers as determined by find_servers(). ** The global variable ``prefserver'', if set, contains ** a list of preferred server domains to compare against. ** ** Outputs: ** Stores the preferred nameserver order in nsrank[]. */ void sort_servers() { register int i, j; register int n, pref; register char *p, *q; /* * Initialize the default ranking. */ for (n = 0; n < nservers; n++) { nsrank[n] = n; nspref[n] = 0; } /* * Determine the nameserver preference. * Compare against a list of comma-separated preferred server domains. * Use the maximum value of all comparisons. */ for (q = NULL, p = prefserver; p != NULL; p = q) { q = index(p, ','); if (q != NULL) *q = '\0'; for (n = 0; n < nservers; n++) { pref = matchlabels(nsname[n], p); if (pref > nspref[n]) nspref[n] = pref; } if (q != NULL) *q++ = ','; } /* * Sort the set according to preference. * Keep the rest as much as possible in original order. */ for (i = 0; i < nservers; i++) { for (j = i + 1; j < nservers; j++) { if (nspref[j] > nspref[i]) { pref = nspref[j]; /* nspref[j] = nspref[i]; */ for (n = j; n > i; n--) nspref[n] = nspref[n-1]; nspref[i] = pref; pref = nsrank[j]; /* nsrank[j] = nsrank[i]; */ for (n = j; n > i; n--) nsrank[n] = nsrank[n-1]; nsrank[i] = pref; } } } } /* ** SKIP_TRANSFER -- Check whether a zone transfer should be skipped ** ---------------------------------------------------------------- ** ** Returns: ** TRUE if a transfer for this zone should be skipped. ** FALSE if the zone transfer should proceed. ** ** Inputs: ** The global variable ``skipzone'', if set, contains ** a list of zone names to be skipped. ** ** Certain zones are known to contain bogus information, and ** can be requested to be excluded from further processing. ** The zone transfer for such zones and its delegated zones ** will be skipped. */ bool skip_transfer(name) input char *name; /* name of zone to process */ { register char *p, *q; bool skip = FALSE; for (q = NULL, p = skipzone; p != NULL; p = q) { q = index(p, ','); if (q != NULL) *q = '\0'; if (sameword(name, p)) skip = TRUE; if (q != NULL) *q++ = ','; } return(skip); } /* ** DO_CHECK -- Check SOA records at each of the nameservers ** -------------------------------------------------------- ** ** Returns: ** None. ** ** Inputs: ** The count of nameservers is stored in ``nservers''. ** Names are stored in the nsname[] database. ** Addresses are stored in the ipaddr[] database. ** Address counts are stored in the naddrs[] database. ** ** The SOA record of the zone is checked at each nameserver. ** Nameserver recursion is turned off to make sure that the ** answer is authoritative. */ void do_check(name) input char *name; /* name of zone to process */ { res_state_t save_res; /* saved copy of resolver database */ char *save_server; /* saved copy of server name */ register int n; register int i; /* save resolver database */ save_res = _res; save_server = server; /* turn off nameserver recursion */ _res.options &= ~RES_RECURSE; for (n = 0; n < nservers; n++) { if (naddrs[n] < 1) continue; /* shortcut */ server = nsname[n]; for (i = 0; i < MAXNS && i < naddrs[n]; i++) { nslist(i).sin_family = AF_INET; nslist(i).sin_port = htons(NAMESERVER_PORT); nslist(i).sin_addr = ipaddr[n][i]; } _res.nscount = i; /* retrieve and check SOA */ if (check_zone(name)) continue; /* SOA query failed */ ns_error(name, T_SOA, queryclass, server); /* explicit server failure: possibly data expired */ lameserver = (h_errno == SERVER_FAILURE) ? TRUE : FALSE; /* non-authoritative denial: assume lame delegation */ if (h_errno == NO_RREC || h_errno == NO_HOST) lameserver = TRUE; /* authoritative denial: probably misconfiguration */ if (h_errno == NO_DATA || h_errno == HOST_NOT_FOUND) lameserver = TRUE; /* flag an error if server should not have failed */ if (lameserver && authserver) errmsg("%s has lame delegation to %s", name, server); } /* restore resolver database */ _res = save_res; server = save_server; } /* ** DO_TRANSFER -- Perform a zone transfer from any of its nameservers ** ------------------------------------------------------------------ ** ** Returns: ** TRUE if the zone data have been retrieved successfully. ** FALSE if none of the servers responded. ** ** Inputs: ** The count of nameservers is stored in ``nservers''. ** Names are stored in the nsname[] database. ** Addresses are stored in the ipaddr[] database. ** Address counts are stored in the naddrs[] database. ** ** Ask zone transfer to the nameservers, until one responds. ** The list of nameservers is sorted according to preference. ** An authoritative server should always respond positively. ** If it responds with an error, we may have a lame delegation. ** Always retry with the next server to avoid missing entire zones. */ bool do_transfer(name) input char *name; /* name of zone to do zone xfer for */ { register int n, ns; register int i; for (sort_servers(), ns = 0; ns < nservers; ns++) { for (n = nsrank[ns], i = 0; i < naddrs[n]; i++) { if (verbose) printf("Trying server %s (%s) ...\n", inet_ntoa(ipaddr[n][i]), nsname[n]); if (transfer_zone(name, ipaddr[n][i], nsname[n])) goto done; /* double break */ /* zone transfer failed */ if ((h_errno != TRY_AGAIN) || verbose) ns_error(name, T_AXFR, queryclass, nsname[n]); /* zone transfer request was explicitly refused */ if (h_errno == QUERY_REFUSED) break; /* explicit server failure: possibly data expired */ lameserver = (h_errno == SERVER_FAILURE) ? TRUE : FALSE; /* non-authoritative denial: assume lame delegation */ if (h_errno == NO_RREC || h_errno == NO_HOST) lameserver = TRUE; /* authoritative denial: probably misconfiguration */ if (h_errno == NO_DATA || h_errno == HOST_NOT_FOUND) lameserver = TRUE; /* flag an error if server should not have failed */ if (lameserver && authserver) errmsg("%s has lame delegation to %s", name, nsname[n]); /* try next server if this one is sick */ if (lameserver) break; /* terminate on irrecoverable errors */ if (h_errno != TRY_AGAIN) return(FALSE); /* in case nameserver not present */ if (errno == ECONNREFUSED) break; } } done: if (ns >= nservers) { if ((h_errno == TRY_AGAIN) && !verbose) ns_error(name, T_AXFR, queryclass, (char *)NULL); errmsg("No nameservers for %s responded", name); return(FALSE); } return(TRUE); } /* ** TRANSFER_ZONE -- Wrapper for get_zone() to hide administrative tasks ** -------------------------------------------------------------------- ** ** Returns: ** See get_zone() for details. ** ** Side effects: ** See get_zone() for details. ** ** This routine may be called repeatedly with different server ** addresses, until one of the servers responds. Various items ** must be reset on every try to continue with a clean slate. */ bool transfer_zone(name, inaddr, host) input char *name; /* name of zone to do zone xfer for */ input struct in_addr inaddr; /* address of server to be queried */ input char *host; /* name of server to be queried */ { register int n; /* * Reset the resource record statistics before each try. */ clear_statistics(); /* * Reset the hash tables of saved resource record information. * These tables are used only during the zone transfer itself. */ clear_ttltab(); clear_hosttab(); clear_zonetab(); /* * Perform the actual zone transfer. * All error reporting is done by get_zone(). */ if (get_zone(name, inaddr, host)) return(TRUE); /* * Failure to get the zone. Free any memory that may have been allocated. * On success it is the responsibility of the caller to free the memory. * The information gathered is used by list_zone() after the zone transfer. */ for (n = 0; n < hostcount; n++) xfree(hostname(n)); for (n = 0; n < zonecount; n++) xfree(zonename[n]); if (zonename != NULL) xfree(zonename); zonename = NULL; return(FALSE); } /* ** GET_ZONE -- Perform a zone transfer from server at specific address ** ------------------------------------------------------------------- ** ** Returns: ** TRUE if the zone data have been retrieved successfully. ** FALSE if an error occurred (h_errno is set appropriately). ** Set TRY_AGAIN wherever possible to try the next server. ** ** Side effects: ** Stores list of delegated zones found in zonename[], ** and the count of delegated zones in ``zonecount''. ** Stores list of host names found in hostname[], ** and the count of host names in ``hostcount''. ** Updates resource record statistics in record_stats[]. ** This array must have been cleared before. */ bool get_zone(name, inaddr, host) input char *name; /* name of zone to do zone xfer for */ input struct in_addr inaddr; /* address of server to be queried */ input char *host; /* name of server to be queried */ { querybuf query; querybuf answer; HEADER *bp; int ancount; int sock; struct sockaddr_in sin; register int n, i; int nrecords = 0; /* number of records processed */ int npackets = 0; /* number of packets received */ /* clear global counts */ soacount = 0; /* count of SOA records */ zonecount = 0; /* count of delegated zones */ hostcount = 0; /* count of host names */ /* * Construct query, and connect to the given server. */ errno = 0; /* reset before querying nameserver */ n = res_mkquery(QUERY, name, queryclass, T_AXFR, (qbuf_t *)NULL, 0, (rrec_t *)NULL, (qbuf_t *)&query, sizeof(querybuf)); if (n < 0) { if (debug) printf("%sres_mkquery failed\n", dbprefix); h_errno = NO_RECOVERY; return(FALSE); } if (debug) { printf("%sget_zone()\n", dbprefix); pr_query((qbuf_t *)&query, n, stdout); } /* setup destination address */ bzero((char *)&sin, sizeof(sin)); sin.sin_family = AF_INET; sin.sin_port = htons(NAMESERVER_PORT); sin.sin_addr = inaddr; sock = socket(AF_INET, SOCK_STREAM, 0); if (sock < 0) { _res_perror(&sin, host, "socket"); h_errno = TRY_AGAIN; return(FALSE); } if (_res_connect(sock, &sin, sizeof(sin)) < 0) { if (verbose || debug) _res_perror(&sin, host, "connect"); (void) close(sock); h_errno = TRY_AGAIN; return(FALSE); } if (verbose) printf("Asking zone transfer for %s ...\n", name); /* * Send the query buffer. */ if (_res_write(sock, &sin, host, (char *)&query, n) < 0) { (void) close(sock); h_errno = TRY_AGAIN; return(FALSE); } /* * Process all incoming packets, usually one record in a separate packet. */ while ((n = _res_read(sock, &sin, host, (char *)&answer, sizeof(querybuf))) != 0) { if (n < 0) { (void) close(sock); h_errno = TRY_AGAIN; return(FALSE); } errno = 0; /* reset after we got an answer */ if (n < HFIXEDSZ) { pr_error("answer length %s too short during %s for %s from %s", itoa(n), pr_type(T_AXFR), name, host); (void) close(sock); h_errno = TRY_AGAIN; return(FALSE); } if (debug > 1) { printf("%sgot answer, %d bytes:\n", dbprefix, n); pr_query((qbuf_t *)&answer, querysize(n), stdout); } /* * Analyze the contents of the answer and check for errors. * An error can be expected only in the very first packet. * The query section should be empty except in the first packet. * Note the special error status codes for specific failures. */ bp = (HEADER *)&answer; ancount = ntohs(bp->ancount); if (bp->rcode != NOERROR || ancount == 0) { if (verbose || debug) print_status(&answer, n); switch (bp->rcode) { case NXDOMAIN: /* distinguish between authoritative or not */ h_errno = bp->aa ? HOST_NOT_FOUND : NO_HOST; break; case NOERROR: /* distinguish between authoritative or not */ h_errno = bp->aa ? NO_DATA : NO_RREC; break; case REFUSED: /* special status if zone transfer refused */ h_errno = QUERY_REFUSED; break; case SERVFAIL: /* special status upon explicit failure */ h_errno = SERVER_FAILURE; break; default: /* all other errors will cause a retry */ h_errno = TRY_AGAIN; break; } if (npackets != 0) pr_error("unexpected error during %s for %s from %s", pr_type(T_AXFR), name, host); (void) close(sock); return(FALSE); } /* valid answer received, avoid buffer overrun */ h_errno = 0; n = querysize(n); /* * The nameserver and additional info section should be empty. * There may be multiple answers in the answer section. */ #ifdef obsolete if (ancount > 1) pr_error("multiple answers during %s for %s from %s", pr_type(T_AXFR), name, host); #endif if (ntohs(bp->nscount) != 0) pr_error("nonzero nscount during %s for %s from %s", pr_type(T_AXFR), name, host); if (ntohs(bp->arcount) != 0) pr_error("nonzero arcount during %s for %s from %s", pr_type(T_AXFR), name, host); /* * Valid packet received. Print contents if appropriate. * Specific zone information will be saved by update_zone(). */ npackets += 1; nrecords += ancount; soaname = NULL, subname = NULL, adrname = NULL, address = 0; listhost = host; (void) print_info(&answer, n, name, T_AXFR, queryclass, FALSE); /* * Terminate upon the second SOA record for this zone. */ if (soacount > 1) break; } /* * End of zone transfer at second SOA record or zero length read. */ (void) close(sock); /* * Check for the anomaly that the whole transfer consisted of the * SOA records only. Could occur if we queried the victim of a lame * delegation which happened to have the SOA record present. */ if (nrecords <= soacount) { pr_error("empty zone transfer for %s from %s", name, host); h_errno = NO_RREC; return(FALSE); } /* * Do an extra check for delegated zones that also have an A record. * Those may have been defined in the child zone, and crept in the * parent zone, or may have been defined as glue records. * This is not necessarily an error, but the host count may be wrong. * Note that an A record for the current zone has been ignored above. */ for (n = 0; n < zonecount; n++) { i = host_index(zonename[n], FALSE); #ifdef obsolete for (i = 0; i < hostcount; i++) if (sameword(hostname(i), zonename[n])) break; /* found */ #endif if (i < hostcount) pr_warning("%s has both NS and A records within %s from %s", zonename[n], name, host); } /* * The zone transfer has been successful. */ if (verbose) { printf("Transfer complete, %d record%s received for %s\n", nrecords, plural(nrecords), name); if (npackets != nrecords) printf("Transfer consisted of %d packet%s from %s\n", npackets, plural(npackets), host); } return(TRUE); } /* ** UPDATE_ZONE -- Save zone information during zone listings ** --------------------------------------------------------- ** ** Returns: ** None. ** ** Side effects: ** Stores list of delegated zones found in zonename[], ** and the count of delegated zones in ``zonecount''. ** Stores list of host names found in hostname[], ** and the count of host names in ``hostcount''. ** Stores the count of SOA records in ``soacount''. ** ** This routine is called by print_info() for each resource record. */ void update_zone(name) input char *name; /* name of zone to do zone xfer for */ { char *host = listhost; /* contacted host for zone listings */ register int i; /* * Terminate upon the second SOA record for this zone. */ if (soaname && sameword(soaname, name)) soacount++; /* the nameserver balks on this one */ else if (soaname && !sameword(soaname, name)) pr_warning("extraneous SOA record for %s within %s from %s", soaname, name, host); /* * Save encountered delegated zone name for recursive listing. */ if (subname && indomain(subname, name, FALSE)) { i = zone_index(subname, TRUE); #ifdef obsolete for (i = 0; i < zonecount; i++) if (sameword(zonename[i], subname)) break; /* duplicate */ #endif if (i >= zonecount) { zonename = newlist(zonename, zonecount+1, char *); zonename[zonecount] = newstr(subname); zonecount++; } } /* warn about strange delegated zones */ else if (subname && !indomain(subname, name, TRUE)) pr_warning("extraneous NS record for %s within %s from %s", subname, name, host); /* * Save encountered name of A record for host name count. */ if (adrname && indomain(adrname, name, FALSE) && !reverse) { i = host_index(adrname, TRUE); #ifdef obsolete for (i = 0; i < hostcount; i++) if (sameword(hostname(i), adrname)) break; /* duplicate */ #endif if (i >= hostcount) { if (hostcount >= maxhosts) { maxhosts += MAXHOSTINCR; hostlist = newlist(hostlist, maxhosts, host_data_t); } hostname(hostcount) = newstr(adrname); hostaddr(hostcount) = address; multaddr(hostcount) = FALSE; hostcount++; } else if (address != hostaddr(i)) multaddr(i) = TRUE; } /* check for unauthoritative glue records */ else if (adrname && !indomain(adrname, name, TRUE)) pr_warning("extraneous glue record for %s within %s from %s", adrname, name, host); } /* ** GET_MXREC -- Fetch MX records of a domain ** ----------------------------------------- ** ** Returns: ** TRUE if MX records were found. ** FALSE otherwise. */ bool get_mxrec(name) input char *name; /* domain name to get mx for */ { querybuf answer; register int n; if (verbose) printf("Finding MX records for %s ...\n", name); n = get_info(&answer, name, T_MX, queryclass); if (n < 0) return(FALSE); (void) print_info(&answer, n, name, T_MX, queryclass, FALSE); return(TRUE); } /* ** GET_PRIMARY -- Fetch name of primary nameserver for a zone ** ---------------------------------------------------------- ** ** Returns: ** Pointer to the name of the primary server, if found. ** NULL if the server could not be determined. */ char * get_primary(name) input char *name; /* name of zone to get soa for */ { querybuf answer; register int n; if (verbose) printf("Finding primary nameserver for %s ...\n", name); n = get_info(&answer, name, T_SOA, queryclass); if (n < 0) return(NULL); if (verbose > 1) (void) print_info(&answer, n, name, T_SOA, queryclass, FALSE); soaname = NULL; (void) get_soainfo(&answer, n, name); if (soaname == NULL) return(NULL); return(soa.primary); } /* ** CHECK_ZONE -- Fetch and analyze SOA record of a zone ** ---------------------------------------------------- ** ** Returns: ** TRUE if the SOA record was found at the given server. ** FALSE otherwise. ** ** Inputs: ** The global variable ``server'' must contain the name ** of the server that was queried. */ bool check_zone(name) input char *name; /* name of zone to get soa for */ { querybuf answer; register int n; if (verbose) printf("Checking SOA for %s at server %s ...\n", name, server); else if (authserver) printf("%-20s\tNS\t%s\n", name, server); else printf("%s\t(%s)\n", name, server); n = get_info(&answer, name, T_SOA, queryclass); if (n < 0) return(FALSE); if (verbose > 1) (void) print_info(&answer, n, name, T_SOA, queryclass, FALSE); soaname = NULL; (void) get_soainfo(&answer, n, name); if (soaname == NULL) return(FALSE); check_soa(&answer, name); return(TRUE); } /* ** GET_SOAINFO -- Extract SOA data from nameserver answer buffer ** ------------------------------------------------------------- ** ** Returns: ** TRUE if the answer buffer was processed successfully. ** FALSE otherwise. ** ** Outputs: ** The global struct ``soa'' is filled with the soa data. ** ** Side effects: ** Sets ``soaname'' if there is a valid SOA record. ** This variable must have been cleared before calling ** get_soainfo() and may be checked afterwards. */ bool get_soainfo(answerbuf, answerlen, name) input querybuf *answerbuf; /* location of answer buffer */ input int answerlen; /* length of answer buffer */ input char *name; /* name of zone to get soa for */ { HEADER *bp; int qdcount, ancount; u_char *msg, *eom; register u_char *cp; bp = (HEADER *)answerbuf; qdcount = ntohs(bp->qdcount); ancount = ntohs(bp->ancount); msg = (u_char *)answerbuf; eom = (u_char *)answerbuf + answerlen; cp = (u_char *)answerbuf + HFIXEDSZ; if (qdcount > 0 && cp < eom) /* should be exactly one record */ { cp = skip_qrec(name, T_SOA, queryclass, cp, msg, eom); if (cp == NULL) return(FALSE); qdcount--; } if (qdcount) { pr_error("invalid qdcount after %s query for %s", pr_type(T_SOA), name); h_errno = NO_RECOVERY; return(FALSE); } /* * Check answer section only. * Check that answers match the requested zone. Ignore other entries. * The nameserver section may contain the nameservers for the zone, * and the additional section their addresses, but not guaranteed. * Those sections are usually empty for authoritative answers. */ while (ancount > 0 && cp < eom) { char rname[MAXDNAME+1]; int type, class, ttl, dlen; u_char *eor; register int n; n = expand_name(name, T_NONE, cp, msg, eom, rname); if (n < 0) return(FALSE); cp += n; n = 3*INT16SZ + INT32SZ; if (check_size(rname, T_NONE, cp, msg, eom, n) < 0) return(FALSE); type = _getshort(cp); cp += INT16SZ; class = _getshort(cp); cp += INT16SZ; ttl = _getlong(cp); cp += INT32SZ; dlen = _getshort(cp); cp += INT16SZ; eor = cp + dlen; #ifdef lint if (verbose) printf("%-20s\t%d\t%s\t%s\n", rname, ttl, pr_class(class), pr_type(type)); #endif if ((type == T_SOA) && sameword(rname, name)) { n = expand_name(rname, type, cp, msg, eom, soa.primary); if (n < 0) return(FALSE); cp += n; n = expand_name(rname, type, cp, msg, eom, soa.hostmaster); if (n < 0) return(FALSE); cp += n; n = 5*INT32SZ; if (check_size(rname, type, cp, msg, eor, n) < 0) return(FALSE); soa.serial = _getlong(cp); cp += INT32SZ; soa.refresh = _getlong(cp); cp += INT32SZ; soa.retry = _getlong(cp); cp += INT32SZ; soa.expire = _getlong(cp); cp += INT32SZ; soa.defttl = _getlong(cp); cp += INT32SZ; /* valid complete soa record found */ soaname = strcpy(soanamebuf, rname); } else { /* just ignore other records */ cp += dlen; } if (cp != eor) { pr_error("size error in %s record for %s, off by %s", pr_type(type), rname, itoa(cp - eor)); h_errno = NO_RECOVERY; return(FALSE); } ancount--; } if (ancount) { pr_error("invalid ancount after %s query for %s", pr_type(T_SOA), name); h_errno = NO_RECOVERY; return(FALSE); } /* set proper status if no answers found */ h_errno = (soaname != NULL) ? 0 : TRY_AGAIN; return(TRUE); } /* ** CHECK_SOA -- Analyze retrieved SOA records of a zone ** ---------------------------------------------------- ** ** Returns: ** None. ** ** Inputs: ** The global variable ``server'' must contain the ** name of the server that was queried. ** The global struct ``soa'' must contain the soa data. */ void check_soa(answerbuf, name) input querybuf *answerbuf; /* location of answer buffer */ input char *name; /* name of zone to check soa for */ { static char oldnamebuf[MAXDNAME+1]; static char *oldname = NULL; /* previous name of zone */ static char *oldserver = NULL; /* previous name of server */ static soa_data_t oldsoa; /* previous soa data */ register int n; HEADER *bp; /* * Print the various SOA fields in abbreviated form. * Values are actually unsigned, but we print them as signed integers, * apart from the serial which really becomes that big sometimes. * In the latter case we print a warning below. */ printf("%s\t%s\t(%u %d %d %d %d)\n", soa.primary, soa.hostmaster, (unsigned)soa.serial, soa.refresh, soa.retry, soa.expire, soa.defttl); /* * We are supposed to have queried an authoritative nameserver, and since * nameserver recursion has been turned off, answer must be authoritative. */ bp = (HEADER *)answerbuf; if (!bp->aa) { if (authserver) pr_error("%s SOA record at %s is not authoritative", name, server); else pr_warning("%s SOA record at %s is not authoritative", name, server); if (authserver) errmsg("%s has lame delegation to %s", name, server); } /* * Check whether we are switching to a new zone. * The old name must have been saved in static storage. */ if ((oldname != NULL) && !sameword(name, oldname)) oldname = NULL; /* * Make few timer consistency checks only for the first one in a series. * Compare the primary field against the list of authoritative servers. * Explicitly check the hostmaster field for illegal characters ('@'). * Yell if the serial has the high bit set (not always intentional). */ if (oldname == NULL) { for (n = 0; n < nservers; n++) if (sameword(soa.primary, nsname[n])) break; /* found */ if ((n >= nservers) && authserver) pr_warning("%s SOA primary %s is not advertised via NS", name, soa.primary); if (!valid_name(soa.primary, FALSE, FALSE, FALSE)) pr_warning("%s SOA primary %s has illegal name", name, soa.primary); if (!valid_name(soa.hostmaster, FALSE, TRUE, FALSE)) pr_warning("%s SOA hostmaster %s has illegal mailbox", name, soa.hostmaster); if (bitset(0x80000000, soa.serial)) pr_warning("%s SOA serial has high bit set", name); if (soa.retry > soa.refresh) pr_warning("%s SOA retry exceeds refresh", name); if (soa.refresh + soa.retry > soa.expire) pr_warning("%s SOA refresh+retry exceeds expire", name); } /* * Compare various fields with those of the previous query, if any. * Different serial numbers may be present if secondaries have not yet * refreshed the data from the primary. Issue only a warning in that case. */ if (oldname != NULL) { if (!sameword(soa.primary, oldsoa.primary)) pr_error("%s and %s have different primary for %s", server, oldserver, name); if (!sameword(soa.hostmaster, oldsoa.hostmaster)) pr_error("%s and %s have different hostmaster for %s", server, oldserver, name); if (soa.serial != oldsoa.serial) pr_warning("%s and %s have different serial for %s", server, oldserver, name); if (soa.refresh != oldsoa.refresh) pr_error("%s and %s have different refresh for %s", server, oldserver, name); if (soa.retry != oldsoa.retry) pr_error("%s and %s have different retry for %s", server, oldserver, name); if (soa.expire != oldsoa.expire) pr_error("%s and %s have different expire for %s", server, oldserver, name); if (soa.defttl != oldsoa.defttl) pr_error("%s and %s have different defttl for %s", server, oldserver, name); } /* * Save the current information. */ oldname = strcpy(oldnamebuf, name); oldserver = server; oldsoa = soa; } /* ** CHECK_DUPL -- Check global address list for duplicates ** ------------------------------------------------------ ** ** Returns: ** TRUE if the given host address already exists. ** FALSE otherwise. ** ** Side effects: ** Adds the host address to the list if not present. ** ** The information in this table is global, and is not cleared. */ #define AHASHSIZE 0x2000 #define AHASHMASK 0x1fff typedef struct addr_tab { ipaddr_t *addrlist; /* global list of addresses */ int addrcount; /* count of global addresses */ } addr_tab_t; addr_tab_t addrtab[AHASHSIZE]; /* hash list of global addresses */ bool check_dupl(addr) input ipaddr_t addr; /* address of host to check */ { register int i; register addr_tab_t *s; s = &addrtab[ntohl(addr) & AHASHMASK]; for (i = 0; i < s->addrcount; i++) if (s->addrlist[i] == addr) return(TRUE); /* duplicate */ s->addrlist = newlist(s->addrlist, s->addrcount+1, ipaddr_t); s->addrlist[s->addrcount] = addr; s->addrcount++; return(FALSE); } /* ** CHECK_TTL -- Check list of records for different ttl values ** ----------------------------------------------------------- ** ** Returns: ** TRUE if the ttl value matches the first record ** already listed with the same name/type/class. ** FALSE only when the first discrepancy is found. ** ** Side effects: ** Adds the record data to the list if not present. */ #define THASHSIZE 2003 typedef struct ttl_tab { struct ttl_tab *next; /* next entry in chain */ char *name; /* name of resource record */ int type; /* resource record type */ int class; /* resource record class */ int ttl; /* time_to_live value */ int count; /* count of different ttl values */ } ttl_tab_t; ttl_tab_t *ttltab[THASHSIZE]; /* hash list of record info */ bool check_ttl(name, type, class, ttl) input char *name; /* resource record name */ input int type, class, ttl; /* resource record fixed values */ { register ttl_tab_t *s; register ttl_tab_t **ps; register unsigned int hfunc; register char *p; register char c; /* * Compute the hash function for this resource record. * Look it up in the appropriate hash chain. */ for (hfunc = type, p = name; (c = *p) != '\0'; p++) { hfunc = ((hfunc << 1) ^ (lowercase(c) & 0377)) % THASHSIZE; } for (ps = &ttltab[hfunc]; (s = *ps) != NULL; ps = &s->next) { if (s->type != type || s->class != class) continue; if (sameword(s->name, name)) break; } /* * Allocate new entry if not found. */ if (s == NULL) { /* ps = &ttltab[hfunc]; */ s = newstruct(ttl_tab_t); /* initialize new entry */ s->name = newstr(name); s->type = type; s->class = class; s->ttl = ttl; s->count = 0; /* link it in */ s->next = *ps; *ps = s; } /* * Check whether the ttl value matches the first recorded one. * If not, signal only the first discrepancy encountered, so * only one warning message will be printed. */ if (s->ttl == ttl) return(TRUE); s->count += 1; return((s->count == 1) ? FALSE : TRUE); } /* ** CLEAR_TTLTAB -- Clear resource record list for ttl checking ** ----------------------------------------------------------- ** ** Returns: ** None. ** ** An entry on the hash list, and the host name in each ** entry, have been allocated in dynamic memory. ** ** The information in this table is on a per-zone basis. ** It must be cleared before any subsequent zone transfers. */ void clear_ttltab() { register int i; register ttl_tab_t *s, *t; for (i = 0; i < THASHSIZE; i++) { if (ttltab[i] != NULL) { /* free chain of entries */ for (t = NULL, s = ttltab[i]; s != NULL; s = t) { t = s->next; xfree(s->name); xfree(s); } /* reset hash chain */ ttltab[i] = NULL; } } } /* ** HOST_INDEX -- Check list of host names for name being present ** ------------------------------------------------------------- ** ** Returns: ** Index into hostname[] table, if found. ** Current ``hostcount'' value, if not found. ** ** Side effects: ** May add an entry to the hash list if not present. ** ** A linear search through the master table becomes very ** costly for zones with more than a few thousand hosts. ** Maintain a hash list with indexes into the master table. ** Caller should update the master table after this call. */ #define HHASHSIZE 2003 typedef struct host_tab { struct host_tab *next; /* next entry in chain */ int slot; /* slot in host name table */ } host_tab_t; host_tab_t *hosttab[HHASHSIZE]; /* hash list of host name info */ int host_index(name, enter) input char *name; /* the host name to check */ input bool enter; /* add to table if not found */ { register host_tab_t *s; register host_tab_t **ps; register unsigned int hfunc; register char *p; register char c; /* * Compute the hash function for this host name. * Look it up in the appropriate hash chain. */ for (hfunc = 0, p = name; (c = *p) != '\0'; p++) { hfunc = ((hfunc << 1) ^ (lowercase(c) & 0377)) % HHASHSIZE; } for (ps = &hosttab[hfunc]; (s = *ps) != NULL; ps = &s->next) { if (s->slot >= hostcount) continue; if (sameword(hostname(s->slot), name)) break; } /* * Allocate new entry if not found. */ if ((s == NULL) && enter) { /* ps = &hosttab[hfunc]; */ s = newstruct(host_tab_t); /* initialize new entry */ s->slot = hostcount; /* link it in */ s->next = *ps; *ps = s; } return((s != NULL) ? s->slot : hostcount); } /* ** CLEAR_HOSTTAB -- Clear hash list for host name checking ** ------------------------------------------------------- ** ** Returns: ** None. ** ** A hash list entry has been allocated in dynamic memory. ** ** The information in this table is on a per-zone basis. ** It must be cleared before any subsequent zone transfers. */ void clear_hosttab() { register int i; register host_tab_t *s, *t; for (i = 0; i < HHASHSIZE; i++) { if (hosttab[i] != NULL) { /* free chain of entries */ for (t = NULL, s = hosttab[i]; s != NULL; s = t) { t = s->next; xfree(s); } /* reset hash chain */ hosttab[i] = NULL; } } } /* ** ZONE_INDEX -- Check list of zone names for name being present ** ------------------------------------------------------------- ** ** Returns: ** Index into zonename[] table, if found. ** Current ``zonecount'' value, if not found. ** ** Side effects: ** May add an entry to the hash list if not present. ** ** A linear search through the master table becomes very ** costly for more than a few thousand delegated zones. ** Maintain a hash list with indexes into the master table. ** Caller should update the master table after this call. */ #define ZHASHSIZE 2003 typedef struct zone_tab { struct zone_tab *next; /* next entry in chain */ int slot; /* slot in zone name table */ } zone_tab_t; zone_tab_t *zonetab[ZHASHSIZE]; /* hash list of zone name info */ int zone_index(name, enter) input char *name; /* the zone name to check */ input bool enter; /* add to table if not found */ { register zone_tab_t *s; register zone_tab_t **ps; register unsigned int hfunc; register char *p; register char c; /* * Compute the hash function for this zone name. * Look it up in the appropriate hash chain. */ for (hfunc = 0, p = name; (c = *p) != '\0'; p++) { hfunc = ((hfunc << 1) ^ (lowercase(c) & 0377)) % ZHASHSIZE; } for (ps = &zonetab[hfunc]; (s = *ps) != NULL; ps = &s->next) { if (s->slot >= zonecount) continue; if (sameword(zonename[s->slot], name)) break; } /* * Allocate new entry if not found. */ if ((s == NULL) && enter) { /* ps = &zonetab[hfunc]; */ s = newstruct(zone_tab_t); /* initialize new entry */ s->slot = zonecount; /* link it in */ s->next = *ps; *ps = s; } return((s != NULL) ? s->slot : zonecount); } /* ** CLEAR_ZONETAB -- Clear hash list for zone name checking ** ------------------------------------------------------- ** ** Returns: ** None. ** ** A hash list entry has been allocated in dynamic memory. ** ** The information in this table is on a per-zone basis. ** It must be cleared before any subsequent zone transfers. */ void clear_zonetab() { register int i; register zone_tab_t *s, *t; for (i = 0; i < ZHASHSIZE; i++) { if (zonetab[i] != NULL) { /* free chain of entries */ for (t = NULL, s = zonetab[i]; s != NULL; s = t) { t = s->next; xfree(s); } /* reset hash chain */ zonetab[i] = NULL; } } } /* ** CHECK_CANON -- Check list of domain names for name being canonical ** ------------------------------------------------------------------ ** ** Returns: ** Nonzero if the name is definitely not canonical. ** 0 if it is canonical, or if it remains undecided. ** ** Side effects: ** Adds the domain name to the list if not present. ** ** The information in this table is global, and is not cleared ** (which may be necessary if the checking algorithm changes). */ #define CHASHSIZE 2003 typedef struct canon_tab { struct canon_tab *next; /* next entry in chain */ char *name; /* domain name */ int status; /* nonzero if not canonical */ } canon_tab_t; canon_tab_t *canontab[CHASHSIZE]; /* hash list of domain name info */ int check_canon(name) input char *name; /* the domain name to check */ { register canon_tab_t *s; register canon_tab_t **ps; register unsigned int hfunc; register char *p; register char c; /* * Compute the hash function for this domain name. * Look it up in the appropriate hash chain. */ for (hfunc = 0, p = name; (c = *p) != '\0'; p++) { hfunc = ((hfunc << 1) ^ (lowercase(c) & 0377)) % CHASHSIZE; } for (ps = &canontab[hfunc]; (s = *ps) != NULL; ps = &s->next) { if (sameword(s->name, name)) break; } /* * Allocate new entry if not found. * Only then is the actual check carried out. */ if (s == NULL) { /* ps = &canontab[hfunc]; */ s = newstruct(canon_tab_t); /* initialize new entry */ s->name = newstr(name); s->status = canonical(name); /* link it in */ s->next = *ps; *ps = s; } return(s->status); } /* ** CHECK_ADDR -- Check whether reverse address mappings revert to host ** ------------------------------------------------------------------- ** ** Returns: ** TRUE if all addresses of host map back to host. ** FALSE otherwise. */ bool check_addr(name) input char *name; /* host name to check addresses for */ { struct hostent *hp; register int i; struct in_addr inaddr[MAXADDRS]; int naddress; char hnamebuf[MAXDNAME+1]; char *hname; char inamebuf[MAXDNAME+1]; char *iname; int matched; /* * Look up the specified host to fetch its addresses. */ hp = gethostbyname(name); if (hp == NULL) { ns_error(name, T_A, C_IN, server); return(FALSE); } hname = strncpy(hnamebuf, hp->h_name, MAXDNAME); hname[MAXDNAME] = '\0'; for (i = 0; i < MAXADDRS && hp->h_addr_list[i]; i++) inaddr[i] = incopy(hp->h_addr_list[i]); naddress = i; if (verbose) printf("Found %d address%s for %s\n", naddress, plurale(naddress), hname); /* * Map back the addresses found, and check whether they revert to host. */ for (matched = 0, i = 0; i < naddress; i++) { iname = strcpy(inamebuf, inet_ntoa(inaddr[i])); if (verbose) printf("Checking %s address %s\n", hname, iname); hp = gethostbyaddr((char *)&inaddr[i], INADDRSZ, AF_INET); if (hp == NULL) ns_error(iname, T_PTR, C_IN, server); else if (!sameword(hp->h_name, hname)) pr_warning("%s address %s maps to %s", hname, iname, hp->h_name); else matched++; } return((matched == naddress) ? TRUE : FALSE); } /* ** CHECK_NAME -- Check whether address belongs to host addresses ** ------------------------------------------------------------- ** ** Returns: ** TRUE if given address was found among host addresses. ** FALSE otherwise. */ bool check_name(addr) input ipaddr_t addr; /* address of host to check */ { struct hostent *hp; register int i; struct in_addr inaddr; char hnamebuf[MAXDNAME+1]; char *hname; char inamebuf[MAXDNAME+1]; char *iname; int matched; /* * Check whether the address is registered by fetching its host name. */ inaddr.s_addr = addr; iname = strcpy(inamebuf, inet_ntoa(inaddr)); hp = gethostbyaddr((char *)&inaddr, INADDRSZ, AF_INET); if (hp == NULL) { ns_error(iname, T_PTR, C_IN, server); return(FALSE); } hname = strncpy(hnamebuf, hp->h_name, MAXDNAME); hname[MAXDNAME] = '\0'; if (verbose) printf("Address %s maps to %s\n", iname, hname); /* * Lookup the host name found to fetch its addresses. */ hp = gethostbyname(hname); if (hp == NULL) { ns_error(hname, T_A, C_IN, server); return(FALSE); } /* * Verify whether the mapped host name is canonical. */ if (!sameword(hp->h_name, hname)) pr_warning("%s host %s is not canonical (%s)", iname, hname, hp->h_name); /* * Check whether the given address is listed among the known addresses. */ for (matched = 0, i = 0; hp->h_addr_list[i]; i++) { inaddr = incopy(hp->h_addr_list[i]); if (verbose) printf("Checking %s address %s\n", hname, inet_ntoa(inaddr)); if (inaddr.s_addr == addr) matched++; } if (!matched) pr_error("address %s does not belong to %s", iname, hname); return(matched ? TRUE : FALSE); } /* ** GETH_BYNAME -- Wrapper for gethostbyname ** ---------------------------------------- ** ** Returns: ** Pointer to struct hostent if lookup was successful. ** NULL otherwise. ** ** Note. This routine works for fully qualified names only. ** The entire special res_search() processing can be skipped. */ struct hostent * geth_byname(name) input CONST char *name; /* name to do forward lookup for */ { querybuf answer; struct hostent *hp; register int n; hp = gethostbyname(name); if (hp != NULL) return(hp); if (verbose > print_level) printf("Finding addresses for %s ...\n", name); n = get_info(&answer, name, T_A, C_IN); if (n < 0) return(NULL); if ((verbose > print_level + 1) && (print_level < 1)) (void) print_info(&answer, n, name, T_A, C_IN, FALSE); hp = gethostbyname(name); return(hp); } /* ** GETH_BYADDR -- Wrapper for gethostbyaddr ** ---------------------------------------- ** ** Returns: ** Pointer to struct hostent if lookup was successful. ** NULL otherwise. */ struct hostent * geth_byaddr(addr, size, family) input CONST char *addr; /* address to do reverse mapping for */ input int size; /* size of the address */ input int family; /* address family */ { char addrbuf[4*4 + sizeof(ARPA_ROOT) + 1]; char *name = addrbuf; u_char *a = (u_char *)addr; querybuf answer; struct hostent *hp; register int n; if (size != INADDRSZ || family != AF_INET) { hp = gethostbyaddr(addr, size, family); return(hp); } hp = gethostbyaddr(addr, size, family); if (hp != NULL) return(hp); /* construct absolute reverse name *without* trailing dot */ (void) sprintf(addrbuf, "%u.%u.%u.%u.%s", a[3]&0xff, a[2]&0xff, a[1]&0xff, a[0]&0xff, ARPA_ROOT); if (verbose > print_level) printf("Finding reverse mapping for %s ...\n", inet_ntoa(incopy(addr))); n = get_info(&answer, name, T_PTR, C_IN); if (n < 0) return(NULL); if ((verbose > print_level + 1) && (print_level < 1)) (void) print_info(&answer, n, name, T_PTR, C_IN, FALSE); hp = gethostbyaddr(addr, size, family); return(hp); } /* ** PARSE_TYPE -- Decode rr type from input string ** ---------------------------------------------- ** ** Returns: ** Value of resource record type. ** -1 if specified record name is invalid. ** ** Note. Several types are deprecated or obsolete, but recognized. ** T_AXFR/T_IXFR is not allowed to be specified as query type. */ int parse_type(str) input char *str; /* input string with record type */ { register int type; /* standard types */ if (sameword(str, "A")) return(T_A); if (sameword(str, "NS")) return(T_NS); if (sameword(str, "MD")) return(T_MD); /* obsolete */ if (sameword(str, "MF")) return(T_MF); /* obsolete */ if (sameword(str, "CNAME")) return(T_CNAME); if (sameword(str, "SOA")) return(T_SOA); if (sameword(str, "MB")) return(T_MB); /* deprecated */ if (sameword(str, "MG")) return(T_MG); /* deprecated */ if (sameword(str, "MR")) return(T_MR); /* deprecated */ if (sameword(str, "NULL")) return(T_NULL); /* obsolete */ if (sameword(str, "WKS")) return(T_WKS); if (sameword(str, "PTR")) return(T_PTR); if (sameword(str, "HINFO")) return(T_HINFO); if (sameword(str, "MINFO")) return(T_MINFO); /* deprecated */ if (sameword(str, "MX")) return(T_MX); if (sameword(str, "TXT")) return(T_TXT); /* new types */ if (sameword(str, "RP")) return(T_RP); if (sameword(str, "AFSDB")) return(T_AFSDB); if (sameword(str, "X25")) return(T_X25); if (sameword(str, "ISDN")) return(T_ISDN); if (sameword(str, "RT")) return(T_RT); if (sameword(str, "NSAP")) return(T_NSAP); if (sameword(str, "NSAP-PTR")) return(T_NSAPPTR); if (sameword(str, "SIG")) return(T_SIG); if (sameword(str, "KEY")) return(T_KEY); if (sameword(str, "PX")) return(T_PX); if (sameword(str, "GPOS")) return(T_GPOS); /* withdrawn */ if (sameword(str, "AAAA")) return(T_AAAA); if (sameword(str, "LOC")) return(T_LOC); if (sameword(str, "NXT")) return(T_NXT); if (sameword(str, "EID")) return(T_EID); if (sameword(str, "NIMLOC")) return(T_NIMLOC); if (sameword(str, "SRV")) return(T_SRV); if (sameword(str, "ATMA")) return(T_ATMA); if (sameword(str, "NAPTR")) return(T_NAPTR); /* nonstandard types */ if (sameword(str, "UINFO")) return(T_UINFO); if (sameword(str, "UID")) return(T_UID); if (sameword(str, "GID")) return(T_GID); if (sameword(str, "UNSPEC")) return(T_UNSPEC); /* filters */ if (sameword(str, "IXFR")) return(-1); /* illegal */ if (sameword(str, "AXFR")) return(-1); /* illegal */ if (sameword(str, "MAILB")) return(T_MAILB); if (sameword(str, "MAILA")) return(T_MAILA); /* obsolete */ if (sameword(str, "ANY")) return(T_ANY); if (sameword(str, "*")) return(T_ANY); /* unknown types */ type = atoi(str); if (type >= T_FIRST && type <= T_LAST) return(type); return(-1); } /* ** PARSE_CLASS -- Decode rr class from input string ** ------------------------------------------------ ** ** Returns: ** Value of resource class. ** -1 if specified class name is invalid. ** ** Note. C_CSNET is obsolete, but recognized. */ int parse_class(str) input char *str; /* input string with resource class */ { register int class; if (sameword(str, "IN")) return(C_IN); if (sameword(str, "INTERNET")) return(C_IN); if (sameword(str, "CS")) return(C_CSNET); /* obsolete */ if (sameword(str, "CSNET")) return(C_CSNET); /* obsolete */ if (sameword(str, "CH")) return(C_CHAOS); if (sameword(str, "CHAOS")) return(C_CHAOS); if (sameword(str, "HS")) return(C_HS); if (sameword(str, "HESIOD")) return(C_HS); if (sameword(str, "ANY")) return(C_ANY); if (sameword(str, "*")) return(C_ANY); class = atoi(str); if (class > 0) return(class); return(-1); } /* ** IN_ADDR_ARPA -- Convert dotted quad string to reverse in-addr.arpa ** ------------------------------------------------------------------ ** ** Returns: ** Pointer to appropriate reverse in-addr.arpa name ** with trailing dot to force absolute domain name. ** NULL in case of invalid dotted quad input string. */ char * in_addr_arpa(dottedquad) input char *dottedquad; /* input string with dotted quad */ { static char addrbuf[4*4 + sizeof(ARPA_ROOT) + 2]; unsigned int a[4]; register int n; n = sscanf(dottedquad, "%u.%u.%u.%u", &a[0], &a[1], &a[2], &a[3]); switch (n) { case 4: (void) sprintf(addrbuf, "%u.%u.%u.%u.%s.", a[3]&0xff, a[2]&0xff, a[1]&0xff, a[0]&0xff, ARPA_ROOT); break; case 3: (void) sprintf(addrbuf, "%u.%u.%u.%s.", a[2]&0xff, a[1]&0xff, a[0]&0xff, ARPA_ROOT); break; case 2: (void) sprintf(addrbuf, "%u.%u.%s.", a[1]&0xff, a[0]&0xff, ARPA_ROOT); break; case 1: (void) sprintf(addrbuf, "%u.%s.", a[0]&0xff, ARPA_ROOT); break; default: return(NULL); } while (--n >= 0) if (a[n] > 255) return(NULL); return(addrbuf); } /* ** NSAP_INT -- Convert dotted nsap address string to reverse nsap.int ** ------------------------------------------------------------------ ** ** Returns: ** Pointer to appropriate reverse nsap.int name ** with trailing dot to force absolute domain name. ** NULL in case of invalid nsap address input string. */ char * nsap_int(name) input char *name; /* input string with dotted nsap */ { static char addrbuf[4*MAXNSAP + sizeof(NSAP_ROOT) + 2]; register int n; register int i; /* skip optional leading hex indicator */ if (samehead(name, "0x")) name += 2; for (n = 0, i = strlength(name)-1; i >= 0; --i) { /* skip optional interspersed separators */ if (name[i] == '.' || name[i] == '+' || name[i] == '/') continue; /* must consist of hex digits only */ if (!is_xdigit(name[i])) return(NULL); /* but not too many */ if (n >= 4*MAXNSAP) return(NULL); addrbuf[n++] = name[i]; addrbuf[n++] = '.'; } /* must have an even number of hex digits */ if (n == 0 || (n % 4) != 0) return(NULL); (void) sprintf(&addrbuf[n], "%s.", NSAP_ROOT); return(addrbuf); } /* ** PRINT_HOST -- Print host name and address of hostent struct ** ----------------------------------------------------------- ** ** Returns: ** None. */ void print_host(heading, hp) input char *heading; /* header string */ input struct hostent *hp; /* location of hostent struct */ { register char **ap; printf("%s: %s", heading, hp->h_name); for (ap = hp->h_addr_list; ap && *ap; ap++) { if (ap == hp->h_addr_list) printf("\nAddress:"); printf(" %s", inet_ntoa(incopy(*ap))); } for (ap = hp->h_aliases; ap && *ap && **ap; ap++) { if (ap == hp->h_aliases) printf("\nAliases:"); printf(" %s", *ap); } printf("\n\n"); } /* ** SHOW_RES -- Show resolver database information ** ---------------------------------------------- ** ** Returns: ** None. ** ** Inputs: ** The resolver database _res is localized in the resolver. */ void show_res() { register int i; register char **domain; /* * The default domain is defined by the "domain" entry in /etc/resolv.conf * if not overridden by the environment variable "LOCALDOMAIN". * If still not defined, gethostname() may yield a fully qualified host name. */ printf("Default domain:"); if (_res.defdname[0] != '\0') printf(" %s", _res.defdname); printf("\n"); /* * The search domains are extracted from the default domain components, * but may be overridden by "search" directives in /etc/resolv.conf * since 4.8.3. */ printf("Search domains:"); for (domain = _res.dnsrch; *domain; domain++) printf(" %s", *domain); printf("\n"); /* * The routine res_send() will do _res.retry tries to contact each of the * _res.nscount nameserver addresses before giving up when using datagrams. * The first try will timeout after _res.retrans seconds. Each following * try will timeout after ((_res.retrans << try) / _res.nscount) seconds. * Note. When we contact an explicit server the addresses will be replaced * by the multiple addresses of the same server. * When doing a zone transfer _res.retrans is used for the connect timeout. */ printf("Timeout per retry: %d secs\n", _res.retrans); printf("Number of retries: %d\n", _res.retry); printf("Number of addresses: %d\n", _res.nscount); for (i = 0; i < _res.nscount; i++) printf("%s\n", inet_ntoa(nslist(i).sin_addr)); /* * The resolver options are initialized by res_init() to contain the * defaults settings (RES_RECURSE | RES_DEFNAMES | RES_DNSRCH) * The various options have the following meaning: * * RES_INIT set after res_init() has been called * RES_DEBUG let the resolver modules print debugging info * RES_AAONLY want authoritative answers only (not implemented) * RES_USEVC use tcp virtual circuit instead of udp datagrams * RES_PRIMARY use primary nameserver only (not implemented) * RES_IGNTC ignore datagram truncation; don't switch to tcp * RES_RECURSE forward query if answer not locally available * RES_DEFNAMES add default domain to queryname without dot * RES_STAYOPEN keep tcp socket open for subsequent queries * RES_DNSRCH append search domains even to queryname with dot */ printf("Options set:"); if (bitset(RES_INIT, _res.options)) printf(" INIT"); if (bitset(RES_DEBUG, _res.options)) printf(" DEBUG"); if (bitset(RES_AAONLY, _res.options)) printf(" AAONLY"); if (bitset(RES_USEVC, _res.options)) printf(" USEVC"); if (bitset(RES_PRIMARY, _res.options)) printf(" PRIMARY"); if (bitset(RES_IGNTC, _res.options)) printf(" IGNTC"); if (bitset(RES_RECURSE, _res.options)) printf(" RECURSE"); if (bitset(RES_DEFNAMES, _res.options)) printf(" DEFNAMES"); if (bitset(RES_STAYOPEN, _res.options)) printf(" STAYOPEN"); if (bitset(RES_DNSRCH, _res.options)) printf(" DNSRCH"); printf("\n"); printf("Options clr:"); if (!bitset(RES_INIT, _res.options)) printf(" INIT"); if (!bitset(RES_DEBUG, _res.options)) printf(" DEBUG"); if (!bitset(RES_AAONLY, _res.options)) printf(" AAONLY"); if (!bitset(RES_USEVC, _res.options)) printf(" USEVC"); if (!bitset(RES_PRIMARY, _res.options)) printf(" PRIMARY"); if (!bitset(RES_IGNTC, _res.options)) printf(" IGNTC"); if (!bitset(RES_RECURSE, _res.options)) printf(" RECURSE"); if (!bitset(RES_DEFNAMES, _res.options)) printf(" DEFNAMES"); if (!bitset(RES_STAYOPEN, _res.options)) printf(" STAYOPEN"); if (!bitset(RES_DNSRCH, _res.options)) printf(" DNSRCH"); printf("\n"); /* * The new BIND 4.9.3 has additional features which are not (yet) used. */ printf("\n"); } /* ** PRINT_STATISTICS -- Print resource record statistics ** ---------------------------------------------------- ** ** Returns: ** None. ** ** Inputs: ** The record_stats[] counts have been updated by print_rrec(). */ void print_statistics(name, filter, class) input char *name; /* name of zone we are listing */ input int filter; /* type of records we want to see */ input int class; /* class of records we want to see */ { register int type; int nrecords; for (type = T_FIRST; type <= T_LAST; type++) { nrecords = record_stats[type]; if (nrecords > 0 || ((filter != T_ANY) && want_type(type, filter))) { printf("Found %4d %-5s record%-1s", nrecords, pr_type(type), plural(nrecords)); if (class != C_IN) printf(" in class %s", pr_class(class)); printf(" within %s\n", name); } } } /* ** CLEAR_STATISTICS -- Clear resource record statistics ** ---------------------------------------------------- ** ** Returns: ** None. */ void clear_statistics() { bzero((char *)record_stats, sizeof(record_stats)); } /* ** SHOW_TYPES -- Show resource record types wanted ** ----------------------------------------------- ** ** Returns: ** None. */ void show_types(name, filter, class) input char *name; /* name we want to query about */ input int filter; /* type of records we want to see */ input int class; /* class of records we want to see */ { register int type; if (filter >= T_NONE) { printf("Query about %s for record types", name); if (filter == T_ANY) printf(" %s", pr_type(T_ANY)); else for (type = T_FIRST; type <= T_LAST; type++) if (want_type(type, filter)) printf(" %s", pr_type(type)); if (class != C_IN) printf(" in class %s", pr_class(class)); printf("\n"); } } /* ** NS_ERROR -- Print error message from errno and h_errno ** ------------------------------------------------------ ** ** Returns: ** None. ** ** If BIND res_send() fails, it will leave errno in either of the first ** two following states when using datagrams. Note that this depends on ** the proper handling of connected datagram sockets, which is usually ** true if BSD >= 43 (see res_send.c for details; it may need a patch). ** Note. If the 4.8 version succeeds, it may leave errno as EAFNOSUPPORT ** if it has disconnected a previously connected datagram socket, since ** the dummy address used to disconnect does not have a proper family set. ** Always clear errno after getting a reply, or patch res_send(). ** Our private version of res_send() will leave also other error statuses. */ void ns_error(name, type, class, host) input char *name; /* full name we queried about */ input int type; /* record type we queried about */ input int class; /* record class we queried about */ input char *host; /* set if explicit server was used */ { static char *auth = "Authoritative answer"; /* * Print the message associated with the network related errno values. */ switch (errno) { case ECONNREFUSED: /* * The contacted host does not have a nameserver running. * The standard res_send() also returns this if none of * the intended hosts could be reached via datagrams. */ if (host != NULL) errmsg("Nameserver %s not running", host); else errmsg("Nameserver not running"); break; case ETIMEDOUT: /* * The contacted server did not give any reply at all * within the specified time frame. */ if (host != NULL) errmsg("Nameserver %s not responding", host); else errmsg("Nameserver not responding"); break; case ENETDOWN: case ENETUNREACH: case EHOSTDOWN: case EHOSTUNREACH: /* * The host to be contacted or its network can not be reached. * Our private res_send() also returns this using datagrams. */ if (host != NULL) errmsg("Nameserver %s not reachable", host); else errmsg("Nameserver not reachable"); break; } /* * Print the message associated with the particular nameserver error. */ switch (h_errno) { case HOST_NOT_FOUND: /* * The specified name does definitely not exist at all. * In this case the answer is always authoritative. * Nameserver status: NXDOMAIN */ if (class != C_IN) errmsg("%s does not exist in class %s (%s)", name, pr_class(class), auth); else if (host != NULL) errmsg("%s does not exist at %s (%s)", name, host, auth); else errmsg("%s does not exist (%s)", name, auth); break; case NO_HOST: /* * The specified name does not exist, but the answer * was not authoritative, so it is still undecided. * Nameserver status: NXDOMAIN */ if (class != C_IN) errmsg("%s does not exist in class %s, try again", name, pr_class(class)); else if (host != NULL) errmsg("%s does not exist at %s, try again", name, host); else errmsg("%s does not exist, try again", name); break; case NO_DATA: /* * The name is valid, but the specified type does not exist. * This status is here returned only in case authoritative. * Nameserver status: NOERROR */ if (class != C_IN) errmsg("%s has no %s record in class %s (%s)", name, pr_type(type), pr_class(class), auth); else if (host != NULL) errmsg("%s has no %s record at %s (%s)", name, pr_type(type), host, auth); else errmsg("%s has no %s record (%s)", name, pr_type(type), auth); break; case NO_RREC: /* * The specified type does not exist, but we don't know whether * the name is valid or not. The answer was not authoritative. * Perhaps recursion was off, and no data was cached locally. * Nameserver status: NOERROR */ if (class != C_IN) errmsg("%s %s record in class %s currently not present", name, pr_type(type), pr_class(class)); else if (host != NULL) errmsg("%s %s record currently not present at %s", name, pr_type(type), host); else errmsg("%s %s record currently not present", name, pr_type(type)); break; case TRY_AGAIN: /* * Some intermediate failure, e.g. connect timeout, * or some local operating system transient errors. * General failure to reach any appropriate servers. * The status SERVFAIL now yields a separate error code. * Nameserver status: (SERVFAIL) */ if (class != C_IN) errmsg("%s %s record in class %s not found, try again", name, pr_type(type), pr_class(class)); else if (host != NULL) errmsg("%s %s record not found at %s, try again", name, pr_type(type), host); else errmsg("%s %s record not found, try again", name, pr_type(type)); break; case SERVER_FAILURE: /* * Explicit server failure status. This will be returned upon * some internal server errors, forwarding failures, or when * the server is not authoritative for a specific class. * Also if the zone data has expired at a secondary server. * Nameserver status: SERVFAIL */ if (class != C_IN) errmsg("%s %s record in class %s not found, server failure", name, pr_type(type), pr_class(class)); else if (host != NULL) errmsg("%s %s record not found at %s, server failure", name, pr_type(type), host); else errmsg("%s %s record not found, server failure", name, pr_type(type)); break; case NO_RECOVERY: /* * Some irrecoverable format error, or server refusal. * The status REFUSED now yields a separate error code. * Nameserver status: (REFUSED) FORMERR NOTIMP NOCHANGE */ if (class != C_IN) errmsg("%s %s record in class %s not found, no recovery", name, pr_type(type), pr_class(class)); else if (host != NULL) errmsg("%s %s record not found at %s, no recovery", name, pr_type(type), host); else errmsg("%s %s record not found, no recovery", name, pr_type(type)); break; case QUERY_REFUSED: /* * The server explicitly refused to answer the query. * Servers can be configured to disallow zone transfers. * Nameserver status: REFUSED */ if (class != C_IN) errmsg("%s %s record in class %s query refused", name, pr_type(type), pr_class(class)); else if (host != NULL) errmsg("%s %s record query refused by %s", name, pr_type(type), host); else errmsg("%s %s record query refused", name, pr_type(type)); break; default: /* * Unknown cause for server failure. */ if (class != C_IN) errmsg("%s %s record in class %s not found", name, pr_type(type), pr_class(class)); else if (host != NULL) errmsg("%s %s record not found at %s", name, pr_type(type), host); else errmsg("%s %s record not found", name, pr_type(type)); break; } } /* ** DECODE_ERROR -- Convert nameserver error code to error message ** -------------------------------------------------------------- ** ** Returns: ** Pointer to appropriate error message. */ char * decode_error(rcode) input int rcode; /* error code from bp->rcode */ { switch (rcode) { case NOERROR: return("no error"); case FORMERR: return("format error"); case SERVFAIL: return("server failure"); case NXDOMAIN: return("non-existent domain"); case NOTIMP: return("not implemented"); case REFUSED: return("query refused"); case NOCHANGE: return("no change"); } return("unknown error"); } /* ** PRINT_STATUS -- Print result status after nameserver query ** ---------------------------------------------------------- ** ** Returns: ** None. ** ** Conditions: ** The size of the answer buffer must have been ** checked before to be of sufficient length, ** i.e. to contain at least the buffer header. */ void print_status(answerbuf, answerlen) input querybuf *answerbuf; /* location of answer buffer */ input int answerlen; /* length of answer buffer */ { HEADER *bp; int ancount; bool failed; bp = (HEADER *)answerbuf; ancount = ntohs(bp->ancount); failed = (bp->rcode != NOERROR || ancount == 0); printf("%s", verbose ? "" : dbprefix); printf("Query %s", failed ? "failed" : "done"); if (bp->tc || (answerlen > PACKETSZ)) printf(", %d byte%s", answerlen, plural(answerlen)); if (bp->tc) { if (answerlen > sizeof(querybuf)) printf(" (truncated to %d)", sizeof(querybuf)); else printf(" (truncated)"); } printf(", %d answer%s", ancount, plural(ancount)); printf(", %s", bp->aa ? "authoritative " : ""); printf("status: %s\n", decode_error((int)bp->rcode)); } /* ** PR_ERROR -- Print error message about encountered inconsistencies ** ----------------------------------------------------------------- ** ** We are supposed to have an error condition which is fatal ** for normal continuation, and the message is always printed. ** ** Returns: ** None. ** ** Side effects: ** Increments the global error count. */ void /*VARARGS1*/ pr_error(fmt, a, b, c, d) input char *fmt; /* format of message */ input char *a, *b, *c, *d; /* optional arguments */ { (void) fprintf(stderr, " *** "); (void) fprintf(stderr, fmt, a, b, c, d); (void) fprintf(stderr, "\n"); /* flag an error */ errorcount++; } /* ** PR_WARNING -- Print warning message about encountered inconsistencies ** --------------------------------------------------------------------- ** ** We are supposed to have an error condition which is non-fatal ** for normal continuation, and the message is suppressed in case ** quiet mode has been selected. ** ** Returns: ** None. */ void /*VARARGS1*/ pr_warning(fmt, a, b, c, d) input char *fmt; /* format of message */ input char *a, *b, *c, *d; /* optional arguments */ { if (!quiet) { (void) fprintf(stderr, " !!! "); (void) fprintf(stderr, fmt, a, b, c, d); (void) fprintf(stderr, "\n"); } } /* ** WANT_TYPE -- Indicate whether the rr type matches the desired filter ** -------------------------------------------------------------------- ** ** Returns: ** TRUE if the resource record type matches the filter. ** FALSE otherwise. ** ** In regular mode, the querytype is used to formulate the query, ** and the filter is set to T_ANY to filter out any response. ** In listmode, we get everything, so the filter is set to the ** querytype to filter out the proper responses. ** Note that T_NONE is the default querytype in listmode. */ bool want_type(type, filter) input int type; /* resource record type */ input int filter; /* type of records we want to see */ { if (type == filter) return(TRUE); if (filter == T_ANY) return(TRUE); if (filter == T_NONE && (type == T_A || type == T_NS || type == T_PTR)) return(TRUE); if (filter == T_MAILB && (type == T_MB || type == T_MR || type == T_MG || type == T_MINFO)) return(TRUE); if (filter == T_MAILA && (type == T_MD || type == T_MF)) return(TRUE); return(FALSE); } /* ** WANT_CLASS -- Indicate whether the rr class matches the desired filter ** ---------------------------------------------------------------------- ** ** Returns: ** TRUE if the resource record class matches the filter. ** FALSE otherwise. ** ** In regular mode, the queryclass is used to formulate the query, ** and the filter is set to C_ANY to filter out any response. ** In listmode, we get everything, so the filter is set to the ** queryclass to filter out the proper responses. ** Note that C_IN is the default queryclass in listmode. */ bool want_class(class, filter) input int class; /* resource record class */ input int filter; /* class of records we want to see */ { if (class == filter) return(TRUE); if (filter == C_ANY) return(TRUE); return(FALSE); } /* ** INDOMAIN -- Check whether a name belongs to a zone ** -------------------------------------------------- ** ** Returns: ** TRUE if the given name lies anywhere in the zone, or ** if the given name is the same as the zone and may be so. ** FALSE otherwise. */ bool indomain(name, domain, equal) input char *name; /* the name under consideration */ input char *domain; /* the name of the zone */ input bool equal; /* set if name may be same as zone */ { register char *dot; if (sameword(name, domain)) return(equal); if (sameword(domain, ".")) return(TRUE); dot = index(name, '.'); while (dot != NULL) { if (!is_quoted(dot, name)) { if (sameword(dot+1, domain)) return(TRUE); } dot = index(dot+1, '.'); } return(FALSE); } /* ** SAMEDOMAIN -- Check whether a name belongs to a zone ** ---------------------------------------------------- ** ** Returns: ** TRUE if the given name lies directly in the zone, or ** if the given name is the same as the zone and may be so. ** FALSE otherwise. */ bool samedomain(name, domain, equal) input char *name; /* the name under consideration */ input char *domain; /* the name of the zone */ input bool equal; /* set if name may be same as zone */ { register char *dot; if (sameword(name, domain)) return(equal); dot = index(name, '.'); while (dot != NULL) { if (!is_quoted(dot, name)) { if (sameword(dot+1, domain)) return(TRUE); return(FALSE); } dot = index(dot+1, '.'); } if (sameword(domain, ".")) return(TRUE); return(FALSE); } /* ** GLUERECORD -- Check whether a name is a glue record ** --------------------------------------------------- ** ** Returns: ** TRUE is this is a glue record. ** FALSE otherwise. ** ** The name is supposed to be the name of an address record. ** If it lies directly in the given zone, it is considered ** an ordinary host within that zone, and not a glue record. ** If it does not belong to the given zone at all, is it ** here considered to be a glue record. ** If it lies in the given zone, but not directly, it is ** considered a glue record if it belongs to any of the known ** delegated zones of the given zone. ** In the root zone itself are no hosts, only glue records. */ bool gluerecord(name, domain, zone, nzones) input char *name; /* the name under consideration */ input char *domain; /* name of zone being processed */ input char *zone[]; /* list of known delegated zones */ input int nzones; /* number of known delegated zones */ { register int n; if (sameword(domain, ".")) return(TRUE); if (samedomain(name, domain, TRUE)) return(FALSE); if (!indomain(name, domain, TRUE)) return(TRUE); for (n = 0; n < nzones; n++) if (indomain(name, zone[n], TRUE)) return(TRUE); return(FALSE); } /* ** MATCHLABELS -- Determine number of matching domain name labels ** -------------------------------------------------------------- ** ** Returns: ** Number of shared trailing components in both names. ** ** Note. This routine is currently used only to compare nameserver ** names in the RHS of NS records, so there is no need to check ** for embedded quoted dots. */ int matchlabels(name, domain) input char *name; /* domain name to check */ input char *domain; /* domain name to compare against */ { register int i, j; int matched = 0; i = strlength(name); j = strlength(domain); while (--i >= 0 && --j >= 0) { if (lowercase(name[i]) != lowercase(domain[j])) break; if (domain[j] == '.') matched++; else if (j == 0 && (i == 0 || name[i-1] == '.')) matched++; } return(matched); } /* ** PR_DOMAIN -- Convert domain name according to printing options ** -------------------------------------------------------------- ** ** Returns: ** Pointer to new domain name, if conversion was done. ** Pointer to original name, if no conversion necessary. */ char * pr_domain(name, listing) input char *name; /* domain name to be printed */ input bool listing; /* set if this is a zone listing */ { char *newname; /* converted domain name */ /* * Print reverse nsap.int name in forward notation, unless prohibited. */ if (revnsap && !dotprint) { newname = pr_nsap(name); if (newname != name) return(newname); } /* * Print domain names with trailing dot if necessary. */ if (listing || dotprint) { newname = pr_dotname(name); if (newname != name) return(newname); } /* * No conversion was required, use original name. */ return(name); } /* ** PR_DOTNAME -- Return domain name with trailing dot ** -------------------------------------------------- ** ** Returns: ** Pointer to new domain name, if dot was added. ** Pointer to original name, if dot was already present. */ char * pr_dotname(name) input char *name; /* domain name to append to */ { static char buf[MAXDNAME+2]; /* buffer to store new domain name */ register int n; n = strlength(name); if (n > 0 && name[n-1] == '.') return(name); if (n > MAXDNAME) n = MAXDNAME; #ifdef obsolete (void) sprintf(buf, "%.*s.", MAXDNAME, name); #endif bcopy(name, buf, n); buf[n] = '.'; buf[n+1] = '\0'; return(buf); } /* ** PR_NSAP -- Convert reverse nsap.int to dotted forward notation ** -------------------------------------------------------------- ** ** Returns: ** Pointer to new dotted nsap, if converted. ** Pointer to original name otherwise. */ char * pr_nsap(name) input char *name; /* potential reverse nsap.int name */ { static char buf[3*MAXNSAP+1]; register char *p; register int n; register int i; /* must begin with single hex digits separated by dots */ for (i = 0; is_xdigit(name[i]) && name[i+1] == '.'; i += 2) continue; /* must have an even number of hex digits */ if (i == 0 || (i % 4) != 0) return(name); /* but not too many */ if (i > 4*MAXNSAP) return(name); /* must end in the appropriate root domain */ if (!sameword(&name[i], NSAP_ROOT)) return(name); for (p = buf, n = 0; i >= 4; i -= 4, n++) { *p++ = name[i-2]; *p++ = name[i-4]; /* add dots for readability */ if ((n % 2) == 0 && (i - 4) > 0) *p++ = '.'; } *p = '\0'; return(buf); } /* ** PR_TYPE -- Return name of resource record type ** ---------------------------------------------- ** ** Returns: ** Pointer to name of resource record type. ** ** Note. All possible (even obsolete) types are recognized. */ char * pr_type(type) input int type; /* resource record type */ { static char buf[30]; /* sufficient for 64-bit values */ switch (type) { /* standard types */ case T_A: return("A"); /* internet address */ case T_NS: return("NS"); /* authoritative server */ case T_MD: return("MD"); /* mail destination */ case T_MF: return("MF"); /* mail forwarder */ case T_CNAME: return("CNAME"); /* canonical name */ case T_SOA: return("SOA"); /* start of auth zone */ case T_MB: return("MB"); /* mailbox domain name */ case T_MG: return("MG"); /* mail group member */ case T_MR: return("MR"); /* mail rename name */ case T_NULL: return("NULL"); /* null resource record */ case T_WKS: return("WKS"); /* well known service */ case T_PTR: return("PTR"); /* domain name pointer */ case T_HINFO: return("HINFO"); /* host information */ case T_MINFO: return("MINFO"); /* mailbox information */ case T_MX: return("MX"); /* mail routing info */ case T_TXT: return("TXT"); /* descriptive text */ /* new types */ case T_RP: return("RP"); /* responsible person */ case T_AFSDB: return("AFSDB"); /* afs database location */ case T_X25: return("X25"); /* x25 address */ case T_ISDN: return("ISDN"); /* isdn address */ case T_RT: return("RT"); /* route through host */ case T_NSAP: return("NSAP"); /* nsap address */ case T_NSAPPTR: return("NSAP-PTR"); /* nsap pointer */ case T_SIG: return("SIG"); /* security signature */ case T_KEY: return("KEY"); /* security key */ case T_PX: return("PX"); /* rfc822 - x400 mapping */ case T_GPOS: return("GPOS"); /* geographical position */ case T_AAAA: return("AAAA"); /* ip v6 address */ case T_LOC: return("LOC"); /* geographical location */ case T_NXT: return("NXT"); /* next valid name */ case T_EID: return("EID"); /* endpoint identifier */ case T_NIMLOC: return("NIMLOC"); /* nimrod locator */ case T_SRV: return("SRV"); /* service info */ case T_ATMA: return("ATMA"); /* atm address */ case T_NAPTR: return("NAPTR"); /* naming authority urn */ /* nonstandard types */ case T_UINFO: return("UINFO"); /* user information */ case T_UID: return("UID"); /* user ident */ case T_GID: return("GID"); /* group ident */ case T_UNSPEC: return("UNSPEC"); /* unspecified binary data */ /* filters */ case T_IXFR: return("IXFR"); /* incremental zone transfer */ case T_AXFR: return("AXFR"); /* zone transfer */ case T_MAILB: return("MAILB"); /* matches MB/MR/MG/MINFO */ case T_MAILA: return("MAILA"); /* matches MD/MF */ case T_ANY: return("ANY"); /* matches any type */ case T_NONE: return("resource"); /* not yet determined */ } /* unknown type */ (void) sprintf(buf, "%d", type); return(buf); } /* ** PR_CLASS -- Return name of resource record class ** ------------------------------------------------ ** ** Returns: ** Pointer to name of resource record class. */ char * pr_class(class) input int class; /* resource record class */ { static char buf[30]; /* sufficient for 64-bit values */ switch (class) { case C_IN: return("IN"); /* internet */ case C_CSNET: return("CS"); /* csnet */ case C_CHAOS: return("CH"); /* chaosnet */ case C_HS: return("HS"); /* hesiod */ case C_ANY: return("ANY"); /* any class */ } /* unknown class */ (void) sprintf(buf, "%d", class); return(buf); } /* ** EXPAND_NAME -- Expand compressed domain name in a resource record ** ----------------------------------------------------------------- ** ** Returns: ** Number of bytes advanced in answer buffer. ** -1 if there was a format error. ** ** It is assumed that the specified buffer is of a fixed size ** MAXDNAME+1 that should be sufficient to store the data. */ int expand_name(name, type, cp, msg, eom, namebuf) input char *name; /* name of resource record */ input int type; /* type of resource record */ input u_char *cp; /* current position in answer buf */ input u_char *msg, *eom; /* begin and end of answer buf */ output char *namebuf; /* location of buf to expand name in */ { register int n; n = dn_expand(msg, eom, cp, (nbuf_t *)namebuf, MAXDNAME); if (n < 0) { pr_error("expand error in %s record for %s, offset %s", pr_type(type), name, itoa(cp - msg)); h_errno = NO_RECOVERY; return(-1); } /* should not be necessary, but who knows */ namebuf[MAXDNAME] = '\0'; /* change root to single dot */ if (namebuf[0] == '\0') { namebuf[0] = '.'; namebuf[1] = '\0'; } return(n); } /* ** CHECK_SIZE -- Check whether resource record is of sufficient length ** ------------------------------------------------------------------- ** ** Returns: ** Requested size if current record is long enough. ** -1 if current record does not have this many bytes. ** ** Note that HINFO records are very often incomplete since only ** one of the two data fields has been filled in and the second ** field is missing. So we generate only a warning message. */ int check_size(name, type, cp, msg, eor, size) input char *name; /* name of resource record */ input int type; /* type of resource record */ input u_char *cp; /* current position in answer buf */ input u_char *msg; /* begin of answer buf */ input u_char *eor; /* predicted position of next record */ input int size; /* required record size remaining */ { if (cp + size > eor) { if (type != T_HINFO) pr_error("incomplete %s record for %s, offset %s", pr_type(type), name, itoa(cp - msg)); else pr_warning("incomplete %s record for %s", pr_type(type), name); h_errno = NO_RECOVERY; return(-1); } return(size); } /* ** VALID_NAME -- Check whether domain name contains invalid characters ** ------------------------------------------------------------------- ** ** Returns: ** TRUE if the name is valid. ** FALSE otherwise. ** ** The total size of a compound name should not exceed MAXDNAME. ** We assume that this is true. Its individual components between ** dots should not be longer than 64. This is not checked here. ** ** Only alphanumeric characters and dash '-' may be used (dash ** only in the middle). We only check the individual characters. ** Strictly speaking, this restriction is only for ``host names''. ** The underscore is illegal, at least not recommended, but is ** so abundant that it requires special processing. ** ** If the domain name represents a mailbox specification, the ** first label up to the first (unquoted) dot is the local part ** of a mail address, which should adhere to the RFC 822 specs. ** This first dot takes the place of the RFC 822 '@' sign. ** ** The label '*' can in principle be used anywhere to indicate ** wildcarding. It is valid only in the LHS resource record name, ** in definitions in zone files only as the first component. ** Used primarily in wildcard MX record definitions. ** ** Note. This routine is much too liberal. */ char *specials = ".()<>@,;:\\\"[]"; /* RFC 822 specials */ bool valid_name(name, wildcard, localpart, underscore) input char *name; /* domain name to check */ input bool wildcard; /* set if wildcard is allowed */ input bool localpart; /* set if this is a mailbox spec */ input bool underscore; /* set if underscores are allowed */ { bool backslash = FALSE; bool quoting = FALSE; register char *p; register char c; for (p = name; (c = *p) != '\0'; p++) { /* special check for local part in mailbox */ if (localpart) { if (backslash) backslash = FALSE; /* escape this char */ else if (c == '\\') backslash = TRUE; /* escape next char */ else if (c == '"') quoting = !quoting; /* start/stop quoting */ else if (quoting) continue; /* allow quoted chars */ else if (c == '.') localpart = FALSE; /* instead of '@' */ else if (c == '@') return(FALSE); /* should be '.' */ else if (in_string(specials, c)) return(FALSE); /* must be escaped */ else if (is_space(c)) return(FALSE); /* must be escaped */ continue; } /* basic character set */ if (is_alnum(c) || (c == '-')) continue; /* start of a new component */ if (c == '.') continue; /* allow '*' for use in wildcard names */ if ((c == '*') && (p == name && p[1] == '.') && wildcard) continue; /* ignore underscore in certain circumstances */ if ((c == '_') && underscore && !illegal) continue; /* silently allowed widespread exceptions */ if (illegal && in_string(illegal, c)) continue; return(FALSE); } /* must be beyond the local part in a mailbox */ if (localpart) return(FALSE); return(TRUE); } /* ** CANONICAL -- Check whether domain name is a canonical host name ** --------------------------------------------------------------- ** ** Returns: ** Nonzero if the name is definitely not canonical. ** 0 if it is canonical, or if it remains undecided. */ int canonical(name) input char *name; /* the domain name to check */ { struct hostent *hp; int status; int save_errno; int save_herrno; /* * Preserve state when querying, to avoid clobbering current values. */ save_errno = errno; save_herrno = h_errno; hp = geth_byname(name); status = h_errno; errno = save_errno; h_errno = save_herrno; /* * Indicate negative result only after definitive lookup failures. */ if (hp == NULL) { /* authoritative denial -- not existing or no A record */ if (status == NO_DATA || status == HOST_NOT_FOUND) return(status); /* nameserver failure -- still undecided, assume ok */ return(0); } /* * The given name exists and there is an associated A record. * The name of this A record should be the name we queried about. * If this is not the case we probably supplied a CNAME. */ status = sameword(hp->h_name, name) ? 0 : HOST_NOT_CANON; return(status); } /* ** MAPREVERSE -- Check whether address maps back to given domain ** ------------------------------------------------------------- ** ** Returns: ** NULL if address could definitively not be mapped. ** Given name if the address maps back properly, or ** in case of transient nameserver failures. ** Reverse name if it differs from the given name. */ char * mapreverse(name, inaddr) input char *name; /* domain name of A record */ input struct in_addr inaddr; /* address of A record to check */ { struct hostent *hp; int status; int save_errno; int save_herrno; /* * Preserve state when querying, to avoid clobbering current values. */ save_errno = errno; save_herrno = h_errno; hp = geth_byaddr((char *)&inaddr, INADDRSZ, AF_INET); status = h_errno; errno = save_errno; h_errno = save_herrno; /* * Indicate negative result only after definitive lookup failures. */ if (hp == NULL) { /* authoritative denial -- not existing or no PTR record */ if (status == NO_DATA || status == HOST_NOT_FOUND) return(NULL); /* nameserver failure -- still undecided, assume ok */ return(name); } /* * Indicate whether the reverse mapping yields the given name. */ return(sameword(hp->h_name, name) ? name : hp->h_name); } /* ** COMPARE_NAME -- Compare two names wrt alphabetical order ** -------------------------------------------------------- ** ** Returns: ** Value of case-insensitive comparison. */ int compare_name(a, b) input const ptr_t *a; /* first name */ input const ptr_t *b; /* second name */ { return(strcasecmp(*(char **)a, *(char **)b)); } /* ** XALLOC -- Allocate or reallocate additional memory ** -------------------------------------------------- ** ** Returns: ** Pointer to (re)allocated buffer space. ** Aborts if the requested memory could not be obtained. */ ptr_t * xalloc(buf, size) register ptr_t *buf; /* current start of buffer space */ input siz_t size; /* number of bytes to allocate */ { if (buf == NULL) buf = malloc(size); else buf = realloc(buf, size); if (buf == NULL) { errmsg("Out of memory"); exit(EX_OSERR); } return(buf); } /* ** ITOA -- Convert value to decimal integer ascii string ** ----------------------------------------------------- ** ** Returns: ** Pointer to string. */ char * itoa(n) input int n; /* value to convert */ { static char buf[30]; /* sufficient for 64-bit values */ (void) sprintf(buf, "%d", n); return(buf); } /* ** UTOA -- Convert value to unsigned decimal ascii string ** ------------------------------------------------------ ** ** Returns: ** Pointer to string. */ char * utoa(n) input int n; /* value to convert */ { static char buf[30]; /* sufficient for 64-bit values */ (void) sprintf(buf, "%u", (unsigned)n); return(buf); } /* ** XTOA -- Convert value to hexadecimal ascii string ** ------------------------------------------------- ** ** Returns: ** Pointer to string. */ char * xtoa(n) input int n; /* value to convert */ { static char buf[17]; /* sufficient for 64-bit values */ (void) sprintf(buf, "%X", (unsigned)n); return(buf); } /* ** STOA -- Extract partial ascii string, escape if necessary ** --------------------------------------------------------- ** ** Returns: ** Pointer to string. */ char * stoa(cp, size, escape) input u_char *cp; /* current position in answer buf */ input int size; /* number of bytes to extract */ input bool escape; /* escape special characters if set */ { static char buf[2*MAXDLEN+1]; register char *p; register char c; register int i; if (size > MAXDLEN) size = MAXDLEN; #ifdef obsolete if (size > 0) (void) sprintf(buf, "%.*s", size, (char *)cp); else (void) sprintf(buf, "%s", ""); #endif for (p = buf, i = 0; i < size; i++) { c = *cp++; if (escape && (c == '\n' || c == '\\' || c == '"')) *p++ = '\\'; *p++ = c; } *p = '\0'; return(buf); } /* ** BASE_NTOA -- Convert binary data to base64 ascii ** ------------------------------------------------ ** ** Returns: ** Pointer to string. ** ** This routine is used to convert encoded keys and signatures ** in T_KEY and T_SIG resource records. */ char b64tab[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; char * base_ntoa(cp, size) input u_char *cp; /* current position in answer buf */ input int size; /* number of bytes to extract */ { static char buf[MAXB64SIZE+1]; register char *p; int c1, c2, c3, c4; if (size > MAXMD5SIZE) size = MAXMD5SIZE; for (p = buf; size > 2; cp += 3, size -= 3) { c1 = (((int)cp[0] >> 2) & 0x3f); c2 = (((int)cp[0] & 0x03) << 4) + (((int)cp[1] >> 4) & 0x0f); c3 = (((int)cp[1] & 0x0f) << 2) + (((int)cp[2] >> 6) & 0x03); c4 = ((int)cp[2] & 0x3f); *p++ = b64tab[c1]; *p++ = b64tab[c2]; *p++ = b64tab[c3]; *p++ = b64tab[c4]; } if (size == 2) { c1 = (((int)cp[0] >> 2) & 0x3f); c2 = (((int)cp[0] & 0x03) << 4) + (((int)cp[1] >> 4) & 0x0f); c3 = (((int)cp[1] & 0x0f) << 2); *p++ = b64tab[c1]; *p++ = b64tab[c2]; *p++ = b64tab[c3]; *p++ = '='; } else if (size == 1) { c1 = (((int)cp[0] >> 2) & 0x3f); c2 = (((int)cp[0] & 0x03) << 4); *p++ = b64tab[c1]; *p++ = b64tab[c2]; *p++ = '='; *p++ = '='; } *p = '\0'; return(buf); } /* ** NSAP_NTOA -- Convert binary nsap address to ascii ** ------------------------------------------------- ** ** Returns: ** Pointer to string. ** ** As per RFC 1637 an nsap address is encoded in binary form ** in the resource record. It was unclear from RFC 1348 how ** the encoding should be. RFC 1629 defines an upper bound ** of 20 bytes to the size of a binary nsap address. */ char * nsap_ntoa(cp, size) input u_char *cp; /* current position in answer buf */ input int size; /* number of bytes to extract */ { static char buf[3*MAXNSAP+1]; register char *p; register int n; register int i; if (size > MAXNSAP) size = MAXNSAP; for (p = buf, i = 0; i < size; i++, cp++) { n = ((int)(*cp) >> 4) & 0x0f; *p++ = hexdigit(n); n = ((int)(*cp) >> 0) & 0x0f; *p++ = hexdigit(n); /* add dots for readability */ if ((i % 2) == 0 && (i + 1) < size) *p++ = '.'; } *p = '\0'; return(buf); } /* ** IPNG_NTOA -- Convert binary ip v6 address to ascii ** -------------------------------------------------- ** ** Returns: ** Pointer to string. ** ** As per RFC 1886 an ip v6 address is encoded in binary form ** in the resource record. The size is fixed. */ char * ipng_ntoa(cp) input u_char *cp; /* current position in answer buf */ { static char buf[5*(IPNGSIZE/2)+1]; register char *p; register int n; register int i; for (p = buf, i = 0; i < IPNGSIZE/2; i++) { n = _getshort(cp); cp += INT16SZ; (void) sprintf(p, ":%X", n); p += strlength(p); } *p = '\0'; return(buf + 1); } /* ** PR_DATE -- Produce printable version of a clock value ** ----------------------------------------------------- ** ** Returns: ** Pointer to string. ** ** The value is a standard absolute clock value. */ char * pr_date(value) input int value; /* the clock value to be converted */ { static char buf[sizeof("YYYYMMDDHHMMSS")+1]; time_t clocktime = value; struct tm *t; t = gmtime(&clocktime); t->tm_year += 1900; t->tm_mon += 1; (void) sprintf(buf, "%04d%02d%02d%02d%02d%02d", t->tm_year, t->tm_mon, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); return(buf); } /* ** PR_TIME -- Produce printable version of a time interval ** ------------------------------------------------------- ** ** Returns: ** Pointer to a string version of interval. ** ** The value is a time interval expressed in seconds. */ char * pr_time(value, brief) input int value; /* the interval to be converted */ input bool brief; /* use brief format if set */ { static char buf[256]; register char *p = buf; int week, days, hour, mins, secs; /* special cases */ if (value < 0) return("negative"); if ((value == 0) && !brief) return("zero seconds"); /* * Decode the components. */ secs = value % 60; value /= 60; mins = value % 60; value /= 60; hour = value % 24; value /= 24; days = value; if (!brief) { days = value % 7; value /= 7; week = value; } /* * Now turn it into a sexy form. */ if (brief) { if (days > 0) { (void) sprintf(p, "%d+", days); p += strlength(p); } (void) sprintf(p, "%02d:%02d:%02d", hour, mins, secs); return(buf); } if (week > 0) { (void) sprintf(p, ", %d week%s", week, plural(week)); p += strlength(p); } if (days > 0) { (void) sprintf(p, ", %d day%s", days, plural(days)); p += strlength(p); } if (hour > 0) { (void) sprintf(p, ", %d hour%s", hour, plural(hour)); p += strlength(p); } if (mins > 0) { (void) sprintf(p, ", %d minute%s", mins, plural(mins)); p += strlength(p); } if (secs > 0) { (void) sprintf(p, ", %d second%s", secs, plural(secs)); /* p += strlength(p); */ } return(buf + 2); } /* ** PR_SPHERICAL -- Produce printable version of a spherical location ** ----------------------------------------------------------------- ** ** Returns: ** Pointer to a string version of location. ** ** The value is a spherical location (latitude or longitude) ** expressed in thousandths of a second of arc. ** The value 2^31 represents zero (equator or prime meridian). */ char * pr_spherical(value, pos, neg) input int value; /* the location to be converted */ input char *pos; /* suffix if value positive */ input char *neg; /* suffix if value negative */ { static char buf[256]; register char *p = buf; char *direction; int degrees, minutes, seconds, fracsec; /* * Normalize. */ value -= (int)((unsigned)1 << 31); direction = pos; if (value < 0) { direction = neg; value = -value; } /* * Decode the components. */ fracsec = value % 1000; value /= 1000; seconds = value % 60; value /= 60; minutes = value % 60; value /= 60; degrees = value; /* * Construct output string. */ (void) sprintf(p, "%d", degrees); p += strlength(p); if (minutes > 0 || seconds > 0 || fracsec > 0) { (void) sprintf(p, " %02d", minutes); p += strlength(p); } if (seconds > 0 || fracsec > 0) { (void) sprintf(p, " %02d", seconds); p += strlength(p); } if (fracsec > 0) { (void) sprintf(p, ".%03d", fracsec); p += strlength(p); } (void) sprintf(p, " %s", direction); #ifdef obsolete (void) sprintf(buf, "%d %02d %02d.%03d %s", degrees, minutes, seconds, fracsec, direction); #endif return(buf); } /* ** PR_VERTICAL -- Produce printable version of a vertical location ** --------------------------------------------------------------- ** ** Returns: ** Pointer to a string version of location. ** ** The value is an altitude expressed in centimeters, starting ** from a base 100000 meters below the GPS reference spheroid. ** This allows for the actual range [-10000000 .. 4293967296]. */ char * pr_vertical(value, pos, neg) input int value; /* the location to be converted */ input char *pos; /* prefix if value positive */ input char *neg; /* prefix if value negative */ { static char buf[256]; register char *p = buf; char *direction; int meters, centimeters; unsigned int altitude; unsigned int reference; /* * Normalize. */ altitude = value; reference = 100000*100; if (altitude < reference) { direction = neg; altitude = reference - altitude; } else { direction = pos; altitude = altitude - reference; } /* * Decode the components. */ centimeters = altitude % 100; altitude /= 100; meters = altitude; /* * Construct output string. */ (void) sprintf(p, "%s%d", direction, meters); p += strlength(p); if (centimeters > 0) (void) sprintf(p, ".%02d", centimeters); #ifdef obsolete (void) sprintf(buf, "%s%d.%02d", direction, meters, centimeters); #endif return(buf); } /* ** PR_PRECISION -- Produce printable version of a location precision ** ----------------------------------------------------------------- ** ** Returns: ** Pointer to a string version of precision. ** ** The value is a precision expressed in centimeters, encoded ** as 4-bit mantissa and 4-bit power of 10 (each ranging 0-9). */ unsigned int poweroften[10] = {1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000}; char * pr_precision(value) input int value; /* the precision to be converted */ { static char buf[256]; register char *p = buf; int meters, centimeters; unsigned int precision; register int mantissa; register int exponent; /* * Normalize. */ mantissa = ((value >> 4) & 0x0f) % 10; exponent = ((value >> 0) & 0x0f) % 10; precision = mantissa * poweroften[exponent]; /* * Decode the components. */ centimeters = precision % 100; precision /= 100; meters = precision; /* * Construct output string. */ (void) sprintf(p, "%d", meters); p += strlength(p); if (centimeters > 0) (void) sprintf(p, ".%02d", centimeters); #ifdef obsolete (void) sprintf(buf, "%d.%02d", meters, centimeters); #endif return(buf); }