resolv/res_debug.c

   1 /*
   2  * ++Copyright++ 1985, 1990, 1993
   3  * -
   4  * Copyright (c) 1985, 1990, 1993
   5  *    The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  * -
  35  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
  36  *
  37  * Permission to use, copy, modify, and distribute this software for any
  38  * purpose with or without fee is hereby granted, provided that the above
  39  * copyright notice and this permission notice appear in all copies, and that
  40  * the name of Digital Equipment Corporation not be used in advertising or
  41  * publicity pertaining to distribution of the document or software without
  42  * specific, written prior permission.
  43  *
  44  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  45  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  46  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  47  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  48  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  49  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  50  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  51  * SOFTWARE.
  52  * -
  53  * Portions Copyright (c) 1995 by International Business Machines, Inc.
  54  *
  55  * International Business Machines, Inc. (hereinafter called IBM) grants
  56  * permission under its copyrights to use, copy, modify, and distribute this
  57  * Software with or without fee, provided that the above copyright notice and
  58  * all paragraphs of this notice appear in all copies, and that the name of IBM
  59  * not be used in connection with the marketing of any product incorporating
  60  * the Software or modifications thereof, without specific, written prior
  61  * permission.
  62  *
  63  * To the extent it has a right to do so, IBM grants an immunity from suit
  64  * under its patents, if any, for the use, sale or manufacture of products to
  65  * the extent that such products are used for performing Domain Name System
  66  * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
  67  * granted for any product per se or for any other function of any product.
  68  *
  69  * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
  70  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  71  * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
  72  * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
  73  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
  74  * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
  75  * --Copyright--
  76  */
  77
  78 #if defined(LIBC_SCCS) && !defined(lint)
  79 static char sccsid[] = "@(#)res_debug.c 8.1 (Berkeley) 6/4/93";
  80 static char rcsid[] = "$Id$";
  81 #endif /* LIBC_SCCS and not lint */
  82
  83 #include <sys/param.h>
  84 #include <sys/types.h>
  85 #include <sys/socket.h>
  86 #include <netinet/in.h>
  87 #include <arpa/inet.h>
  88 #include <arpa/nameser.h>
  89
  90 #include <ctype.h>
  91 #include <netdb.h>
  92 #include <resolv.h>
  93 #include <stdio.h>
  94 #include <time.h>
  95
  96 #if defined(BSD) && (BSD >= 199103) && defined(AF_INET6)
  97 # include <stdlib.h>
  98 # include <string.h>
  99 #else
 100 # include "../conf/portability.h"
 101 #endif
 102
 103 #if defined(USE_OPTIONS_H)
 104 # include "../conf/options.h"
 105 #endif
 106
 107 extern const char *_res_opcodes[];
 108 extern const char *_res_resultcodes[];
 109
 110 /* XXX: we should use getservbyport() instead. */
 111 static const char *
 112 dewks(wks)
 113         int wks;
 114 {
 115         static char nbuf[20];
 116
 117         switch (wks) {
 118         case 5: return "rje";
 119         case 7: return "echo";
 120         case 9: return "discard";
 121         case 11: return "systat";
 122         case 13: return "daytime";
 123         case 15: return "netstat";
 124         case 17: return "qotd";
 125         case 19: return "chargen";
 126         case 20: return "ftp-data";
 127         case 21: return "ftp";
 128         case 23: return "telnet";
 129         case 25: return "smtp";
 130         case 37: return "time";
 131         case 39: return "rlp";
 132         case 42: return "name";
 133         case 43: return "whois";
 134         case 53: return "domain";
 135         case 57: return "apts";
 136         case 59: return "apfs";
 137         case 67: return "bootps";
 138         case 68: return "bootpc";
 139         case 69: return "tftp";
 140         case 77: return "rje";
 141         case 79: return "finger";
 142         case 87: return "link";
 143         case 95: return "supdup";
 144         case 100: return "newacct";
 145         case 101: return "hostnames";
 146         case 102: return "iso-tsap";
 147         case 103: return "x400";
 148         case 104: return "x400-snd";
 149         case 105: return "csnet-ns";
 150         case 109: return "pop-2";
 151         case 111: return "sunrpc";
 152         case 113: return "auth";
 153         case 115: return "sftp";
 154         case 117: return "uucp-path";
 155         case 119: return "nntp";
 156         case 121: return "erpc";
 157         case 123: return "ntp";
 158         case 133: return "statsrv";
 159         case 136: return "profile";
 160         case 144: return "NeWS";
 161         case 161: return "snmp";
 162         case 162: return "snmp-trap";
 163         case 170: return "print-srv";
 164         default: (void) sprintf(nbuf, "%d", wks); return (nbuf);
 165         }
 166 }
 167
 168 /* XXX: we should use getprotobynumber() instead. */
 169 static const char *
 170 deproto(protonum)
 171         int protonum;
 172 {
 173         static char nbuf[20];
 174
 175         switch (protonum) {
 176         case 1: return "icmp";
 177         case 2: return "igmp";
 178         case 3: return "ggp";
 179         case 5: return "st";
 180         case 6: return "tcp";
 181         case 7: return "ucl";
 182         case 8: return "egp";
 183         case 9: return "igp";
 184         case 11: return "nvp-II";
 185         case 12: return "pup";
 186         case 16: return "chaos";
 187         case 17: return "udp";
 188         default: (void) sprintf(nbuf, "%d", protonum); return (nbuf);
 189         }
 190 }
 191
 192 static const u_char *
 193 do_rrset(msg, len, cp, cnt, pflag, file, hs)
 194         int cnt, pflag, len;
 195         const u_char *cp, *msg;
 196         const char *hs;
 197         FILE *file;
 198 {
 199         int n;
 200         int sflag;
 201
 202         /*
 203          * Print answer records.
 204          */
 205         sflag = (_res.pfcode & pflag);
 206         if (n = ntohs(cnt)) {
 207                 if ((!_res.pfcode) ||
 208                     ((sflag) && (_res.pfcode & RES_PRF_HEAD1)))
 209                         fprintf(file, hs);
 210                 while (--n >= 0) {
 211                         if ((!_res.pfcode) || sflag) {
 212                                 cp = p_rr(cp, msg, file);
 213                         } else {
 214                                 unsigned int dlen;
 215                                 cp += __dn_skipname(cp, cp + MAXCDNAME);
 216                                 cp += INT16SZ;
 217                                 cp += INT16SZ;
 218                                 cp += INT32SZ;
 219                                 dlen = _getshort((u_char*)cp);
 220                                 cp += INT16SZ;
 221                                 cp += dlen;
 222                         }
 223                         if ((cp - msg) > len)
 224                                 return (NULL);
 225                 }
 226                 if ((!_res.pfcode) ||
 227                     ((sflag) && (_res.pfcode & RES_PRF_HEAD1)))
 228                         putc('\n', file);
 229         }
 230         return (cp);
 231 }
 232
 233 void
 234 __p_query(msg)
 235         const u_char *msg;
 236 {
 237         __fp_query(msg, stdout);
 238 }
 239
 240 #ifdef ultrix
 241 #undef p_query
 242 /* ultrix 4.0's packaging has some icky packaging.  alias for it here.
 243  * there is more junk of this kind over in res_comp.c.
 244  */
 245 void
 246 p_query(msg)
 247         const u_char *msg;
 248 {
 249         __p_query(msg);
 250 }
 251 #endif
 252
 253 /*
 254  * Print the current options.
 255  * This is intended to be primarily a debugging routine.
 256  */
 257 void
 258 __fp_resstat(statp, file)
 259         struct __res_state *statp;
 260         FILE *file;
 261 {
 262         register u_long mask;
 263
 264         fprintf(file, ";; res options:");
 265         if (!statp)
 266                 statp = &_res;
 267         for (mask = 1;  mask != 0;  mask <<= 1)
 268                 if (statp->options & mask)
 269                         fprintf(file, " %s", p_option(mask));
 270         putc('\n', file);
 271 }
 272
 273 /*
 274  * Print the contents of a query.
 275  * This is intended to be primarily a debugging routine.
 276  */
 277 void
 278 __fp_nquery(msg, len, file)
 279         const u_char *msg;
 280         int len;
 281         FILE *file;
 282 {
 283         register const u_char *cp, *endMark;
 284         register const HEADER *hp;
 285         register int n;
 286
 287         if ((_res.options & RES_INIT) == 0 && res_init() == -1)
 288                 return;
 289
 290 #define TruncTest(x) if (x > endMark) goto trunc
 291 #define ErrorTest(x) if (x == NULL) goto error
 292
 293         /*
 294          * Print header fields.
 295          */
 296         hp = (HEADER *)msg;
 297         cp = msg + HFIXEDSZ;
 298         endMark = msg + len;
 299         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEADX) || hp->rcode) {
 300                 fprintf(file, ";; ->>HEADER<<- opcode: %s, status: %s, id: %d",
 301                         _res_opcodes[hp->opcode],
 302                         _res_resultcodes[hp->rcode],
 303                         ntohs(hp->id));
 304                 putc('\n', file);
 305         }
 306         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEADX))
 307                 putc(';', file);
 308         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD2)) {
 309                 fprintf(file, "; flags:");
 310                 if (hp->qr)
 311                         fprintf(file, " qr");
 312                 if (hp->aa)
 313                         fprintf(file, " aa");
 314                 if (hp->tc)
 315                         fprintf(file, " tc");
 316                 if (hp->rd)
 317                         fprintf(file, " rd");
 318                 if (hp->ra)
 319                         fprintf(file, " ra");
 320                 if (hp->unused)
 321                         fprintf(file, " UNUSED-BIT-ON");
 322                 if (hp->ad)
 323                         fprintf(file, " ad");
 324                 if (hp->cd)
 325                         fprintf(file, " cd");
 326         }
 327         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD1)) {
 328                 fprintf(file, "; Ques: %d", ntohs(hp->qdcount));
 329                 fprintf(file, ", Ans: %d", ntohs(hp->ancount));
 330                 fprintf(file, ", Auth: %d", ntohs(hp->nscount));
 331                 fprintf(file, ", Addit: %d", ntohs(hp->arcount));
 332         }
 333         if ((!_res.pfcode) || (_res.pfcode &
 334                 (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1))) {
 335                 putc('\n',file);
 336         }
 337         /*
 338          * Print question records.
 339          */
 340         if (n = ntohs(hp->qdcount)) {
 341                 if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
 342                         fprintf(file, ";; QUESTIONS:\n");
 343                 while (--n >= 0) {
 344                         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
 345                                 fprintf(file, ";;\t");
 346                         TruncTest(cp);
 347                         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
 348                                 cp = p_cdnname(cp, msg, len, file);
 349                         else {
 350                                 int n;
 351                                 char name[MAXDNAME];
 352
 353                                 if ((n = dn_expand(msg, msg+len, cp, name,
 354                                                 sizeof name)) < 0)
 355                                         cp = NULL;
 356                                 else
 357                                         cp += n;
 358                         }
 359                         ErrorTest(cp);
 360                         TruncTest(cp);
 361                         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
 362                                 fprintf(file, ", type = %s",
 363                                         __p_type(_getshort((u_char*)cp)));
 364                         cp += INT16SZ;
 365                         TruncTest(cp);
 366                         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
 367                                 fprintf(file, ", class = %s\n",
 368                                         __p_class(_getshort((u_char*)cp)));
 369                         cp += INT16SZ;
 370                         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES))
 371                                 putc('\n', file);
 372                 }
 373         }
 374         /*
 375          * Print authoritative answer records
 376          */
 377         TruncTest(cp);
 378         cp = do_rrset(msg, len, cp, hp->ancount, RES_PRF_ANS, file,
 379                       ";; ANSWERS:\n");
 380         ErrorTest(cp);
 381
 382         /*
 383          * print name server records
 384          */
 385         TruncTest(cp);
 386         cp = do_rrset(msg, len, cp, hp->nscount, RES_PRF_AUTH, file,
 387                       ";; AUTHORITY RECORDS:\n");
 388         ErrorTest(cp);
 389
 390         TruncTest(cp);
 391         /*
 392          * print additional records
 393          */
 394         cp = do_rrset(msg, len, cp, hp->arcount, RES_PRF_ADD, file,
 395                       ";; ADDITIONAL RECORDS:\n");
 396         ErrorTest(cp);
 397         return;
 398  trunc:
 399         fprintf(file, "\n;; ...truncated\n");
 400         return;
 401  error:
 402         fprintf(file, "\n;; ...malformed\n");
 403 }
 404
 405 void
 406 __fp_query(msg, file)
 407         const u_char *msg;
 408         FILE *file;
 409 {
 410         fp_nquery(msg, PACKETSZ, file);
 411 }
 412
 413 const u_char *
 414 __p_cdnname(cp, msg, len, file)
 415         const u_char *cp, *msg;
 416         int len;
 417         FILE *file;
 418 {
 419         char name[MAXDNAME];
 420         int n;
 421
 422         if ((n = dn_expand(msg, msg + len, cp, name, sizeof name)) < 0)
 423                 return (NULL);
 424         if (name[0] == '\0')
 425                 putc('.', file);
 426         else
 427                 fputs(name, file);
 428         return (cp + n);
 429 }
 430
 431 const u_char *
 432 __p_cdname(cp, msg, file)
 433         const u_char *cp, *msg;
 434         FILE *file;
 435 {
 436         return (p_cdnname(cp, msg, PACKETSZ, file));
 437 }
 438
 439
 440 /* Return a fully-qualified domain name from a compressed name (with
 441    length supplied).  */
 442
 443 const u_char *
 444 __p_fqnname(cp, msg, msglen, name, namelen)
 445         const u_char *cp, *msg;
 446         int msglen;
 447         char *name;
 448         int namelen;
 449 {
 450         int n, newlen;
 451
 452         if ((n = dn_expand(msg, cp + msglen, cp, name, namelen)) < 0)
 453                 return (NULL);
 454         newlen = strlen (name);
 455         if (newlen == 0 || name[newlen - 1] != '.')
 456                 if (newlen+1 >= namelen)        /* Lack space for final dot */
 457                         return (NULL);
 458                 else
 459                         strcpy(name + newlen, ".");
 460         return (cp + n);
 461 }
 462
 463 /* XXX: the rest of these functions need to become length-limited, too. (vix)
 464  */
 465
 466 const u_char *
 467 __p_fqname(cp, msg, file)
 468         const u_char *cp, *msg;
 469         FILE *file;
 470 {
 471         char name[MAXDNAME];
 472         const u_char *n;
 473
 474         n = __p_fqnname(cp, msg, MAXCDNAME, name, sizeof name);
 475         if (n == NULL)
 476                 return (NULL);
 477         fputs(name, file);
 478         return (n);
 479 }
 480
 481 /*
 482  * Print resource record fields in human readable form.
 483  */
 484 const u_char *
 485 __p_rr(cp, msg, file)
 486         const u_char *cp, *msg;
 487         FILE *file;
 488 {
 489         int type, class, dlen, n, c;
 490         struct in_addr inaddr;
 491         const u_char *cp1, *cp2;
 492         u_int32_t tmpttl, t;
 493         int lcnt;
 494         u_int16_t keyflags;
 495         char rrname[MAXDNAME];          /* The fqdn of this RR */
 496         char base64_key[MAX_KEY_BASE64];
 497
 498         if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
 499                 __set_h_errno (NETDB_INTERNAL);
 500                 return (NULL);
 501         }
 502         cp = __p_fqnname(cp, msg, MAXCDNAME, rrname, sizeof rrname);
 503         if (!cp)
 504                 return (NULL);                  /* compression error */
 505         fputs(rrname, file);
 506
 507         type = _getshort((u_char*)cp);
 508         cp += INT16SZ;
 509         class = _getshort((u_char*)cp);
 510         cp += INT16SZ;
 511         tmpttl = _getlong((u_char*)cp);
 512         cp += INT32SZ;
 513         dlen = _getshort((u_char*)cp);
 514         cp += INT16SZ;
 515         cp1 = cp;
 516         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_TTLID))
 517                 fprintf(file, "\t%lu", (u_long)tmpttl);
 518         if ((!_res.pfcode) || (_res.pfcode & RES_PRF_CLASS))
 519                 fprintf(file, "\t%s", __p_class(class));
 520         fprintf(file, "\t%s", __p_type(type));
 521         /*
 522          * Print type specific data, if appropriate
 523          */
 524         switch (type) {
 525         case T_A:
 526                 switch (class) {
 527                 case C_IN:
 528                 case C_HS:
 529                         bcopy(cp, (char *)&inaddr, INADDRSZ);
 530                         if (dlen == 4) {
 531                                 fprintf(file, "\t%s", inet_ntoa(inaddr));
 532                                 cp += dlen;
 533                         } else if (dlen == 7) {
 534                                 char *address;
 535                                 u_char protocol;
 536                                 u_short port;
 537
 538                                 address = inet_ntoa(inaddr);
 539                                 cp += INADDRSZ;
 540                                 protocol = *(u_char*)cp;
 541                                 cp += sizeof (u_char);
 542                                 port = _getshort((u_char*)cp);
 543                                 cp += INT16SZ;
 544                                 fprintf(file, "\t%s\t; proto %d, port %d",
 545                                         address, protocol, port);
 546                         }
 547                         break;
 548                 default:
 549                         cp += dlen;
 550                 }
 551                 break;
 552         case T_CNAME:
 553         case T_MB:
 554         case T_MG:
 555         case T_MR:
 556         case T_NS:
 557         case T_PTR:
 558                 putc('\t', file);
 559                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 560                         return (NULL);
 561                 break;
 562
 563         case T_HINFO:
 564         case T_ISDN:
 565                 cp2 = cp + dlen;
 566                 (void) fputs("\t\"", file);
 567                 if ((n = (unsigned char) *cp++) != 0) {
 568                         for (c = n; c > 0 && cp < cp2; c--) {
 569                                 if (strchr("\n\"\\", *cp))
 570                                         (void) putc('\\', file);
 571                                 (void) putc(*cp++, file);
 572                         }
 573                 }
 574                 putc('"', file);
 575                 if (cp < cp2 && (n = (unsigned char) *cp++) != 0) {
 576                         (void) fputs ("\t\"", file);
 577                         for (c = n; c > 0 && cp < cp2; c--) {
 578                                 if (strchr("\n\"\\", *cp))
 579                                         (void) putc('\\', file);
 580                                 (void) putc(*cp++, file);
 581                         }
 582                         putc('"', file);
 583                 } else if (type == T_HINFO) {
 584                         (void) fputs("\"?\"", file);
 585                         fprintf(file, "\n;; *** Warning *** OS-type missing");
 586                 }
 587                 break;
 588
 589         case T_SOA:
 590                 putc('\t', file);
 591                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 592                         return (NULL);
 593                 putc(' ', file);
 594                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 595                         return (NULL);
 596                 fputs(" (\n", file);
 597                 t = _getlong((u_char*)cp);  cp += INT32SZ;
 598                 fprintf(file, "\t\t\t%lu\t; serial\n", (u_long)t);
 599                 t = _getlong((u_char*)cp);  cp += INT32SZ;
 600                 fprintf(file, "\t\t\t%lu\t; refresh (%s)\n",
 601                         (u_long)t, __p_time(t));
 602                 t = _getlong((u_char*)cp);  cp += INT32SZ;
 603                 fprintf(file, "\t\t\t%lu\t; retry (%s)\n",
 604                         (u_long)t, __p_time(t));
 605                 t = _getlong((u_char*)cp);  cp += INT32SZ;
 606                 fprintf(file, "\t\t\t%lu\t; expire (%s)\n",
 607                         (u_long)t, __p_time(t));
 608                 t = _getlong((u_char*)cp);  cp += INT32SZ;
 609                 fprintf(file, "\t\t\t%lu )\t; minimum (%s)",
 610                         (u_long)t, __p_time(t));
 611                 break;
 612
 613         case T_MX:
 614         case T_AFSDB:
 615         case T_RT:
 616                 fprintf(file, "\t%d ", _getshort((u_char*)cp));
 617                 cp += INT16SZ;
 618                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 619                         return (NULL);
 620                 break;
 621
 622         case T_PX:
 623                 fprintf(file, "\t%d ", _getshort((u_char*)cp));
 624                 cp += INT16SZ;
 625                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 626                         return (NULL);
 627                 putc(' ', file);
 628                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 629                         return (NULL);
 630                 break;
 631
 632         case T_X25:
 633                 cp2 = cp + dlen;
 634                 (void) fputs("\t\"", file);
 635                 if ((n = (unsigned char) *cp++) != 0) {
 636                         for (c = n; c > 0 && cp < cp2; c--) {
 637                                 if (strchr("\n\"\\", *cp))
 638                                         (void) putc('\\', file);
 639                                 (void) putc(*cp++, file);
 640                         }
 641                 }
 642                 putc('"', file);
 643                 break;
 644
 645         case T_TXT:
 646                 (void) putc('\t', file);
 647                 cp2 = cp1 + dlen;
 648                 while (cp < cp2) {
 649                         putc('"', file);
 650                         if (n = (unsigned char) *cp++) {
 651                                 for (c = n; c > 0 && cp < cp2; c--) {
 652                                         if (strchr("\n\"\\", *cp))
 653                                                 (void) putc('\\', file);
 654                                         (void) putc(*cp++, file);
 655                                 }
 656                         }
 657                         putc('"', file);
 658                         if (cp < cp2)
 659                                 putc(' ', file);
 660                 }
 661                 break;
 662
 663         case T_NSAP:
 664                 (void) fprintf(file, "\t%s", inet_nsap_ntoa(dlen, cp, NULL));
 665                 cp += dlen;
 666                 break;
 667
 668         case T_AAAA: {
 669                 char t[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"];
 670
 671                 fprintf(file, "\t%s", inet_ntop(AF_INET6, cp, t, sizeof t));
 672                 cp += dlen;
 673                 break;
 674             }
 675
 676         case T_LOC: {
 677                 char t[255];
 678
 679                 (void) fprintf(file, "\t%s", loc_ntoa(cp, t));
 680                 cp += dlen;
 681                 break;
 682             }
 683
 684         case T_NAPTR: {
 685                 u_int order, preference;
 686
 687                 order = _getshort(cp);  cp += INT16SZ;
 688                 preference   = _getshort(cp);  cp += INT16SZ;
 689                 fprintf(file, "\t%u %u ",order, preference);
 690                 /* Flags */
 691                 n = *cp++;
 692                 fprintf(file,"\"%.*s\" ", (int)n, cp);
 693                 cp += n;
 694                 /* Service */
 695                 n = *cp++;
 696                 fprintf(file,"\"%.*s\" ", (int)n, cp);
 697                 cp += n;
 698                 /* Regexp */
 699                 n = *cp++;
 700                 fprintf(file,"\"%.*s\" ", (int)n, cp);
 701                 cp += n;
 702                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 703                         return (NULL);
 704                 break;
 705             }
 706
 707         case T_SRV: {
 708                 u_int priority, weight, port;
 709
 710                 priority = _getshort(cp);  cp += INT16SZ;
 711                 weight   = _getshort(cp);  cp += INT16SZ;
 712                 port     = _getshort(cp);  cp += INT16SZ;
 713                 fprintf(file, "\t%u %u %u ", priority, weight, port);
 714                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 715                         return (NULL);
 716                 break;
 717             }
 718
 719         case T_MINFO:
 720         case T_RP:
 721                 putc('\t', file);
 722                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 723                         return (NULL);
 724                 putc(' ', file);
 725                 if ((cp = p_fqname(cp, msg, file)) == NULL)
 726                         return (NULL);
 727                 break;
 728
 729         case T_UINFO:
 730                 putc('\t', file);
 731                 fputs((char *)cp, file);
 732                 cp += dlen;
 733                 break;
 734
 735         case T_UID:
 736         case T_GID:
 737                 if (dlen == 4) {
 738                         fprintf(file, "\t%u", _getlong((u_char*)cp));
 739                         cp += INT32SZ;
 740                 }
 741                 break;
 742
 743         case T_WKS:
 744                 if (dlen < INT32SZ + 1)
 745                         break;
 746                 bcopy(cp, (char *)&inaddr, INADDRSZ);
 747                 cp += INT32SZ;
 748                 fprintf(file, "\t%s %s ( ",
 749                         inet_ntoa(inaddr),
 750                         deproto((int) *cp));
 751                 cp += sizeof (u_char);
 752                 n = 0;
 753                 lcnt = 0;
 754                 while (cp < cp1 + dlen) {
 755                         c = *cp++;
 756                         do {
 757                                 if (c & 0200) {
 758                                         if (lcnt == 0) {
 759                                                 fputs("\n\t\t\t", file);
 760                                                 lcnt = 5;
 761                                         }
 762                                         fputs(dewks(n), file);
 763                                         putc(' ', file);
 764                                         lcnt--;
 765                                 }
 766                                 c <<= 1;
 767                         } while (++n & 07);
 768                 }
 769                 putc(')', file);
 770                 break;
 771
 772         case T_KEY:
 773                 putc('\t', file);
 774                 keyflags = _getshort(cp);
 775                 cp += 2;
 776                 fprintf(file,"0x%04x", keyflags );      /* flags */
 777                 fprintf(file," %u", *cp++);     /* protocol */
 778                 fprintf(file," %u (", *cp++);   /* algorithm */
 779
 780                 n = b64_ntop(cp, (cp1 + dlen) - cp,
 781                              base64_key, sizeof base64_key);
 782                 for (c = 0; c < n; ++c) {
 783                         if (0 == (c & 0x3F))
 784                                 fprintf(file, "\n\t");
 785                         putc(base64_key[c], file);  /* public key data */
 786                 }
 787
 788                 fprintf(file, " )");
 789                 if (n < 0)
 790                         fprintf(file, "\t; BAD BASE64");
 791                 fflush(file);
 792                 cp = cp1 + dlen;
 793                 break;
 794
 795         case T_SIG:
 796                 type = _getshort((u_char*)cp);
 797                 cp += INT16SZ;
 798                 fprintf(file, " %s", p_type(type));
 799                 fprintf(file, "\t%d", *cp++);   /* algorithm */
 800                 /* Check label value and print error if wrong. */
 801                 n = *cp++;
 802                 c = dn_count_labels (rrname);
 803                 if (n != c)
 804                         fprintf(file, "\t; LABELS WRONG (%d should be %d)\n\t",
 805                                 n, c);
 806                 /* orig ttl */
 807                 n = _getlong((u_char*)cp);
 808                 if (n != tmpttl)
 809                         fprintf(file, " %u", n);
 810                 cp += INT32SZ;
 811                 /* sig expire */
 812                 fprintf(file, " (\n\t%s",
 813                         __p_secstodate(_getlong((u_char*)cp)));
 814                 cp += INT32SZ;
 815                 /* time signed */
 816                 fprintf(file, " %s", __p_secstodate(_getlong((u_char*)cp)));
 817                 cp += INT32SZ;
 818                 /* sig footprint */
 819                 fprintf(file," %u ", _getshort((u_char*)cp));
 820                 cp += INT16SZ;
 821                 /* signer's name */
 822                 cp = p_fqname(cp, msg, file);
 823                 n = b64_ntop(cp, (cp1 + dlen) - cp,
 824                              base64_key, sizeof base64_key);
 825                 for (c = 0; c < n; c++) {
 826                         if (0 == (c & 0x3F))
 827                                 fprintf (file, "\n\t");
 828                         putc(base64_key[c], file);              /* signature */
 829                 }
 830                 /* Clean up... */
 831                 fprintf(file, " )");
 832                 if (n < 0)
 833                         fprintf(file, "\t; BAD BASE64");
 834                 fflush(file);
 835                 cp = cp1+dlen;
 836                 break;
 837
 838 #ifdef ALLOW_T_UNSPEC
 839         case T_UNSPEC:
 840                 {
 841                         int NumBytes = 8;
 842                         u_char *DataPtr;
 843                         int i;
 844
 845                         if (dlen < NumBytes) NumBytes = dlen;
 846                         fprintf(file, "\tFirst %d bytes of hex data:",
 847                                 NumBytes);
 848                         for (i = 0, DataPtr = cp; i < NumBytes; i++, DataPtr++)
 849                                 fprintf(file, " %x", *DataPtr);
 850                         cp += dlen;
 851                 }
 852                 break;
 853 #endif /* ALLOW_T_UNSPEC */
 854
 855         default:
 856                 fprintf(file, "\t?%d?", type);
 857                 cp += dlen;
 858         }
 859 #if 0
 860         fprintf(file, "\t; dlen=%d, ttl %s\n", dlen, __p_time(tmpttl));
 861 #else
 862         putc('\n', file);
 863 #endif
 864         if (cp - cp1 != dlen) {
 865                 fprintf(file,
 866                         ";; packet size error (found %lu, dlen was %d)\n",
 867                         (unsigned long) (cp - cp1), dlen);
 868                 cp = NULL;
 869         }
 870         return (cp);
 871 }
 872
 873 /*
 874  * Names of RR classes and qclasses.  Classes and qclasses are the same, except
 875  * that C_ANY is a qclass but not a class.  (You can ask for records of class
 876  * C_ANY, but you can't have any records of that class in the database.)
 877  */
 878 const struct res_sym __p_class_syms[] = {
 879         {C_IN,          "IN"},
 880         {C_CHAOS,       "CHAOS"},
 881         {C_HS,          "HS"},
 882         {C_HS,          "HESIOD"},
 883         {C_ANY,         "ANY"},
 884         {C_IN,          (char *)0}
 885 };
 886
 887 /*
 888  * Names of RR types and qtypes.  Types and qtypes are the same, except
 889  * that T_ANY is a qtype but not a type.  (You can ask for records of type
 890  * T_ANY, but you can't have any records of that type in the database.)
 891  */
 892 const struct res_sym __p_type_syms[] = {
 893         {T_A,           "A",            "address"},
 894         {T_NS,          "NS",           "name server"},
 895         {T_MD,          "MD",           "mail destination (deprecated)"},
 896         {T_MF,          "MF",           "mail forwarder (deprecated)"},
 897         {T_CNAME,       "CNAME",        "canonical name"},
 898         {T_SOA,         "SOA",          "start of authority"},
 899         {T_MB,          "MB",           "mailbox"},
 900         {T_MG,          "MG",           "mail group member"},
 901         {T_MR,          "MR",           "mail rename"},
 902         {T_NULL,        "NULL",         "null"},
 903         {T_WKS,         "WKS",          "well-known service (deprecated)"},
 904         {T_PTR,         "PTR",          "domain name pointer"},
 905         {T_HINFO,       "HINFO",        "host information"},
 906         {T_MINFO,       "MINFO",        "mailbox information"},
 907         {T_MX,          "MX",           "mail exchanger"},
 908         {T_TXT,         "TXT",          "text"},
 909         {T_RP,          "RP",           "responsible person"},
 910         {T_AFSDB,       "AFSDB",        "DCE or AFS server"},
 911         {T_X25,         "X25",          "X25 address"},
 912         {T_ISDN,        "ISDN",         "ISDN address"},
 913         {T_RT,          "RT",           "router"},
 914         {T_NSAP,        "NSAP",         "nsap address"},
 915         {T_NSAP_PTR,    "NSAP_PTR",     "domain name pointer"},
 916         {T_SIG,         "SIG",          "signature"},
 917         {T_KEY,         "KEY",          "key"},
 918         {T_PX,          "PX",           "mapping information"},
 919         {T_GPOS,        "GPOS",         "geographical position (withdrawn)"},
 920         {T_AAAA,        "AAAA",         "IPv6 address"},
 921         {T_LOC,         "LOC",          "location"},
 922         {T_NXT,         "NXT",          "next valid name (unimplemented)"},
 923         {T_EID,         "EID",          "endpoint identifier (unimplemented)"},
 924         {T_NIMLOC,      "NIMLOC",       "NIMROD locator (unimplemented)"},
 925         {T_SRV,         "SRV",          "server selection"},
 926         {T_ATMA,        "ATMA",         "ATM address (unimplemented)"},
 927         {T_IXFR,        "IXFR",         "incremental zone transfer"},
 928         {T_AXFR,        "AXFR",         "zone transfer"},
 929         {T_MAILB,       "MAILB",        "mailbox-related data (deprecated)"},
 930         {T_MAILA,       "MAILA",        "mail agent (deprecated)"},
 931         {T_UINFO,       "UINFO",        "user information (nonstandard)"},
 932         {T_UID,         "UID",          "user ID (nonstandard)"},
 933         {T_GID,         "GID",          "group ID (nonstandard)"},
 934         {T_NAPTR,       "NAPTR",        "URN Naming Authority"},
 935 #ifdef ALLOW_T_UNSPEC
 936         {T_UNSPEC,      "UNSPEC",       "unspecified data (nonstandard)"},
 937 #endif /* ALLOW_T_UNSPEC */
 938         {T_ANY,         "ANY",          "\"any\""},
 939         {0,             NULL,           NULL}
 940 };
 941
 942 int
 943 __sym_ston(syms, name, success)
 944         const struct res_sym *syms;
 945         char *name;
 946         int *success;
 947 {
 948 #ifdef _LIBC
 949         /* Changed to prevent warning. --drepper@gnu  */
 950         for (; syms->name != 0; syms++) {
 951 #else
 952         for (NULL; syms->name != 0; syms++) {
 953 #endif
 954                 if (strcasecmp (name, syms->name) == 0) {
 955                         if (success)
 956                                 *success = 1;
 957                         return (syms->number);
 958                 }
 959         }
 960         if (success)
 961                 *success = 0;
 962         return (syms->number);          /* The default value. */
 963 }
 964
 965 const char *
 966 __sym_ntos(syms, number, success)
 967         const struct res_sym *syms;
 968         int number;
 969         int *success;
 970 {
 971         static char unname[20];
 972
 973 #ifdef _LIBC
 974         /* Changed to prevent warning. --drepper@gnu  */
 975         for (; syms->name != 0; syms++) {
 976 #else
 977         for (NULL; syms->name != 0; syms++) {
 978 #endif
 979                 if (number == syms->number) {
 980                         if (success)
 981                                 *success = 1;
 982                         return (syms->name);
 983                 }
 984         }
 985
 986         sprintf (unname, "%d", number);
 987         if (success)
 988                 *success = 0;
 989         return (unname);
 990 }
 991
 992
 993 const char *
 994 __sym_ntop(syms, number, success)
 995         const struct res_sym *syms;
 996         int number;
 997         int *success;
 998 {
 999         static char unname[20];
1000
1001 #ifdef _LIBC
1002         /* Changed to prevent warning. --drepper@gnu  */
1003         for (; syms->name != 0; syms++) {
1004 #else
1005         for (NULL; syms->name != 0; syms++) {
1006 #endif
1007                 if (number == syms->number) {
1008                         if (success)
1009                                 *success = 1;
1010                         return (syms->humanname);
1011                 }
1012         }
1013         sprintf(unname, "%d", number);
1014         if (success)
1015                 *success = 0;
1016         return (unname);
1017 }
1018
1019 /*
1020  * Return a string for the type
1021  */
1022 const char *
1023 __p_type(type)
1024         int type;
1025 {
1026         return (__sym_ntos (__p_type_syms, type, (int *)0));
1027 }
1028
1029 /*
1030  * Return a mnemonic for class
1031  */
1032 const char *
1033 __p_class(class)
1034         int class;
1035 {
1036         return (__sym_ntos (__p_class_syms, class, (int *)0));
1037 }
1038
1039 /*
1040  * Return a mnemonic for an option
1041  */
1042 const char *
1043 __p_option(option)
1044         u_long option;
1045 {
1046         static char nbuf[40];
1047
1048         switch (option) {
1049         case RES_INIT:          return "init";
1050         case RES_DEBUG:         return "debug";
1051         case RES_AAONLY:        return "aaonly(unimpl)";
1052         case RES_USEVC:         return "usevc";
1053         case RES_PRIMARY:       return "primry(unimpl)";
1054         case RES_IGNTC:         return "igntc";
1055         case RES_RECURSE:       return "recurs";
1056         case RES_DEFNAMES:      return "defnam";
1057         case RES_STAYOPEN:      return "styopn";
1058         case RES_DNSRCH:        return "dnsrch";
1059         case RES_INSECURE1:     return "insecure1";
1060         case RES_INSECURE2:     return "insecure2";
1061         default:                sprintf(nbuf, "?0x%lx?", (u_long)option);
1062                                 return (nbuf);
1063         }
1064 }
1065
1066 /*
1067  * Return a mnemonic for a time to live
1068  */
1069 const char *
1070 p_time(value)
1071         u_int32_t value;
1072 {
1073         static char nbuf[60];
1074         int secs, mins, hours, days;
1075         register char *p;
1076
1077         if (value == 0) {
1078                 strcpy(nbuf, "0 secs");
1079                 return (nbuf);
1080         }
1081
1082         secs = value % 60;
1083         value /= 60;
1084         mins = value % 60;
1085         value /= 60;
1086         hours = value % 24;
1087         value /= 24;
1088         days = value;
1089         value = 0;
1090
1091 #define PLURALIZE(x)    x, (x == 1) ? "" : "s"
1092         p = nbuf;
1093         if (days) {
1094                 (void)sprintf(p, "%d day%s", PLURALIZE(days));
1095                 while (*++p);
1096         }
1097         if (hours) {
1098                 if (days)
1099                         *p++ = ' ';
1100                 (void)sprintf(p, "%d hour%s", PLURALIZE(hours));
1101                 while (*++p);
1102         }
1103         if (mins) {
1104                 if (days || hours)
1105                         *p++ = ' ';
1106                 (void)sprintf(p, "%d min%s", PLURALIZE(mins));
1107                 while (*++p);
1108         }
1109         if (secs || ! (days || hours || mins)) {
1110                 if (days || hours || mins)
1111                         *p++ = ' ';
1112                 (void)sprintf(p, "%d sec%s", PLURALIZE(secs));
1113         }
1114         return (nbuf);
1115 }
1116
1117 /*
1118  * routines to convert between on-the-wire RR format and zone file format.
1119  * Does not contain conversion to/from decimal degrees; divide or multiply
1120  * by 60*60*1000 for that.
1121  */
1122
1123 static unsigned int poweroften[10] = {1, 10, 100, 1000, 10000, 100000,
1124                                       1000000,10000000,100000000,1000000000};
1125
1126 /* takes an XeY precision/size value, returns a string representation. */
1127 static const char *
1128 precsize_ntoa(prec)
1129         u_int8_t prec;
1130 {
1131         static char retbuf[sizeof "90000000.00"];
1132         unsigned long val;
1133         int mantissa, exponent;
1134
1135         mantissa = (int)((prec >> 4) & 0x0f) % 10;
1136         exponent = (int)((prec >> 0) & 0x0f) % 10;
1137
1138         val = mantissa * poweroften[exponent];
1139
1140         (void) sprintf(retbuf, "%ld.%.2ld", val/100, val%100);
1141         return (retbuf);
1142 }
1143
1144 /* converts ascii size/precision X * 10**Y(cm) to 0xXY.  moves pointer. */
1145 static u_int8_t
1146 precsize_aton(strptr)
1147         char **strptr;
1148 {
1149         unsigned int mval = 0, cmval = 0;
1150         u_int8_t retval = 0;
1151         register char *cp;
1152         register int exponent;
1153         register int mantissa;
1154
1155         cp = *strptr;
1156
1157         while (isdigit(*cp))
1158                 mval = mval * 10 + (*cp++ - '0');
1159
1160         if (*cp == '.') {               /* centimeters */
1161                 cp++;
1162                 if (isdigit(*cp)) {
1163                         cmval = (*cp++ - '0') * 10;
1164                         if (isdigit(*cp)) {
1165                                 cmval += (*cp++ - '0');
1166                         }
1167                 }
1168         }
1169         cmval = (mval * 100) + cmval;
1170
1171         for (exponent = 0; exponent < 9; exponent++)
1172                 if (cmval < poweroften[exponent+1])
1173                         break;
1174
1175         mantissa = cmval / poweroften[exponent];
1176         if (mantissa > 9)
1177                 mantissa = 9;
1178
1179         retval = (mantissa << 4) | exponent;
1180
1181         *strptr = cp;
1182
1183         return (retval);
1184 }
1185
1186 /* converts ascii lat/lon to unsigned encoded 32-bit number.  moves pointer. */
1187 static u_int32_t
1188 latlon2ul(latlonstrptr,which)
1189         char **latlonstrptr;
1190         int *which;
1191 {
1192         register char *cp;
1193         u_int32_t retval;
1194         int deg = 0, min = 0, secs = 0, secsfrac = 0;
1195
1196         cp = *latlonstrptr;
1197
1198         while (isdigit(*cp))
1199                 deg = deg * 10 + (*cp++ - '0');
1200
1201         while (isspace(*cp))
1202                 cp++;
1203
1204         if (!(isdigit(*cp)))
1205                 goto fndhemi;
1206
1207         while (isdigit(*cp))
1208                 min = min * 10 + (*cp++ - '0');
1209
1210         while (isspace(*cp))
1211                 cp++;
1212
1213         if (!(isdigit(*cp)))
1214                 goto fndhemi;
1215
1216         while (isdigit(*cp))
1217                 secs = secs * 10 + (*cp++ - '0');
1218
1219         if (*cp == '.') {               /* decimal seconds */
1220                 cp++;
1221                 if (isdigit(*cp)) {
1222                         secsfrac = (*cp++ - '0') * 100;
1223                         if (isdigit(*cp)) {
1224                                 secsfrac += (*cp++ - '0') * 10;
1225                                 if (isdigit(*cp)) {
1226                                         secsfrac += (*cp++ - '0');
1227                                 }
1228                         }
1229                 }
1230         }
1231
1232         while (!isspace(*cp))   /* if any trailing garbage */
1233                 cp++;
1234
1235         while (isspace(*cp))
1236                 cp++;
1237
1238  fndhemi:
1239         switch (*cp) {
1240         case 'N': case 'n':
1241         case 'E': case 'e':
1242                 retval = ((unsigned)1<<31)
1243                         + (((((deg * 60) + min) * 60) + secs) * 1000)
1244                         + secsfrac;
1245                 break;
1246         case 'S': case 's':
1247         case 'W': case 'w':
1248                 retval = ((unsigned)1<<31)
1249                         - (((((deg * 60) + min) * 60) + secs) * 1000)
1250                         - secsfrac;
1251                 break;
1252         default:
1253                 retval = 0;     /* invalid value -- indicates error */
1254                 break;
1255         }
1256
1257         switch (*cp) {
1258         case 'N': case 'n':
1259         case 'S': case 's':
1260                 *which = 1;     /* latitude */
1261                 break;
1262         case 'E': case 'e':
1263         case 'W': case 'w':
1264                 *which = 2;     /* longitude */
1265                 break;
1266         default:
1267                 *which = 0;     /* error */
1268                 break;
1269         }
1270
1271         cp++;                   /* skip the hemisphere */
1272
1273         while (!isspace(*cp))   /* if any trailing garbage */
1274                 cp++;
1275
1276         while (isspace(*cp))    /* move to next field */
1277                 cp++;
1278
1279         *latlonstrptr = cp;
1280
1281         return (retval);
1282 }
1283
1284 /* converts a zone file representation in a string to an RDATA on-the-wire
1285  * representation. */
1286 int
1287 loc_aton(ascii, binary)
1288         const char *ascii;
1289         u_char *binary;
1290 {
1291         const char *cp, *maxcp;
1292         u_char *bcp;
1293
1294         u_int32_t latit = 0, longit = 0, alt = 0;
1295         u_int32_t lltemp1 = 0, lltemp2 = 0;
1296         int altmeters = 0, altfrac = 0, altsign = 1;
1297         u_int8_t hp = 0x16;     /* default = 1e6 cm = 10000.00m = 10km */
1298         u_int8_t vp = 0x13;     /* default = 1e3 cm = 10.00m */
1299         u_int8_t siz = 0x12;    /* default = 1e2 cm = 1.00m */
1300         int which1 = 0, which2 = 0;
1301
1302         cp = ascii;
1303         maxcp = cp + strlen(ascii);
1304
1305         lltemp1 = latlon2ul(&cp, &which1);
1306
1307         lltemp2 = latlon2ul(&cp, &which2);
1308
1309         switch (which1 + which2) {
1310         case 3:                 /* 1 + 2, the only valid combination */
1311                 if ((which1 == 1) && (which2 == 2)) { /* normal case */
1312                         latit = lltemp1;
1313                         longit = lltemp2;
1314                 } else if ((which1 == 2) && (which2 == 1)) { /* reversed */
1315                         longit = lltemp1;
1316                         latit = lltemp2;
1317                 } else {        /* some kind of brokenness */
1318                         return (0);
1319                 }
1320                 break;
1321         default:                /* we didn't get one of each */
1322                 return (0);
1323         }
1324
1325         /* altitude */
1326         if (*cp == '-') {
1327                 altsign = -1;
1328                 cp++;
1329         }
1330
1331         if (*cp == '+')
1332                 cp++;
1333
1334         while (isdigit(*cp))
1335                 altmeters = altmeters * 10 + (*cp++ - '0');
1336
1337         if (*cp == '.') {               /* decimal meters */
1338                 cp++;
1339                 if (isdigit(*cp)) {
1340                         altfrac = (*cp++ - '0') * 10;
1341                         if (isdigit(*cp)) {
1342                                 altfrac += (*cp++ - '0');
1343                         }
1344                 }
1345         }
1346
1347         alt = (10000000 + (altsign * (altmeters * 100 + altfrac)));
1348
1349         while (!isspace(*cp) && (cp < maxcp)) /* if trailing garbage or m */
1350                 cp++;
1351
1352         while (isspace(*cp) && (cp < maxcp))
1353                 cp++;
1354
1355         if (cp >= maxcp)
1356                 goto defaults;
1357
1358         siz = precsize_aton(&cp);
1359
1360         while (!isspace(*cp) && (cp < maxcp))   /* if trailing garbage or m */
1361                 cp++;
1362
1363         while (isspace(*cp) && (cp < maxcp))
1364                 cp++;
1365
1366         if (cp >= maxcp)
1367                 goto defaults;
1368
1369         hp = precsize_aton(&cp);
1370
1371         while (!isspace(*cp) && (cp < maxcp))   /* if trailing garbage or m */
1372                 cp++;
1373
1374         while (isspace(*cp) && (cp < maxcp))
1375                 cp++;
1376
1377         if (cp >= maxcp)
1378                 goto defaults;
1379
1380         vp = precsize_aton(&cp);
1381
1382  defaults:
1383
1384         bcp = binary;
1385         *bcp++ = (u_int8_t) 0;  /* version byte */
1386         *bcp++ = siz;
1387         *bcp++ = hp;
1388         *bcp++ = vp;
1389         PUTLONG(latit,bcp);
1390         PUTLONG(longit,bcp);
1391         PUTLONG(alt,bcp);
1392
1393         return (16);            /* size of RR in octets */
1394 }
1395
1396 /* takes an on-the-wire LOC RR and formats it in a human readable format. */
1397 const char *
1398 loc_ntoa(binary, ascii)
1399         const u_char *binary;
1400         char *ascii;
1401 {
1402         static char *error = "?";
1403         register const u_char *cp = binary;
1404
1405         int latdeg, latmin, latsec, latsecfrac;
1406         int longdeg, longmin, longsec, longsecfrac;
1407         char northsouth, eastwest;
1408         int altmeters, altfrac, altsign;
1409
1410         const int referencealt = 100000 * 100;
1411
1412         int32_t latval, longval, altval;
1413         u_int32_t templ;
1414         u_int8_t sizeval, hpval, vpval, versionval;
1415
1416         char *sizestr, *hpstr, *vpstr;
1417
1418         versionval = *cp++;
1419
1420         if (versionval) {
1421                 sprintf(ascii, "; error: unknown LOC RR version");
1422                 return (ascii);
1423         }
1424
1425         sizeval = *cp++;
1426
1427         hpval = *cp++;
1428         vpval = *cp++;
1429
1430         GETLONG(templ, cp);
1431         latval = (templ - ((unsigned)1<<31));
1432
1433         GETLONG(templ, cp);
1434         longval = (templ - ((unsigned)1<<31));
1435
1436         GETLONG(templ, cp);
1437         if (templ < referencealt) { /* below WGS 84 spheroid */
1438                 altval = referencealt - templ;
1439                 altsign = -1;
1440         } else {
1441                 altval = templ - referencealt;
1442                 altsign = 1;
1443         }
1444
1445         if (latval < 0) {
1446                 northsouth = 'S';
1447                 latval = -latval;
1448         } else
1449                 northsouth = 'N';
1450
1451         latsecfrac = latval % 1000;
1452         latval = latval / 1000;
1453         latsec = latval % 60;
1454         latval = latval / 60;
1455         latmin = latval % 60;
1456         latval = latval / 60;
1457         latdeg = latval;
1458
1459         if (longval < 0) {
1460                 eastwest = 'W';
1461                 longval = -longval;
1462         } else
1463                 eastwest = 'E';
1464
1465         longsecfrac = longval % 1000;
1466         longval = longval / 1000;
1467         longsec = longval % 60;
1468         longval = longval / 60;
1469         longmin = longval % 60;
1470         longval = longval / 60;
1471         longdeg = longval;
1472
1473         altfrac = altval % 100;
1474         altmeters = (altval / 100) * altsign;
1475
1476         if ((sizestr = strdup(precsize_ntoa(sizeval))) == NULL)
1477                 sizestr = error;
1478         if ((hpstr = strdup(precsize_ntoa(hpval))) == NULL)
1479                 hpstr = error;
1480         if ((vpstr = strdup(precsize_ntoa(vpval))) == NULL)
1481                 vpstr = error;
1482
1483         sprintf(ascii,
1484               "%d %.2d %.2d.%.3d %c %d %.2d %.2d.%.3d %c %d.%.2dm %sm %sm %sm",
1485                 latdeg, latmin, latsec, latsecfrac, northsouth,
1486                 longdeg, longmin, longsec, longsecfrac, eastwest,
1487                 altmeters, altfrac, sizestr, hpstr, vpstr);
1488
1489         if (sizestr != error)
1490                 free(sizestr);
1491         if (hpstr != error)
1492                 free(hpstr);
1493         if (vpstr != error)
1494                 free(vpstr);
1495
1496         return (ascii);
1497 }
1498
1499
1500 /* Return the number of DNS hierarchy levels in the name. */
1501 int
1502 __dn_count_labels(name)
1503         char *name;
1504 {
1505         int i, len, count;
1506
1507         len = strlen(name);
1508
1509         for(i = 0, count = 0; i < len; i++) {
1510                 if (name[i] == '.')
1511                         count++;
1512         }
1513
1514         /* don't count initial wildcard */
1515         if (name[0] == '*')
1516                 if (count)
1517                         count--;
1518
1519         /* don't count the null label for root. */
1520         /* if terminating '.' not found, must adjust */
1521         /* count to include last label */
1522         if (len > 0 && name[len-1] != '.')
1523                 count++;
1524         return (count);
1525 }
1526
1527
1528 /*
1529  * Make dates expressed in seconds-since-Jan-1-1970 easy to read.
1530  * SIG records are required to be printed like this, by the Secure DNS RFC.
1531  */
1532 char *
1533 __p_secstodate (secs)
1534         unsigned long secs;
1535 {
1536         static char output[15];         /* YYYYMMDDHHMMSS and null */
1537         time_t clock = secs;
1538         struct tm time;
1539
1540         __gmtime_r(&clock, &time);
1541         time.tm_year += 1900;
1542         time.tm_mon += 1;
1543         sprintf(output, "%04d%02d%02d%02d%02d%02d",
1544                 time.tm_year, time.tm_mon, time.tm_mday,
1545                 time.tm_hour, time.tm_min, time.tm_sec);
1546         return (output);
1547 }