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