[BACK]Return to res_debug.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libc / resolv

Annotation of src/lib/libc/resolv/res_debug.c, Revision 1.14.16.1

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

CVSweb <webmaster@jp.NetBSD.org>