From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- src/c-ares/adig.c | 827 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 827 insertions(+) create mode 100644 src/c-ares/adig.c (limited to 'src/c-ares/adig.c') diff --git a/src/c-ares/adig.c b/src/c-ares/adig.c new file mode 100644 index 000000000..e112dc044 --- /dev/null +++ b/src/c-ares/adig.c @@ -0,0 +1,827 @@ +/* Copyright 1998 by the Massachusetts Institute of Technology. + * + * + * Permission to use, copy, modify, and distribute this + * software and its documentation for any purpose and without + * fee is hereby granted, provided that the above copyright + * notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting + * documentation, and that the name of M.I.T. not be used in + * advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. + * M.I.T. makes no representations about the suitability of + * this software for any purpose. It is provided "as is" + * without express or implied warranty. + */ + +#include "ares_setup.h" + +#ifdef HAVE_NETINET_IN_H +# include +#endif +#ifdef HAVE_ARPA_INET_H +# include +#endif +#ifdef HAVE_NETDB_H +# include +#endif +#ifdef HAVE_ARPA_NAMESER_H +# include +#else +# include "nameser.h" +#endif +#ifdef HAVE_ARPA_NAMESER_COMPAT_H +# include +#endif + +#ifdef HAVE_STRINGS_H +# include +#endif + +#include "ares.h" +#include "ares_dns.h" +#include "ares_getopt.h" +#include "ares_nowarn.h" + +#ifndef HAVE_STRDUP +# include "ares_strdup.h" +# define strdup(ptr) ares_strdup(ptr) +#endif + +#ifndef HAVE_STRCASECMP +# include "ares_strcasecmp.h" +# define strcasecmp(p1,p2) ares_strcasecmp(p1,p2) +#endif + +#ifndef HAVE_STRNCASECMP +# include "ares_strcasecmp.h" +# define strncasecmp(p1,p2,n) ares_strncasecmp(p1,p2,n) +#endif + +#ifdef WATT32 +#undef WIN32 /* Redefined in MingW headers */ +#endif + +#ifndef T_SRV +# define T_SRV 33 /* Server selection */ +#endif +#ifndef T_NAPTR +# define T_NAPTR 35 /* Naming authority pointer */ +#endif +#ifndef T_DS +# define T_DS 43 /* Delegation Signer (RFC4034) */ +#endif +#ifndef T_SSHFP +# define T_SSHFP 44 /* SSH Key Fingerprint (RFC4255) */ +#endif +#ifndef T_RRSIG +# define T_RRSIG 46 /* Resource Record Signature (RFC4034) */ +#endif +#ifndef T_NSEC +# define T_NSEC 47 /* Next Secure (RFC4034) */ +#endif +#ifndef T_DNSKEY +# define T_DNSKEY 48 /* DNS Public Key (RFC4034) */ +#endif + +struct nv { + const char *name; + int value; +}; + +static const struct nv flags[] = { + { "usevc", ARES_FLAG_USEVC }, + { "primary", ARES_FLAG_PRIMARY }, + { "igntc", ARES_FLAG_IGNTC }, + { "norecurse", ARES_FLAG_NORECURSE }, + { "stayopen", ARES_FLAG_STAYOPEN }, + { "noaliases", ARES_FLAG_NOALIASES } +}; +static const int nflags = sizeof(flags) / sizeof(flags[0]); + +static const struct nv classes[] = { + { "IN", C_IN }, + { "CHAOS", C_CHAOS }, + { "HS", C_HS }, + { "ANY", C_ANY } +}; +static const int nclasses = sizeof(classes) / sizeof(classes[0]); + +static const struct nv types[] = { + { "A", T_A }, + { "NS", T_NS }, + { "MD", T_MD }, + { "MF", T_MF }, + { "CNAME", T_CNAME }, + { "SOA", T_SOA }, + { "MB", T_MB }, + { "MG", T_MG }, + { "MR", T_MR }, + { "NULL", T_NULL }, + { "WKS", T_WKS }, + { "PTR", T_PTR }, + { "HINFO", T_HINFO }, + { "MINFO", T_MINFO }, + { "MX", T_MX }, + { "TXT", T_TXT }, + { "RP", T_RP }, + { "AFSDB", T_AFSDB }, + { "X25", T_X25 }, + { "ISDN", T_ISDN }, + { "RT", T_RT }, + { "NSAP", T_NSAP }, + { "NSAP_PTR", T_NSAP_PTR }, + { "SIG", T_SIG }, + { "KEY", T_KEY }, + { "PX", T_PX }, + { "GPOS", T_GPOS }, + { "AAAA", T_AAAA }, + { "LOC", T_LOC }, + { "SRV", T_SRV }, + { "AXFR", T_AXFR }, + { "MAILB", T_MAILB }, + { "MAILA", T_MAILA }, + { "NAPTR", T_NAPTR }, + { "DS", T_DS }, + { "SSHFP", T_SSHFP }, + { "RRSIG", T_RRSIG }, + { "NSEC", T_NSEC }, + { "DNSKEY", T_DNSKEY }, + { "ANY", T_ANY } +}; +static const int ntypes = sizeof(types) / sizeof(types[0]); + +static const char *opcodes[] = { + "QUERY", "IQUERY", "STATUS", "(reserved)", "NOTIFY", + "(unknown)", "(unknown)", "(unknown)", "(unknown)", + "UPDATEA", "UPDATED", "UPDATEDA", "UPDATEM", "UPDATEMA", + "ZONEINIT", "ZONEREF" +}; + +static const char *rcodes[] = { + "NOERROR", "FORMERR", "SERVFAIL", "NXDOMAIN", "NOTIMP", "REFUSED", + "(unknown)", "(unknown)", "(unknown)", "(unknown)", "(unknown)", + "(unknown)", "(unknown)", "(unknown)", "(unknown)", "NOCHANGE" +}; + +static void callback(void *arg, int status, int timeouts, + unsigned char *abuf, int alen); +static const unsigned char *display_question(const unsigned char *aptr, + const unsigned char *abuf, + int alen); +static const unsigned char *display_rr(const unsigned char *aptr, + const unsigned char *abuf, int alen); +static const char *type_name(int type); +static const char *class_name(int dnsclass); +static void usage(void); +static void destroy_addr_list(struct ares_addr_node *head); +static void append_addr_list(struct ares_addr_node **head, + struct ares_addr_node *node); + +int main(int argc, char **argv) +{ + ares_channel channel; + int c, i, optmask = ARES_OPT_FLAGS, dnsclass = C_IN, type = T_A; + int status, nfds, count; + struct ares_options options; + struct hostent *hostent; + fd_set read_fds, write_fds; + struct timeval *tvp, tv; + struct ares_addr_node *srvr, *servers = NULL; + +#ifdef USE_WINSOCK + WORD wVersionRequested = MAKEWORD(USE_WINSOCK,USE_WINSOCK); + WSADATA wsaData; + WSAStartup(wVersionRequested, &wsaData); +#endif + + status = ares_library_init(ARES_LIB_INIT_ALL); + if (status != ARES_SUCCESS) + { + fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status)); + return 1; + } + + options.flags = ARES_FLAG_NOCHECKRESP; + options.servers = NULL; + options.nservers = 0; + while ((c = ares_getopt(argc, argv, "df:s:c:t:T:U:")) != -1) + { + switch (c) + { + case 'd': +#ifdef WATT32 + dbug_init(); +#endif + break; + + case 'f': + /* Add a flag. */ + for (i = 0; i < nflags; i++) + { + if (strcmp(flags[i].name, optarg) == 0) + break; + } + if (i < nflags) + options.flags |= flags[i].value; + else + usage(); + break; + + case 's': + /* User-specified name servers override default ones. */ + srvr = malloc(sizeof(struct ares_addr_node)); + if (!srvr) + { + fprintf(stderr, "Out of memory!\n"); + destroy_addr_list(servers); + return 1; + } + append_addr_list(&servers, srvr); + if (ares_inet_pton(AF_INET, optarg, &srvr->addr.addr4) > 0) + srvr->family = AF_INET; + else if (ares_inet_pton(AF_INET6, optarg, &srvr->addr.addr6) > 0) + srvr->family = AF_INET6; + else + { + hostent = gethostbyname(optarg); + if (!hostent) + { + fprintf(stderr, "adig: server %s not found.\n", optarg); + destroy_addr_list(servers); + return 1; + } + switch (hostent->h_addrtype) + { + case AF_INET: + srvr->family = AF_INET; + memcpy(&srvr->addr.addr4, hostent->h_addr, + sizeof(srvr->addr.addr4)); + break; + case AF_INET6: + srvr->family = AF_INET6; + memcpy(&srvr->addr.addr6, hostent->h_addr, + sizeof(srvr->addr.addr6)); + break; + default: + fprintf(stderr, + "adig: server %s unsupported address family.\n", optarg); + destroy_addr_list(servers); + return 1; + } + } + /* Notice that calling ares_init_options() without servers in the + * options struct and with ARES_OPT_SERVERS set simultaneously in + * the options mask, results in an initialization with no servers. + * When alternative name servers have been specified these are set + * later calling ares_set_servers() overriding any existing server + * configuration. To prevent initial configuration with default + * servers that will be discarded later, ARES_OPT_SERVERS is set. + * If this flag is not set here the result shall be the same but + * ares_init_options() will do needless work. */ + optmask |= ARES_OPT_SERVERS; + break; + + case 'c': + /* Set the query class. */ + for (i = 0; i < nclasses; i++) + { + if (strcasecmp(classes[i].name, optarg) == 0) + break; + } + if (i < nclasses) + dnsclass = classes[i].value; + else + usage(); + break; + + case 't': + /* Set the query type. */ + for (i = 0; i < ntypes; i++) + { + if (strcasecmp(types[i].name, optarg) == 0) + break; + } + if (i < ntypes) + type = types[i].value; + else + usage(); + break; + + case 'T': + /* Set the TCP port number. */ + if (!ISDIGIT(*optarg)) + usage(); + options.tcp_port = (unsigned short)strtol(optarg, NULL, 0); + optmask |= ARES_OPT_TCP_PORT; + break; + + case 'U': + /* Set the UDP port number. */ + if (!ISDIGIT(*optarg)) + usage(); + options.udp_port = (unsigned short)strtol(optarg, NULL, 0); + optmask |= ARES_OPT_UDP_PORT; + break; + } + } + argc -= optind; + argv += optind; + if (argc == 0) + usage(); + + status = ares_init_options(&channel, &options, optmask); + + if (status != ARES_SUCCESS) + { + fprintf(stderr, "ares_init_options: %s\n", + ares_strerror(status)); + return 1; + } + + if(servers) + { + status = ares_set_servers(channel, servers); + destroy_addr_list(servers); + if (status != ARES_SUCCESS) + { + fprintf(stderr, "ares_init_options: %s\n", + ares_strerror(status)); + return 1; + } + } + + /* Initiate the queries, one per command-line argument. If there is + * only one query to do, supply NULL as the callback argument; + * otherwise, supply the query name as an argument so we can + * distinguish responses for the user when printing them out. + */ + if (argc == 1) + ares_query(channel, *argv, dnsclass, type, callback, (char *) NULL); + else + { + for (; *argv; argv++) + ares_query(channel, *argv, dnsclass, type, callback, *argv); + } + + /* Wait for all queries to complete. */ + for (;;) + { + FD_ZERO(&read_fds); + FD_ZERO(&write_fds); + nfds = ares_fds(channel, &read_fds, &write_fds); + if (nfds == 0) + break; + tvp = ares_timeout(channel, NULL, &tv); + count = select(nfds, &read_fds, &write_fds, NULL, tvp); + if (count < 0 && (status = SOCKERRNO) != EINVAL) + { + printf("select fail: %d", status); + return 1; + } + ares_process(channel, &read_fds, &write_fds); + } + + ares_destroy(channel); + + ares_library_cleanup(); + +#ifdef USE_WINSOCK + WSACleanup(); +#endif + + return 0; +} + +static void callback(void *arg, int status, int timeouts, + unsigned char *abuf, int alen) +{ + char *name = (char *) arg; + int id, qr, opcode, aa, tc, rd, ra, rcode; + unsigned int qdcount, ancount, nscount, arcount, i; + const unsigned char *aptr; + + (void) timeouts; + + /* Display the query name if given. */ + if (name) + printf("Answer for query %s:\n", name); + + /* Display an error message if there was an error, but only stop if + * we actually didn't get an answer buffer. + */ + if (status != ARES_SUCCESS) + { + printf("%s\n", ares_strerror(status)); + if (!abuf) + return; + } + + /* Won't happen, but check anyway, for safety. */ + if (alen < HFIXEDSZ) + return; + + /* Parse the answer header. */ + id = DNS_HEADER_QID(abuf); + qr = DNS_HEADER_QR(abuf); + opcode = DNS_HEADER_OPCODE(abuf); + aa = DNS_HEADER_AA(abuf); + tc = DNS_HEADER_TC(abuf); + rd = DNS_HEADER_RD(abuf); + ra = DNS_HEADER_RA(abuf); + rcode = DNS_HEADER_RCODE(abuf); + qdcount = DNS_HEADER_QDCOUNT(abuf); + ancount = DNS_HEADER_ANCOUNT(abuf); + nscount = DNS_HEADER_NSCOUNT(abuf); + arcount = DNS_HEADER_ARCOUNT(abuf); + + /* Display the answer header. */ + printf("id: %d\n", id); + printf("flags: %s%s%s%s%s\n", + qr ? "qr " : "", + aa ? "aa " : "", + tc ? "tc " : "", + rd ? "rd " : "", + ra ? "ra " : ""); + printf("opcode: %s\n", opcodes[opcode]); + printf("rcode: %s\n", rcodes[rcode]); + + /* Display the questions. */ + printf("Questions:\n"); + aptr = abuf + HFIXEDSZ; + for (i = 0; i < qdcount; i++) + { + aptr = display_question(aptr, abuf, alen); + if (aptr == NULL) + return; + } + + /* Display the answers. */ + printf("Answers:\n"); + for (i = 0; i < ancount; i++) + { + aptr = display_rr(aptr, abuf, alen); + if (aptr == NULL) + return; + } + + /* Display the NS records. */ + printf("NS records:\n"); + for (i = 0; i < nscount; i++) + { + aptr = display_rr(aptr, abuf, alen); + if (aptr == NULL) + return; + } + + /* Display the additional records. */ + printf("Additional records:\n"); + for (i = 0; i < arcount; i++) + { + aptr = display_rr(aptr, abuf, alen); + if (aptr == NULL) + return; + } +} + +static const unsigned char *display_question(const unsigned char *aptr, + const unsigned char *abuf, + int alen) +{ + char *name; + int type, dnsclass, status; + long len; + + /* Parse the question name. */ + status = ares_expand_name(aptr, abuf, alen, &name, &len); + if (status != ARES_SUCCESS) + return NULL; + aptr += len; + + /* Make sure there's enough data after the name for the fixed part + * of the question. + */ + if (aptr + QFIXEDSZ > abuf + alen) + { + ares_free_string(name); + return NULL; + } + + /* Parse the question type and class. */ + type = DNS_QUESTION_TYPE(aptr); + dnsclass = DNS_QUESTION_CLASS(aptr); + aptr += QFIXEDSZ; + + /* Display the question, in a format sort of similar to how we will + * display RRs. + */ + printf("\t%-15s.\t", name); + if (dnsclass != C_IN) + printf("\t%s", class_name(dnsclass)); + printf("\t%s\n", type_name(type)); + ares_free_string(name); + return aptr; +} + +static const unsigned char *display_rr(const unsigned char *aptr, + const unsigned char *abuf, int alen) +{ + const unsigned char *p; + int type, dnsclass, ttl, dlen, status; + long len; + char addr[46]; + union { + unsigned char * as_uchar; + char * as_char; + } name; + + /* Parse the RR name. */ + status = ares_expand_name(aptr, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + aptr += len; + + /* Make sure there is enough data after the RR name for the fixed + * part of the RR. + */ + if (aptr + RRFIXEDSZ > abuf + alen) + { + ares_free_string(name.as_char); + return NULL; + } + + /* Parse the fixed part of the RR, and advance to the RR data + * field. */ + type = DNS_RR_TYPE(aptr); + dnsclass = DNS_RR_CLASS(aptr); + ttl = DNS_RR_TTL(aptr); + dlen = DNS_RR_LEN(aptr); + aptr += RRFIXEDSZ; + if (aptr + dlen > abuf + alen) + { + ares_free_string(name.as_char); + return NULL; + } + + /* Display the RR name, class, and type. */ + printf("\t%-15s.\t%d", name.as_char, ttl); + if (dnsclass != C_IN) + printf("\t%s", class_name(dnsclass)); + printf("\t%s", type_name(type)); + ares_free_string(name.as_char); + + /* Display the RR data. Don't touch aptr. */ + switch (type) + { + case T_CNAME: + case T_MB: + case T_MD: + case T_MF: + case T_MG: + case T_MR: + case T_NS: + case T_PTR: + /* For these types, the RR data is just a domain name. */ + status = ares_expand_name(aptr, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s.", name.as_char); + ares_free_string(name.as_char); + break; + + case T_HINFO: + /* The RR data is two length-counted character strings. */ + p = aptr; + len = *p; + if (p + len + 1 > aptr + dlen) + return NULL; + status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s", name.as_char); + ares_free_string(name.as_char); + p += len; + len = *p; + if (p + len + 1 > aptr + dlen) + return NULL; + status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s", name.as_char); + ares_free_string(name.as_char); + break; + + case T_MINFO: + /* The RR data is two domain names. */ + p = aptr; + status = ares_expand_name(p, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s.", name.as_char); + ares_free_string(name.as_char); + p += len; + status = ares_expand_name(p, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s.", name.as_char); + ares_free_string(name.as_char); + break; + + case T_MX: + /* The RR data is two bytes giving a preference ordering, and + * then a domain name. + */ + if (dlen < 2) + return NULL; + printf("\t%d", (int)DNS__16BIT(aptr)); + status = ares_expand_name(aptr + 2, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s.", name.as_char); + ares_free_string(name.as_char); + break; + + case T_SOA: + /* The RR data is two domain names and then five four-byte + * numbers giving the serial number and some timeouts. + */ + p = aptr; + status = ares_expand_name(p, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s.\n", name.as_char); + ares_free_string(name.as_char); + p += len; + status = ares_expand_name(p, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t\t\t\t\t\t%s.\n", name.as_char); + ares_free_string(name.as_char); + p += len; + if (p + 20 > aptr + dlen) + return NULL; + printf("\t\t\t\t\t\t( %u %u %u %u %u )", + DNS__32BIT(p), DNS__32BIT(p+4), + DNS__32BIT(p+8), DNS__32BIT(p+12), + DNS__32BIT(p+16)); + break; + + case T_TXT: + /* The RR data is one or more length-counted character + * strings. */ + p = aptr; + while (p < aptr + dlen) + { + len = *p; + if (p + len + 1 > aptr + dlen) + return NULL; + status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s", name.as_char); + ares_free_string(name.as_char); + p += len; + } + break; + + case T_A: + /* The RR data is a four-byte Internet address. */ + if (dlen != 4) + return NULL; + printf("\t%s", ares_inet_ntop(AF_INET,aptr,addr,sizeof(addr))); + break; + + case T_AAAA: + /* The RR data is a 16-byte IPv6 address. */ + if (dlen != 16) + return NULL; + printf("\t%s", ares_inet_ntop(AF_INET6,aptr,addr,sizeof(addr))); + break; + + case T_WKS: + /* Not implemented yet */ + break; + + case T_SRV: + /* The RR data is three two-byte numbers representing the + * priority, weight, and port, followed by a domain name. + */ + + printf("\t%d", (int)DNS__16BIT(aptr)); + printf(" %d", (int)DNS__16BIT(aptr + 2)); + printf(" %d", (int)DNS__16BIT(aptr + 4)); + + status = ares_expand_name(aptr + 6, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t%s.", name.as_char); + ares_free_string(name.as_char); + break; + + case T_NAPTR: + + printf("\t%d", (int)DNS__16BIT(aptr)); /* order */ + printf(" %d\n", (int)DNS__16BIT(aptr + 2)); /* preference */ + + p = aptr + 4; + status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t\t\t\t\t\t%s\n", name.as_char); + ares_free_string(name.as_char); + p += len; + + status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t\t\t\t\t\t%s\n", name.as_char); + ares_free_string(name.as_char); + p += len; + + status = ares_expand_string(p, abuf, alen, &name.as_uchar, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t\t\t\t\t\t%s\n", name.as_char); + ares_free_string(name.as_char); + p += len; + + status = ares_expand_name(p, abuf, alen, &name.as_char, &len); + if (status != ARES_SUCCESS) + return NULL; + printf("\t\t\t\t\t\t%s", name.as_char); + ares_free_string(name.as_char); + break; + + case T_DS: + case T_SSHFP: + case T_RRSIG: + case T_NSEC: + case T_DNSKEY: + printf("\t[RR type parsing unavailable]"); + break; + + default: + printf("\t[Unknown RR; cannot parse]"); + break; + } + printf("\n"); + + return aptr + dlen; +} + +static const char *type_name(int type) +{ + int i; + + for (i = 0; i < ntypes; i++) + { + if (types[i].value == type) + return types[i].name; + } + return "(unknown)"; +} + +static const char *class_name(int dnsclass) +{ + int i; + + for (i = 0; i < nclasses; i++) + { + if (classes[i].value == dnsclass) + return classes[i].name; + } + return "(unknown)"; +} + +static void usage(void) +{ + fprintf(stderr, "usage: adig [-f flag] [-s server] [-c class] " + "[-t type] [-p port] name ...\n"); + exit(1); +} + +static void destroy_addr_list(struct ares_addr_node *head) +{ + while(head) + { + struct ares_addr_node *detached = head; + head = head->next; + free(detached); + } +} + +static void append_addr_list(struct ares_addr_node **head, + struct ares_addr_node *node) +{ + struct ares_addr_node *last; + node->next = NULL; + if(*head) + { + last = *head; + while(last->next) + last = last->next; + last->next = node; + } + else + *head = node; +} -- cgit v1.2.3