[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.10.14.1

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

CVSweb <webmaster@jp.NetBSD.org>