lib/libc/resolv/res_debug.c

   1 /*-
   2  * SPDX-License-Identifier: (ISC AND BSD-3-Clause)
   3  *
   4  * Portions Copyright (C) 2004, 2005, 2008, 2009  Internet Systems Consortium, Inc. ("ISC")
   5  * Portions Copyright (C) 1996-2003  Internet Software Consortium.
   6  *
   7  * Permission to use, copy, modify, and/or distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  12  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  13  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  14  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  15  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  16  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 /*-
  21  * Copyright (c) 1985
  22  *    The Regents of the University of California.  All rights reserved.
  23  *
  24  * Redistribution and use in source and binary forms, with or without
  25  * modification, are permitted provided that the following conditions
  26  * are met:
  27  * 1. Redistributions of source code must retain the above copyright
  28  *    notice, this list of conditions and the following disclaimer.
  29  * 2. Redistributions in binary form must reproduce the above copyright
  30  *    notice, this list of conditions and the following disclaimer in the
  31  *    documentation and/or other materials provided with the distribution.
  32  * 3. Neither the name of the University nor the names of its contributors
  33  *    may be used to endorse or promote products derived from this software
  34  *    without specific prior written permission.
  35  *
  36  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  37  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  39  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  40  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  41  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  42  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  44  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  45  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46  * SUCH DAMAGE.
  47  */
  48
  49 /*
  50  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  51  *
  52  * Permission to use, copy, modify, and distribute this software for any
  53  * purpose with or without fee is hereby granted, provided that the above
  54  * copyright notice and this permission notice appear in all copies, and that
  55  * the name of Digital Equipment Corporation not be used in advertising or
  56  * publicity pertaining to distribution of the document or software without
  57  * specific, written prior permission.
  58  *
  59  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  60  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  61  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  62  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  63  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  64  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  65  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  66  * SOFTWARE.
  67  */
  68
  69 /*
  70  * Portions Copyright (c) 1995 by International Business Machines, Inc.
  71  *
  72  * International Business Machines, Inc. (hereinafter called IBM) grants
  73  * permission under its copyrights to use, copy, modify, and distribute this
  74  * Software with or without fee, provided that the above copyright notice and
  75  * all paragraphs of this notice appear in all copies, and that the name of IBM
  76  * not be used in connection with the marketing of any product incorporating
  77  * the Software or modifications thereof, without specific, written prior
  78  * permission.
  79  *
  80  * To the extent it has a right to do so, IBM grants an immunity from suit
  81  * under its patents, if any, for the use, sale or manufacture of products to
  82  * the extent that such products are used for performing Domain Name System
  83  * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
  84  * granted for any product per se or for any other function of any product.
  85  *
  86  * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
  87  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
  89  * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
  90  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
  91  * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
  92  */
  93
  94 #if defined(LIBC_SCCS) && !defined(lint)
  95 static const char sccsid[] = "@(#)res_debug.c   8.1 (Berkeley) 6/4/93";
  96 static const char rcsid[] = "$Id: res_debug.c,v 1.19 2009/02/26 11:20:20 tbox Exp $";
  97 #endif /* LIBC_SCCS and not lint */
  98 #include <sys/cdefs.h>
  99 __FBSDID("$FreeBSD$");
 100
 101 #include "port_before.h"
 102
 103 #include <sys/param.h>
 104 #include <sys/socket.h>
 105
 106 #include <netinet/in.h>
 107 #include <arpa/inet.h>
 108 #include <arpa/nameser.h>
 109
 110 #include <ctype.h>
 111 #include <errno.h>
 112 #include <math.h>
 113 #include <netdb.h>
 114 #include <resolv.h>
 115 #include <resolv_mt.h>
 116 #include <stdio.h>
 117 #include <stdlib.h>
 118 #include <string.h>
 119 #include <time.h>
 120
 121 #include "port_after.h"
 122
 123 #ifdef SPRINTF_CHAR
 124 # define SPRINTF(x) strlen(sprintf/**/x)
 125 #else
 126 # define SPRINTF(x) sprintf x
 127 #endif
 128
 129 extern const char *_res_opcodes[];
 130 extern const char *_res_sectioncodes[];
 131
 132 /*%
 133  * Print the current options.
 134  */
 135 void
 136 fp_resstat(const res_state statp, FILE *file) {
 137         u_long mask;
 138
 139         fprintf(file, ";; res options:");
 140         for (mask = 1;  mask != 0U;  mask <<= 1)
 141                 if (statp->options & mask)
 142                         fprintf(file, " %s", p_option(mask));
 143         putc('\n', file);
 144 }
 145
 146 static void
 147 do_section(const res_state statp,
 148            ns_msg *handle, ns_sect section,
 149            int pflag, FILE *file)
 150 {
 151         int n, sflag, rrnum;
 152         static int buflen = 2048;
 153         char *buf;
 154         ns_opcode opcode;
 155         ns_rr rr;
 156
 157         /*
 158          * Print answer records.
 159          */
 160         sflag = (statp->pfcode & pflag);
 161         if (statp->pfcode && !sflag)
 162                 return;
 163
 164         buf = malloc(buflen);
 165         if (buf == NULL) {
 166                 fprintf(file, ";; memory allocation failure\n");
 167                 return;
 168         }
 169
 170         opcode = (ns_opcode) ns_msg_getflag(*handle, ns_f_opcode);
 171         rrnum = 0;
 172         for (;;) {
 173                 if (ns_parserr(handle, section, rrnum, &rr)) {
 174                         if (errno != ENODEV)
 175                                 fprintf(file, ";; ns_parserr: %s\n",
 176                                         strerror(errno));
 177                         else if (rrnum > 0 && sflag != 0 &&
 178                                  (statp->pfcode & RES_PRF_HEAD1))
 179                                 putc('\n', file);
 180                         goto cleanup;
 181                 }
 182                 if (rrnum == 0 && sflag != 0 && (statp->pfcode & RES_PRF_HEAD1))
 183                         fprintf(file, ";; %s SECTION:\n",
 184                                 p_section(section, opcode));
 185                 if (section == ns_s_qd)
 186                         fprintf(file, ";;\t%s, type = %s, class = %s\n",
 187                                 ns_rr_name(rr),
 188                                 p_type(ns_rr_type(rr)),
 189                                 p_class(ns_rr_class(rr)));
 190                 else if (section == ns_s_ar && ns_rr_type(rr) == ns_t_opt) {
 191                         u_int16_t optcode, optlen, rdatalen = ns_rr_rdlen(rr);
 192                         u_int32_t ttl = ns_rr_ttl(rr);
 193
 194                         fprintf(file,
 195                                 "; EDNS: version: %u, udp=%u, flags=%04x\n",
 196                                 (ttl>>16)&0xff, ns_rr_class(rr), ttl&0xffff);
 197
 198                         while (rdatalen >= 4) {
 199                                 const u_char *cp = ns_rr_rdata(rr);
 200                                 int i;
 201
 202                                 GETSHORT(optcode, cp);
 203                                 GETSHORT(optlen, cp);
 204
 205                                 if (optcode == NS_OPT_NSID) {
 206                                         fputs("; NSID: ", file);
 207                                         if (optlen == 0) {
 208                                                 fputs("; NSID\n", file);
 209                                         } else {
 210                                                 fputs("; NSID: ", file);
 211                                                 for (i = 0; i < optlen; i++)
 212                                                         fprintf(file, "%02x ",
 213                                                                 cp[i]);
 214                                                 fputs(" (",file);
 215                                                 for (i = 0; i < optlen; i++)
 216                                                         fprintf(file, "%c",
 217                                                                 isprint(cp[i])?
 218                                                                 cp[i] : '.');
 219                                                 fputs(")\n", file);
 220                                         }
 221                                 } else {
 222                                         if (optlen == 0) {
 223                                                 fprintf(file, "; OPT=%u\n",
 224                                                         optcode);
 225                                         } else {
 226                                                 fprintf(file, "; OPT=%u: ",
 227                                                         optcode);
 228                                                 for (i = 0; i < optlen; i++)
 229                                                         fprintf(file, "%02x ",
 230                                                                 cp[i]);
 231                                                 fputs(" (",file);
 232                                                 for (i = 0; i < optlen; i++)
 233                                                         fprintf(file, "%c",
 234                                                                 isprint(cp[i]) ?
 235                                                                         cp[i] : '.');
 236                                                 fputs(")\n", file);
 237                                         }
 238                                 }
 239                                 rdatalen -= 4 + optlen;
 240                         }
 241                 } else {
 242                         n = ns_sprintrr(handle, &rr, NULL, NULL,
 243                                         buf, buflen);
 244                         if (n < 0) {
 245                                 if (errno == ENOSPC) {
 246                                         free(buf);
 247                                         buf = NULL;
 248                                         if (buflen < 131072)
 249                                                 buf = malloc(buflen += 1024);
 250                                         if (buf == NULL) {
 251                                                 fprintf(file,
 252                                               ";; memory allocation failure\n");
 253                                               return;
 254                                         }
 255                                         continue;
 256                                 }
 257                                 fprintf(file, ";; ns_sprintrr: %s\n",
 258                                         strerror(errno));
 259                                 goto cleanup;
 260                         }
 261                         fputs(buf, file);
 262                         fputc('\n', file);
 263                 }
 264                 rrnum++;
 265         }
 266  cleanup:
 267         if (buf != NULL)
 268                 free(buf);
 269 }
 270
 271 /*%
 272  * Print the contents of a query.
 273  * This is intended to be primarily a debugging routine.
 274  */
 275 void
 276 res_pquery(const res_state statp, const u_char *msg, int len, FILE *file) {
 277         ns_msg handle;
 278         int qdcount, ancount, nscount, arcount;
 279         u_int opcode, rcode, id;
 280
 281         if (ns_initparse(msg, len, &handle) < 0) {
 282                 fprintf(file, ";; ns_initparse: %s\n", strerror(errno));
 283                 return;
 284         }
 285         opcode = ns_msg_getflag(handle, ns_f_opcode);
 286         rcode = ns_msg_getflag(handle, ns_f_rcode);
 287         id = ns_msg_id(handle);
 288         qdcount = ns_msg_count(handle, ns_s_qd);
 289         ancount = ns_msg_count(handle, ns_s_an);
 290         nscount = ns_msg_count(handle, ns_s_ns);
 291         arcount = ns_msg_count(handle, ns_s_ar);
 292
 293         /*
 294          * Print header fields.
 295          */
 296         if ((!statp->pfcode) || (statp->pfcode & RES_PRF_HEADX) || rcode)
 297                 fprintf(file,
 298                         ";; ->>HEADER<<- opcode: %s, status: %s, id: %d\n",
 299                         _res_opcodes[opcode], p_rcode(rcode), id);
 300         if ((!statp->pfcode) || (statp->pfcode & RES_PRF_HEADX))
 301                 putc(';', file);
 302         if ((!statp->pfcode) || (statp->pfcode & RES_PRF_HEAD2)) {
 303                 fprintf(file, "; flags:");
 304                 if (ns_msg_getflag(handle, ns_f_qr))
 305                         fprintf(file, " qr");
 306                 if (ns_msg_getflag(handle, ns_f_aa))
 307                         fprintf(file, " aa");
 308                 if (ns_msg_getflag(handle, ns_f_tc))
 309                         fprintf(file, " tc");
 310                 if (ns_msg_getflag(handle, ns_f_rd))
 311                         fprintf(file, " rd");
 312                 if (ns_msg_getflag(handle, ns_f_ra))
 313                         fprintf(file, " ra");
 314                 if (ns_msg_getflag(handle, ns_f_z))
 315                         fprintf(file, " ??");
 316                 if (ns_msg_getflag(handle, ns_f_ad))
 317                         fprintf(file, " ad");
 318                 if (ns_msg_getflag(handle, ns_f_cd))
 319                         fprintf(file, " cd");
 320         }
 321         if ((!statp->pfcode) || (statp->pfcode & RES_PRF_HEAD1)) {
 322                 fprintf(file, "; %s: %d",
 323                         p_section(ns_s_qd, opcode), qdcount);
 324                 fprintf(file, ", %s: %d",
 325                         p_section(ns_s_an, opcode), ancount);
 326                 fprintf(file, ", %s: %d",
 327                         p_section(ns_s_ns, opcode), nscount);
 328                 fprintf(file, ", %s: %d",
 329                         p_section(ns_s_ar, opcode), arcount);
 330         }
 331         if ((!statp->pfcode) || (statp->pfcode &
 332                 (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1))) {
 333                 putc('\n',file);
 334         }
 335         /*
 336          * Print the various sections.
 337          */
 338         do_section(statp, &handle, ns_s_qd, RES_PRF_QUES, file);
 339         do_section(statp, &handle, ns_s_an, RES_PRF_ANS, file);
 340         do_section(statp, &handle, ns_s_ns, RES_PRF_AUTH, file);
 341         do_section(statp, &handle, ns_s_ar, RES_PRF_ADD, file);
 342         if (qdcount == 0 && ancount == 0 &&
 343             nscount == 0 && arcount == 0)
 344                 putc('\n', file);
 345 }
 346
 347 const u_char *
 348 p_cdnname(const u_char *cp, const u_char *msg, int len, FILE *file) {
 349         char name[MAXDNAME];
 350         int n;
 351
 352         if ((n = dn_expand(msg, msg + len, cp, name, sizeof name)) < 0)
 353                 return (NULL);
 354         if (name[0] == '\0')
 355                 putc('.', file);
 356         else
 357                 fputs(name, file);
 358         return (cp + n);
 359 }
 360
 361 const u_char *
 362 p_cdname(const u_char *cp, const u_char *msg, FILE *file) {
 363         return (p_cdnname(cp, msg, PACKETSZ, file));
 364 }
 365
 366 /*%
 367  * Return a fully-qualified domain name from a compressed name (with
 368    length supplied).  */
 369
 370 const u_char *
 371 p_fqnname(const u_char *cp, const u_char *msg, int msglen, char *name,
 372     int namelen)
 373 {
 374         int n, newlen;
 375
 376         if ((n = dn_expand(msg, cp + msglen, cp, name, namelen)) < 0)
 377                 return (NULL);
 378         newlen = strlen(name);
 379         if (newlen == 0 || name[newlen - 1] != '.') {
 380                 if (newlen + 1 >= namelen)      /*%< Lack space for final dot */
 381                         return (NULL);
 382                 else
 383                         strcpy(name + newlen, ".");
 384         }
 385         return (cp + n);
 386 }
 387
 388 /* XXX: the rest of these functions need to become length-limited, too. */
 389
 390 const u_char *
 391 p_fqname(const u_char *cp, const u_char *msg, FILE *file) {
 392         char name[MAXDNAME];
 393         const u_char *n;
 394
 395         n = p_fqnname(cp, msg, MAXCDNAME, name, sizeof name);
 396         if (n == NULL)
 397                 return (NULL);
 398         fputs(name, file);
 399         return (n);
 400 }
 401
 402 /*%
 403  * Names of RR classes and qclasses.  Classes and qclasses are the same, except
 404  * that C_ANY is a qclass but not a class.  (You can ask for records of class
 405  * C_ANY, but you can't have any records of that class in the database.)
 406  */
 407 const struct res_sym __p_class_syms[] = {
 408         {C_IN,          "IN",           (char *)0},
 409         {C_CHAOS,       "CH",           (char *)0},
 410         {C_CHAOS,       "CHAOS",        (char *)0},
 411         {C_HS,          "HS",           (char *)0},
 412         {C_HS,          "HESIOD",       (char *)0},
 413         {C_ANY,         "ANY",          (char *)0},
 414         {C_NONE,        "NONE",         (char *)0},
 415         {C_IN,          (char *)0,      (char *)0}
 416 };
 417
 418 /*%
 419  * Names of message sections.
 420  */
 421 static const struct res_sym __p_default_section_syms[] = {
 422         {ns_s_qd,       "QUERY",        (char *)0},
 423         {ns_s_an,       "ANSWER",       (char *)0},
 424         {ns_s_ns,       "AUTHORITY",    (char *)0},
 425         {ns_s_ar,       "ADDITIONAL",   (char *)0},
 426         {0,             (char *)0,      (char *)0}
 427 };
 428
 429 static const struct res_sym __p_update_section_syms[] = {
 430         {S_ZONE,        "ZONE",         (char *)0},
 431         {S_PREREQ,      "PREREQUISITE", (char *)0},
 432         {S_UPDATE,      "UPDATE",       (char *)0},
 433         {S_ADDT,        "ADDITIONAL",   (char *)0},
 434         {0,             (char *)0,      (char *)0}
 435 };
 436
 437 const struct res_sym __p_key_syms[] = {
 438         {NS_ALG_MD5RSA,         "RSA",          "RSA KEY with MD5 hash"},
 439         {NS_ALG_DH,             "DH",           "Diffie Hellman"},
 440         {NS_ALG_DSA,            "DSA",          "Digital Signature Algorithm"},
 441         {NS_ALG_EXPIRE_ONLY,    "EXPIREONLY",   "No algorithm"},
 442         {NS_ALG_PRIVATE_OID,    "PRIVATE",      "Algorithm obtained from OID"},
 443         {0,                     NULL,           NULL}
 444 };
 445
 446 const struct res_sym __p_cert_syms[] = {
 447         {cert_t_pkix,   "PKIX",         "PKIX (X.509v3) Certificate"},
 448         {cert_t_spki,   "SPKI",         "SPKI certificate"},
 449         {cert_t_pgp,    "PGP",          "PGP certificate"},
 450         {cert_t_url,    "URL",          "URL Private"},
 451         {cert_t_oid,    "OID",          "OID Private"},
 452         {0,             NULL,           NULL}
 453 };
 454
 455 /*%
 456  * Names of RR types and qtypes.  Types and qtypes are the same, except
 457  * that T_ANY is a qtype but not a type.  (You can ask for records of type
 458  * T_ANY, but you can't have any records of that type in the database.)
 459  */
 460 const struct res_sym __p_type_syms[] = {
 461         {ns_t_a,        "A",            "address"},
 462         {ns_t_ns,       "NS",           "name server"},
 463         {ns_t_md,       "MD",           "mail destination (deprecated)"},
 464         {ns_t_mf,       "MF",           "mail forwarder (deprecated)"},
 465         {ns_t_cname,    "CNAME",        "canonical name"},
 466         {ns_t_soa,      "SOA",          "start of authority"},
 467         {ns_t_mb,       "MB",           "mailbox"},
 468         {ns_t_mg,       "MG",           "mail group member"},
 469         {ns_t_mr,       "MR",           "mail rename"},
 470         {ns_t_null,     "NULL",         "null"},
 471         {ns_t_wks,      "WKS",          "well-known service (deprecated)"},
 472         {ns_t_ptr,      "PTR",          "domain name pointer"},
 473         {ns_t_hinfo,    "HINFO",        "host information"},
 474         {ns_t_minfo,    "MINFO",        "mailbox information"},
 475         {ns_t_mx,       "MX",           "mail exchanger"},
 476         {ns_t_txt,      "TXT",          "text"},
 477         {ns_t_rp,       "RP",           "responsible person"},
 478         {ns_t_afsdb,    "AFSDB",        "DCE or AFS server"},
 479         {ns_t_x25,      "X25",          "X25 address"},
 480         {ns_t_isdn,     "ISDN",         "ISDN address"},
 481         {ns_t_rt,       "RT",           "router"},
 482         {ns_t_nsap,     "NSAP",         "nsap address"},
 483         {ns_t_nsap_ptr, "NSAP_PTR",     "domain name pointer"},
 484         {ns_t_sig,      "SIG",          "signature"},
 485         {ns_t_key,      "KEY",          "key"},
 486         {ns_t_px,       "PX",           "mapping information"},
 487         {ns_t_gpos,     "GPOS",         "geographical position (withdrawn)"},
 488         {ns_t_aaaa,     "AAAA",         "IPv6 address"},
 489         {ns_t_loc,      "LOC",          "location"},
 490         {ns_t_nxt,      "NXT",          "next valid name (unimplemented)"},
 491         {ns_t_eid,      "EID",          "endpoint identifier (unimplemented)"},
 492         {ns_t_nimloc,   "NIMLOC",       "NIMROD locator (unimplemented)"},
 493         {ns_t_srv,      "SRV",          "server selection"},
 494         {ns_t_atma,     "ATMA",         "ATM address (unimplemented)"},
 495         {ns_t_naptr,    "NAPTR",        "naptr"},
 496         {ns_t_kx,       "KX",           "key exchange"},
 497         {ns_t_cert,     "CERT",         "certificate"},
 498         {ns_t_a6,       "A",            "IPv6 address (experminental)"},
 499         {ns_t_dname,    "DNAME",        "non-terminal redirection"},
 500         {ns_t_opt,      "OPT",          "opt"},
 501         {ns_t_apl,      "apl",          "apl"},
 502         {ns_t_ds,       "DS",           "delegation signer"},
 503         {ns_t_sshfp,    "SSFP",         "SSH fingerprint"},
 504         {ns_t_ipseckey, "IPSECKEY",     "IPSEC key"},
 505         {ns_t_rrsig,    "RRSIG",        "rrsig"},
 506         {ns_t_nsec,     "NSEC",         "nsec"},
 507         {ns_t_dnskey,   "DNSKEY",       "DNS key"},
 508         {ns_t_dhcid,    "DHCID",       "dynamic host configuration identifier"},
 509         {ns_t_nsec3,    "NSEC3",        "nsec3"},
 510         {ns_t_nsec3param, "NSEC3PARAM", "NSEC3 parameters"},
 511         {ns_t_hip,      "HIP",          "host identity protocol"},
 512         {ns_t_spf,      "SPF",          "sender policy framework"},
 513         {ns_t_tkey,     "TKEY",         "tkey"},
 514         {ns_t_tsig,     "TSIG",         "transaction signature"},
 515         {ns_t_ixfr,     "IXFR",         "incremental zone transfer"},
 516         {ns_t_axfr,     "AXFR",         "zone transfer"},
 517         {ns_t_zxfr,     "ZXFR",         "compressed zone transfer"},
 518         {ns_t_mailb,    "MAILB",        "mailbox-related data (deprecated)"},
 519         {ns_t_maila,    "MAILA",        "mail agent (deprecated)"},
 520         {ns_t_naptr,    "NAPTR",        "URN Naming Authority"},
 521         {ns_t_kx,       "KX",           "Key Exchange"},
 522         {ns_t_cert,     "CERT",         "Certificate"},
 523         {ns_t_a6,       "A6",           "IPv6 Address"},
 524         {ns_t_dname,    "DNAME",        "dname"},
 525         {ns_t_sink,     "SINK",         "Kitchen Sink (experimental)"},
 526         {ns_t_opt,      "OPT",          "EDNS Options"},
 527         {ns_t_any,      "ANY",          "\"any\""},
 528         {ns_t_dlv,      "DLV",          "DNSSEC look-aside validation"},
 529         {0,             NULL,           NULL}
 530 };
 531
 532 /*%
 533  * Names of DNS rcodes.
 534  */
 535 const struct res_sym __p_rcode_syms[] = {
 536         {ns_r_noerror,  "NOERROR",              "no error"},
 537         {ns_r_formerr,  "FORMERR",              "format error"},
 538         {ns_r_servfail, "SERVFAIL",             "server failed"},
 539         {ns_r_nxdomain, "NXDOMAIN",             "no such domain name"},
 540         {ns_r_notimpl,  "NOTIMP",               "not implemented"},
 541         {ns_r_refused,  "REFUSED",              "refused"},
 542         {ns_r_yxdomain, "YXDOMAIN",             "domain name exists"},
 543         {ns_r_yxrrset,  "YXRRSET",              "rrset exists"},
 544         {ns_r_nxrrset,  "NXRRSET",              "rrset doesn't exist"},
 545         {ns_r_notauth,  "NOTAUTH",              "not authoritative"},
 546         {ns_r_notzone,  "NOTZONE",              "Not in zone"},
 547         {ns_r_max,      "",                     ""},
 548         {ns_r_badsig,   "BADSIG",               "bad signature"},
 549         {ns_r_badkey,   "BADKEY",               "bad key"},
 550         {ns_r_badtime,  "BADTIME",              "bad time"},
 551         {0,             NULL,                   NULL}
 552 };
 553
 554 int
 555 sym_ston(const struct res_sym *syms, const char *name, int *success) {
 556         for ((void)NULL; syms->name != 0; syms++) {
 557                 if (strcasecmp (name, syms->name) == 0) {
 558                         if (success)
 559                                 *success = 1;
 560                         return (syms->number);
 561                 }
 562         }
 563         if (success)
 564                 *success = 0;
 565         return (syms->number);          /*%< The default value. */
 566 }
 567
 568 const char *
 569 sym_ntos(const struct res_sym *syms, int number, int *success) {
 570         char *unname = sym_ntos_unname;
 571
 572         for ((void)NULL; syms->name != 0; syms++) {
 573                 if (number == syms->number) {
 574                         if (success)
 575                                 *success = 1;
 576                         return (syms->name);
 577                 }
 578         }
 579
 580         sprintf(unname, "%d", number);          /*%< XXX nonreentrant */
 581         if (success)
 582                 *success = 0;
 583         return (unname);
 584 }
 585
 586 const char *
 587 sym_ntop(const struct res_sym *syms, int number, int *success) {
 588         char *unname = sym_ntop_unname;
 589
 590         for ((void)NULL; syms->name != 0; syms++) {
 591                 if (number == syms->number) {
 592                         if (success)
 593                                 *success = 1;
 594                         return (syms->humanname);
 595                 }
 596         }
 597         sprintf(unname, "%d", number);          /*%< XXX nonreentrant */
 598         if (success)
 599                 *success = 0;
 600         return (unname);
 601 }
 602
 603 /*%
 604  * Return a string for the type.
 605  */
 606 const char *
 607 p_type(int type) {
 608         int success;
 609         const char *result;
 610         static char typebuf[20];
 611
 612         result = sym_ntos(__p_type_syms, type, &success);
 613         if (success)
 614                 return (result);
 615         if (type < 0 || type > 0xffff)
 616                 return ("BADTYPE");
 617         sprintf(typebuf, "TYPE%d", type);
 618         return (typebuf);
 619 }
 620
 621 /*%
 622  * Return a string for the type.
 623  */
 624 const char *
 625 p_section(int section, int opcode) {
 626         const struct res_sym *symbols;
 627
 628         switch (opcode) {
 629         case ns_o_update:
 630                 symbols = __p_update_section_syms;
 631                 break;
 632         default:
 633                 symbols = __p_default_section_syms;
 634                 break;
 635         }
 636         return (sym_ntos(symbols, section, (int *)0));
 637 }
 638
 639 /*%
 640  * Return a mnemonic for class.
 641  */
 642 const char *
 643 p_class(int class) {
 644         int success;
 645         const char *result;
 646         static char classbuf[20];
 647
 648         result = sym_ntos(__p_class_syms, class, &success);
 649         if (success)
 650                 return (result);
 651         if (class < 0 || class > 0xffff)
 652                 return ("BADCLASS");
 653         sprintf(classbuf, "CLASS%d", class);
 654         return (classbuf);
 655 }
 656
 657 /*%
 658  * Return a mnemonic for an option
 659  */
 660 const char *
 661 p_option(u_long option) {
 662         char *nbuf = p_option_nbuf;
 663
 664         switch (option) {
 665         case RES_INIT:          return "init";
 666         case RES_DEBUG:         return "debug";
 667         case RES_AAONLY:        return "aaonly(unimpl)";
 668         case RES_USEVC:         return "usevc";
 669         case RES_PRIMARY:       return "primry(unimpl)";
 670         case RES_IGNTC:         return "igntc";
 671         case RES_RECURSE:       return "recurs";
 672         case RES_DEFNAMES:      return "defnam";
 673         case RES_STAYOPEN:      return "styopn";
 674         case RES_DNSRCH:        return "dnsrch";
 675         case RES_INSECURE1:     return "insecure1";
 676         case RES_INSECURE2:     return "insecure2";
 677         case RES_NOALIASES:     return "noaliases";
 678         case RES_USE_INET6:     return "inet6";
 679 #ifdef RES_USE_EDNS0    /*%< KAME extension */
 680         case RES_USE_EDNS0:     return "edns0";
 681         case RES_NSID:          return "nsid";
 682 #endif
 683 #ifdef RES_USE_DNAME
 684         case RES_USE_DNAME:     return "dname";
 685 #endif
 686 #ifdef RES_USE_DNSSEC
 687         case RES_USE_DNSSEC:    return "dnssec";
 688 #endif
 689 #ifdef RES_NOTLDQUERY
 690         case RES_NOTLDQUERY:    return "no-tld-query";
 691 #endif
 692 #ifdef RES_NO_NIBBLE2
 693         case RES_NO_NIBBLE2:    return "no-nibble2";
 694 #endif
 695                                 /* XXX nonreentrant */
 696         default:                sprintf(nbuf, "?0x%lx?", (u_long)option);
 697                                 return (nbuf);
 698         }
 699 }
 700
 701 /*%
 702  * Return a mnemonic for a time to live.
 703  */
 704 const char *
 705 p_time(u_int32_t value) {
 706         char *nbuf = p_time_nbuf;
 707
 708         if (ns_format_ttl(value, nbuf, sizeof nbuf) < 0)
 709                 sprintf(nbuf, "%u", value);
 710         return (nbuf);
 711 }
 712
 713 /*%
 714  * Return a string for the rcode.
 715  */
 716 const char *
 717 p_rcode(int rcode) {
 718         return (sym_ntos(__p_rcode_syms, rcode, (int *)0));
 719 }
 720
 721 /*%
 722  * Return a string for a res_sockaddr_union.
 723  */
 724 const char *
 725 p_sockun(union res_sockaddr_union u, char *buf, size_t size) {
 726         char ret[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:123.123.123.123"];
 727
 728         switch (u.sin.sin_family) {
 729         case AF_INET:
 730                 inet_ntop(AF_INET, &u.sin.sin_addr, ret, sizeof ret);
 731                 break;
 732 #ifdef HAS_INET6_STRUCTS
 733         case AF_INET6:
 734                 inet_ntop(AF_INET6, &u.sin6.sin6_addr, ret, sizeof ret);
 735                 break;
 736 #endif
 737         default:
 738                 sprintf(ret, "[af%d]", u.sin.sin_family);
 739                 break;
 740         }
 741         if (size > 0U) {
 742                 strncpy(buf, ret, size - 1);
 743                 buf[size - 1] = '0';
 744         }
 745         return (buf);
 746 }
 747
 748 /*%
 749  * routines to convert between on-the-wire RR format and zone file format.
 750  * Does not contain conversion to/from decimal degrees; divide or multiply
 751  * by 60*60*1000 for that.
 752  */
 753
 754 static unsigned int poweroften[10] = {1, 10, 100, 1000, 10000, 100000,
 755                                       1000000,10000000,100000000,1000000000};
 756
 757 /*% takes an XeY precision/size value, returns a string representation. */
 758 static const char *
 759 precsize_ntoa(u_int8_t prec)
 760 {
 761         char *retbuf = precsize_ntoa_retbuf;
 762         unsigned long val;
 763         int mantissa, exponent;
 764
 765         mantissa = (int)((prec >> 4) & 0x0f) % 10;
 766         exponent = (int)((prec >> 0) & 0x0f) % 10;
 767
 768         val = mantissa * poweroften[exponent];
 769
 770         (void) sprintf(retbuf, "%lu.%.2lu", val/100, val%100);
 771         return (retbuf);
 772 }
 773
 774 /*% converts ascii size/precision X * 10**Y(cm) to 0xXY.  moves pointer.  */
 775 static u_int8_t
 776 precsize_aton(const char **strptr) {
 777         unsigned int mval = 0, cmval = 0;
 778         u_int8_t retval = 0;
 779         const char *cp;
 780         int exponent;
 781         int mantissa;
 782
 783         cp = *strptr;
 784
 785         while (isdigit((unsigned char)*cp))
 786                 mval = mval * 10 + (*cp++ - '0');
 787
 788         if (*cp == '.') {               /*%< centimeters */
 789                 cp++;
 790                 if (isdigit((unsigned char)*cp)) {
 791                         cmval = (*cp++ - '0') * 10;
 792                         if (isdigit((unsigned char)*cp)) {
 793                                 cmval += (*cp++ - '0');
 794                         }
 795                 }
 796         }
 797         cmval = (mval * 100) + cmval;
 798
 799         for (exponent = 0; exponent < 9; exponent++)
 800                 if (cmval < poweroften[exponent+1])
 801                         break;
 802
 803         mantissa = cmval / poweroften[exponent];
 804         if (mantissa > 9)
 805                 mantissa = 9;
 806
 807         retval = (mantissa << 4) | exponent;
 808
 809         *strptr = cp;
 810
 811         return (retval);
 812 }
 813
 814 /*% converts ascii lat/lon to unsigned encoded 32-bit number.  moves pointer. */
 815 static u_int32_t
 816 latlon2ul(const char **latlonstrptr, int *which) {
 817         const char *cp;
 818         u_int32_t retval;
 819         int deg = 0, min = 0, secs = 0, secsfrac = 0;
 820
 821         cp = *latlonstrptr;
 822
 823         while (isdigit((unsigned char)*cp))
 824                 deg = deg * 10 + (*cp++ - '0');
 825
 826         while (isspace((unsigned char)*cp))
 827                 cp++;
 828
 829         if (!(isdigit((unsigned char)*cp)))
 830                 goto fndhemi;
 831
 832         while (isdigit((unsigned char)*cp))
 833                 min = min * 10 + (*cp++ - '0');
 834
 835         while (isspace((unsigned char)*cp))
 836                 cp++;
 837
 838         if (!(isdigit((unsigned char)*cp)))
 839                 goto fndhemi;
 840
 841         while (isdigit((unsigned char)*cp))
 842                 secs = secs * 10 + (*cp++ - '0');
 843
 844         if (*cp == '.') {               /*%< decimal seconds */
 845                 cp++;
 846                 if (isdigit((unsigned char)*cp)) {
 847                         secsfrac = (*cp++ - '0') * 100;
 848                         if (isdigit((unsigned char)*cp)) {
 849                                 secsfrac += (*cp++ - '0') * 10;
 850                                 if (isdigit((unsigned char)*cp)) {
 851                                         secsfrac += (*cp++ - '0');
 852                                 }
 853                         }
 854                 }
 855         }
 856
 857         while (!isspace((unsigned char)*cp))    /*%< if any trailing garbage */
 858                 cp++;
 859
 860         while (isspace((unsigned char)*cp))
 861                 cp++;
 862
 863  fndhemi:
 864         switch (*cp) {
 865         case 'N': case 'n':
 866         case 'E': case 'e':
 867                 retval = ((unsigned)1<<31)
 868                         + (((((deg * 60) + min) * 60) + secs) * 1000)
 869                         + secsfrac;
 870                 break;
 871         case 'S': case 's':
 872         case 'W': case 'w':
 873                 retval = ((unsigned)1<<31)
 874                         - (((((deg * 60) + min) * 60) + secs) * 1000)
 875                         - secsfrac;
 876                 break;
 877         default:
 878                 retval = 0;     /*%< invalid value -- indicates error */
 879                 break;
 880         }
 881
 882         switch (*cp) {
 883         case 'N': case 'n':
 884         case 'S': case 's':
 885                 *which = 1;     /*%< latitude */
 886                 break;
 887         case 'E': case 'e':
 888         case 'W': case 'w':
 889                 *which = 2;     /*%< longitude */
 890                 break;
 891         default:
 892                 *which = 0;     /*%< error */
 893                 break;
 894         }
 895
 896         cp++;                   /*%< skip the hemisphere */
 897         while (!isspace((unsigned char)*cp))    /*%< if any trailing garbage */
 898                 cp++;
 899
 900         while (isspace((unsigned char)*cp))     /*%< move to next field */
 901                 cp++;
 902
 903         *latlonstrptr = cp;
 904
 905         return (retval);
 906 }
 907
 908 /*%
 909  * converts a zone file representation in a string to an RDATA on-the-wire
 910  * representation. */
 911 int
 912 loc_aton(const char *ascii, u_char *binary)
 913 {
 914         const char *cp, *maxcp;
 915         u_char *bcp;
 916
 917         u_int32_t latit = 0, longit = 0, alt = 0;
 918         u_int32_t lltemp1 = 0, lltemp2 = 0;
 919         int altmeters = 0, altfrac = 0, altsign = 1;
 920         u_int8_t hp = 0x16;     /*%< default = 1e6 cm = 10000.00m = 10km */
 921         u_int8_t vp = 0x13;     /*%< default = 1e3 cm = 10.00m */
 922         u_int8_t siz = 0x12;    /*%< default = 1e2 cm = 1.00m */
 923         int which1 = 0, which2 = 0;
 924
 925         cp = ascii;
 926         maxcp = cp + strlen(ascii);
 927
 928         lltemp1 = latlon2ul(&cp, &which1);
 929
 930         lltemp2 = latlon2ul(&cp, &which2);
 931
 932         switch (which1 + which2) {
 933         case 3:                 /*%< 1 + 2, the only valid combination */
 934                 if ((which1 == 1) && (which2 == 2)) { /*%< normal case */
 935                         latit = lltemp1;
 936                         longit = lltemp2;
 937                 } else if ((which1 == 2) && (which2 == 1)) { /*%< reversed */
 938                         longit = lltemp1;
 939                         latit = lltemp2;
 940                 } else {        /*%< some kind of brokenness */
 941                         return (0);
 942                 }
 943                 break;
 944         default:                /*%< we didn't get one of each */
 945                 return (0);
 946         }
 947
 948         /* altitude */
 949         if (*cp == '-') {
 950                 altsign = -1;
 951                 cp++;
 952         }
 953
 954         if (*cp == '+')
 955                 cp++;
 956
 957         while (isdigit((unsigned char)*cp))
 958                 altmeters = altmeters * 10 + (*cp++ - '0');
 959
 960         if (*cp == '.') {               /*%< decimal meters */
 961                 cp++;
 962                 if (isdigit((unsigned char)*cp)) {
 963                         altfrac = (*cp++ - '0') * 10;
 964                         if (isdigit((unsigned char)*cp)) {
 965                                 altfrac += (*cp++ - '0');
 966                         }
 967                 }
 968         }
 969
 970         alt = (10000000 + (altsign * (altmeters * 100 + altfrac)));
 971
 972         while (!isspace((unsigned char)*cp) && (cp < maxcp)) /*%< if trailing garbage or m */
 973                 cp++;
 974
 975         while (isspace((unsigned char)*cp) && (cp < maxcp))
 976                 cp++;
 977
 978         if (cp >= maxcp)
 979                 goto defaults;
 980
 981         siz = precsize_aton(&cp);
 982
 983         while (!isspace((unsigned char)*cp) && (cp < maxcp))    /*%< if trailing garbage or m */
 984                 cp++;
 985
 986         while (isspace((unsigned char)*cp) && (cp < maxcp))
 987                 cp++;
 988
 989         if (cp >= maxcp)
 990                 goto defaults;
 991
 992         hp = precsize_aton(&cp);
 993
 994         while (!isspace((unsigned char)*cp) && (cp < maxcp))    /*%< if trailing garbage or m */
 995                 cp++;
 996
 997         while (isspace((unsigned char)*cp) && (cp < maxcp))
 998                 cp++;
 999
1000         if (cp >= maxcp)
1001                 goto defaults;
1002
1003         vp = precsize_aton(&cp);
1004
1005  defaults:
1006
1007         bcp = binary;
1008         *bcp++ = (u_int8_t) 0;  /*%< version byte */
1009         *bcp++ = siz;
1010         *bcp++ = hp;
1011         *bcp++ = vp;
1012         PUTLONG(latit,bcp);
1013         PUTLONG(longit,bcp);
1014         PUTLONG(alt,bcp);
1015
1016         return (16);            /*%< size of RR in octets */
1017 }
1018
1019 /*% takes an on-the-wire LOC RR and formats it in a human readable format. */
1020 const char *
1021 loc_ntoa(const u_char *binary, char *ascii)
1022 {
1023         static const char *error = "?";
1024         static char tmpbuf[sizeof
1025 "1000 60 60.000 N 1000 60 60.000 W -12345678.00m 90000000.00m 90000000.00m 90000000.00m"];
1026         const u_char *cp = binary;
1027
1028         int latdeg, latmin, latsec, latsecfrac;
1029         int longdeg, longmin, longsec, longsecfrac;
1030         char northsouth, eastwest;
1031         const char *altsign;
1032         int altmeters, altfrac;
1033
1034         const u_int32_t referencealt = 100000 * 100;
1035
1036         int32_t latval, longval, altval;
1037         u_int32_t templ;
1038         u_int8_t sizeval, hpval, vpval, versionval;
1039
1040         char *sizestr, *hpstr, *vpstr;
1041
1042         versionval = *cp++;
1043
1044         if (ascii == NULL)
1045                 ascii = tmpbuf;
1046
1047         if (versionval) {
1048                 (void) sprintf(ascii, "; error: unknown LOC RR version");
1049                 return (ascii);
1050         }
1051
1052         sizeval = *cp++;
1053
1054         hpval = *cp++;
1055         vpval = *cp++;
1056
1057         GETLONG(templ, cp);
1058         latval = (templ - ((unsigned)1<<31));
1059
1060         GETLONG(templ, cp);
1061         longval = (templ - ((unsigned)1<<31));
1062
1063         GETLONG(templ, cp);
1064         if (templ < referencealt) { /*%< below WGS 84 spheroid */
1065                 altval = referencealt - templ;
1066                 altsign = "-";
1067         } else {
1068                 altval = templ - referencealt;
1069                 altsign = "";
1070         }
1071
1072         if (latval < 0) {
1073                 northsouth = 'S';
1074                 latval = -latval;
1075         } else
1076                 northsouth = 'N';
1077
1078         latsecfrac = latval % 1000;
1079         latval = latval / 1000;
1080         latsec = latval % 60;
1081         latval = latval / 60;
1082         latmin = latval % 60;
1083         latval = latval / 60;
1084         latdeg = latval;
1085
1086         if (longval < 0) {
1087                 eastwest = 'W';
1088                 longval = -longval;
1089         } else
1090                 eastwest = 'E';
1091
1092         longsecfrac = longval % 1000;
1093         longval = longval / 1000;
1094         longsec = longval % 60;
1095         longval = longval / 60;
1096         longmin = longval % 60;
1097         longval = longval / 60;
1098         longdeg = longval;
1099
1100         altfrac = altval % 100;
1101         altmeters = (altval / 100);
1102
1103         sizestr = strdup(precsize_ntoa(sizeval));
1104         hpstr = strdup(precsize_ntoa(hpval));
1105         vpstr = strdup(precsize_ntoa(vpval));
1106
1107         sprintf(ascii,
1108             "%d %.2d %.2d.%.3d %c %d %.2d %.2d.%.3d %c %s%d.%.2dm %sm %sm %sm",
1109                 latdeg, latmin, latsec, latsecfrac, northsouth,
1110                 longdeg, longmin, longsec, longsecfrac, eastwest,
1111                 altsign, altmeters, altfrac,
1112                 (sizestr != NULL) ? sizestr : error,
1113                 (hpstr != NULL) ? hpstr : error,
1114                 (vpstr != NULL) ? vpstr : error);
1115
1116         if (sizestr != NULL)
1117                 free(sizestr);
1118         if (hpstr != NULL)
1119                 free(hpstr);
1120         if (vpstr != NULL)
1121                 free(vpstr);
1122
1123         return (ascii);
1124 }
1125
1126
1127 /*% Return the number of DNS hierarchy levels in the name. */
1128 int
1129 dn_count_labels(const char *name) {
1130         int i, len, count;
1131
1132         len = strlen(name);
1133         for (i = 0, count = 0; i < len; i++) {
1134                 /* XXX need to check for \. or use named's nlabels(). */
1135                 if (name[i] == '.')
1136                         count++;
1137         }
1138
1139         /* don't count initial wildcard */
1140         if (name[0] == '*')
1141                 if (count)
1142                         count--;
1143
1144         /* don't count the null label for root. */
1145         /* if terminating '.' not found, must adjust */
1146         /* count to include last label */
1147         if (len > 0 && name[len-1] != '.')
1148                 count++;
1149         return (count);
1150 }
1151
1152 /*%
1153  * Make dates expressed in seconds-since-Jan-1-1970 easy to read.
1154  * SIG records are required to be printed like this, by the Secure DNS RFC.
1155  */
1156 char *
1157 p_secstodate (u_long secs) {
1158         char *output = p_secstodate_output;
1159         time_t clock = secs;
1160         struct tm *time;
1161 #ifdef HAVE_TIME_R
1162         struct tm res;
1163
1164         time = gmtime_r(&clock, &res);
1165 #else
1166         time = gmtime(&clock);
1167 #endif
1168         time->tm_year += 1900;
1169         time->tm_mon += 1;
1170         sprintf(output, "%04d%02d%02d%02d%02d%02d",
1171                 time->tm_year, time->tm_mon, time->tm_mday,
1172                 time->tm_hour, time->tm_min, time->tm_sec);
1173         return (output);
1174 }
1175
1176 u_int16_t
1177 res_nametoclass(const char *buf, int *successp) {
1178         unsigned long result;
1179         char *endptr;
1180         int success;
1181
1182         result = sym_ston(__p_class_syms, buf, &success);
1183         if (success)
1184                 goto done;
1185
1186         if (strncasecmp(buf, "CLASS", 5) != 0 ||
1187             !isdigit((unsigned char)buf[5]))
1188                 goto done;
1189         errno = 0;
1190         result = strtoul(buf + 5, &endptr, 10);
1191         if (errno == 0 && *endptr == '\0' && result <= 0xffffU)
1192                 success = 1;
1193  done:
1194         if (successp)
1195                 *successp = success;
1196         return (result);
1197 }
1198
1199 u_int16_t
1200 res_nametotype(const char *buf, int *successp) {
1201         unsigned long result;
1202         char *endptr;
1203         int success;
1204
1205         result = sym_ston(__p_type_syms, buf, &success);
1206         if (success)
1207                 goto done;
1208
1209         if (strncasecmp(buf, "type", 4) != 0 ||
1210             !isdigit((unsigned char)buf[4]))
1211                 goto done;
1212         errno = 0;
1213         result = strtoul(buf + 4, &endptr, 10);
1214         if (errno == 0 && *endptr == '\0' && result <= 0xffffU)
1215                 success = 1;
1216  done:
1217         if (successp)
1218                 *successp = success;
1219         return (result);
1220 }
1221
1222 /*
1223  * Weak aliases for applications that use certain private entry points,
1224  * and fail to include <resolv.h>.
1225  */
1226 #undef fp_resstat
1227 __weak_reference(__fp_resstat, fp_resstat);
1228 #undef p_fqnname
1229 __weak_reference(__p_fqnname, p_fqnname);
1230 #undef sym_ston
1231 __weak_reference(__sym_ston, sym_ston);
1232 #undef sym_ntos
1233 __weak_reference(__sym_ntos, sym_ntos);
1234 #undef sym_ntop
1235 __weak_reference(__sym_ntop, sym_ntop);
1236 #undef dn_count_labels
1237 __weak_reference(__dn_count_labels, dn_count_labels);
1238 #undef p_secstodate
1239 __weak_reference(__p_secstodate, p_secstodate);
1240
1241 /*! \file */