1 /* 2 * Copyright (c) 1985 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Portions copyright (c) 1999, 2000 6 * Intel Corporation. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * 3. All advertising materials mentioning features or use of this software 21 * must display the following acknowledgement: 22 * 23 * This product includes software developed by the University of 24 * California, Berkeley, Intel Corporation, and its contributors. 25 * 26 * 4. Neither the name of University, Intel Corporation, or their respective 27 * contributors may be used to endorse or promote products derived from 28 * this software without specific prior written permission. 29 * 30 * THIS SOFTWARE IS PROVIDED BY THE REGENTS, INTEL CORPORATION AND 31 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 32 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 33 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS, 34 * INTEL CORPORATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 35 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 36 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 37 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 38 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 39 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 40 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 41 * 42 */ 43 44 /* 45 * Portions Copyright (c) 1993 by Digital Equipment Corporation. 46 * 47 * Permission to use, copy, modify, and distribute this software for any 48 * purpose with or without fee is hereby granted, provided that the above 49 * copyright notice and this permission notice appear in all copies, and that 50 * the name of Digital Equipment Corporation not be used in advertising or 51 * publicity pertaining to distribution of the document or software without 52 * specific, written prior permission. 53 * 54 * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL 55 * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES 56 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT 57 * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 58 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 59 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 60 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 61 * SOFTWARE. 62 */ 63 64 /* 65 * Portions Copyright (c) 1995 by International Business Machines, Inc. 66 * 67 * International Business Machines, Inc. (hereinafter called IBM) grants 68 * permission under its copyrights to use, copy, modify, and distribute this 69 * Software with or without fee, provided that the above copyright notice and 70 * all paragraphs of this notice appear in all copies, and that the name of IBM 71 * not be used in connection with the marketing of any product incorporating 72 * the Software or modifications thereof, without specific, written prior 73 * permission. 74 * 75 * To the extent it has a right to do so, IBM grants an immunity from suit 76 * under its patents, if any, for the use, sale or manufacture of products to 77 * the extent that such products are used for performing Domain Name System 78 * dynamic updates in TCP/IP networks by means of the Software. No immunity is 79 * granted for any product per se or for any other function of any product. 80 * 81 * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES, 82 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 83 * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, 84 * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING 85 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN 86 * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES. 87 */ 88 89 /* 90 * Portions Copyright (c) 1996 by Internet Software Consortium. 91 * 92 * Permission to use, copy, modify, and distribute this software for any 93 * purpose with or without fee is hereby granted, provided that the above 94 * copyright notice and this permission notice appear in all copies. 95 * 96 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS 97 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES 98 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE 99 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 100 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 101 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 102 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 103 * SOFTWARE. 104 */ 105 106 #if defined(LIBC_SCCS) && !defined(lint) 107 static char sccsid[] = "@(#)res_debug.c 8.1 (Berkeley) 6/4/93"; 108 static char rcsid[] = "$Id: res_debug.c,v 1.1.1.1 2003/11/19 01:51:36 kyu3 Exp $"; 109 #endif /* LIBC_SCCS and not lint */ 110 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> 124 #include <stdio.h> 125 #include <stdlib.h> 126 #include <string.h> 127 #include <time.h> 128 129 #define SPRINTF(x) sprintf x 130 131 extern const char *_res_opcodes[]; 132 extern const char *_res_resultcodes[]; 133 extern const char *_res_sectioncodes[]; 134 135 /* 136 * Print the current options. 137 */ 138 void 139 fp_resstat(struct __res_state *statp, FILE *file) { 140 u_long mask; 141 142 fprintf(file, ";; res options:"); 143 if (!statp) 144 statp = &_res; 145 for (mask = 1; mask != 0; mask <<= 1) 146 if (statp->options & mask) 147 fprintf(file, " %s", p_option(mask)); 148 putc('\n', file); 149 } 150 151 static void 152 do_section(ns_msg *handle, ns_sect section, int pflag, FILE *file) { 153 int n, sflag, rrnum; 154 ns_opcode opcode; 155 ns_rr rr; 156 157 /* 158 * Print answer records. 159 */ 160 sflag = (int)(_res.pfcode & pflag); 161 if (_res.pfcode && !sflag) 162 return; 163 164 opcode = ns_msg_getflag(*handle, ns_f_opcode); 165 rrnum = 0; 166 for (;;) { 167 if (ns_parserr(handle, section, rrnum, &rr)) { 168 if (errno != ENODEV) 169 fprintf(file, ";; ns_parserr: %s\n", 170 strerror(errno)); 171 else if (rrnum > 0 && sflag != 0 && 172 (_res.pfcode & RES_PRF_HEAD1)) 173 putc('\n', file); 174 return; 175 } 176 if (rrnum == 0 && sflag != 0 && (_res.pfcode & RES_PRF_HEAD1)) 177 fprintf(file, ";; %s SECTION:\n", 178 p_section(section, opcode)); 179 if (section == ns_s_qd) 180 fprintf(file, ";;\t%s, type = %s, class = %s\n", 181 ns_rr_name(rr), 182 p_type(ns_rr_type(rr)), 183 p_class(ns_rr_class(rr))); 184 else { 185 char *buf; 186 buf = (char*)malloc(2024); 187 if (buf) { 188 n = ns_sprintrr(handle, &rr, NULL, NULL, 189 buf, sizeof buf); 190 if (n < 0) { 191 fprintf(file, ";; ns_sprintrr: %s\n", 192 strerror(errno)); 193 free(buf); 194 return; 195 } 196 fputs(buf, file); 197 fputc('\n', file); 198 free(buf); 199 } 200 } 201 rrnum++; 202 } 203 } 204 205 void 206 p_query(const u_char *msg) { 207 fp_query(msg, stdout); 208 } 209 210 void 211 fp_query(const u_char *msg, FILE *file) { 212 fp_nquery(msg, PACKETSZ, file); 213 } 214 215 /* 216 * Print the contents of a query. 217 * This is intended to be primarily a debugging routine. 218 */ 219 void 220 fp_nquery(const u_char *msg, int len, FILE *file) { 221 ns_msg handle; 222 int qdcount, ancount, nscount, arcount; 223 u_int opcode, rcode, id; 224 225 if ((_res.options & RES_INIT) == 0 && res_init() == -1) 226 return; 227 228 if (ns_initparse(msg, len, &handle) < 0) { 229 fprintf(file, ";; ns_initparse: %s\n", strerror(errno)); 230 return; 231 } 232 opcode = ns_msg_getflag(handle, ns_f_opcode); 233 rcode = ns_msg_getflag(handle, ns_f_rcode); 234 id = ns_msg_id(handle); 235 qdcount = ns_msg_count(handle, ns_s_qd); 236 ancount = ns_msg_count(handle, ns_s_an); 237 nscount = ns_msg_count(handle, ns_s_ns); 238 arcount = ns_msg_count(handle, ns_s_ar); 239 240 /* 241 * Print header fields. 242 */ 243 if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEADX) || rcode) 244 fprintf(file, 245 ";; ->>HEADER<<- opcode: %s, status: %s, id: %d\n", 246 _res_opcodes[opcode], _res_resultcodes[rcode], (int)id); 247 if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEADX)) 248 putc(';', file); 249 if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD2)) { 250 fprintf(file, "; flags:"); 251 if (ns_msg_getflag(handle, ns_f_qr)) 252 fprintf(file, " qr"); 253 if (ns_msg_getflag(handle, ns_f_aa)) 254 fprintf(file, " aa"); 255 if (ns_msg_getflag(handle, ns_f_tc)) 256 fprintf(file, " tc"); 257 if (ns_msg_getflag(handle, ns_f_rd)) 258 fprintf(file, " rd"); 259 if (ns_msg_getflag(handle, ns_f_ra)) 260 fprintf(file, " ra"); 261 if (ns_msg_getflag(handle, ns_f_z)) 262 fprintf(file, " ??"); 263 if (ns_msg_getflag(handle, ns_f_ad)) 264 fprintf(file, " ad"); 265 if (ns_msg_getflag(handle, ns_f_cd)) 266 fprintf(file, " cd"); 267 } 268 if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD1)) { 269 fprintf(file, "; %s: %d", 270 p_section(ns_s_qd, (int)opcode), qdcount); 271 fprintf(file, ", %s: %d", 272 p_section(ns_s_an, (int)opcode), ancount); 273 fprintf(file, ", %s: %d", 274 p_section(ns_s_ns, (int)opcode), nscount); 275 fprintf(file, ", %s: %d", 276 p_section(ns_s_ar, (int)opcode), arcount); 277 } 278 if ((!_res.pfcode) || (_res.pfcode & 279 (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1))) { 280 putc('\n',file); 281 } 282 /* 283 * Print the various sections. 284 */ 285 do_section(&handle, ns_s_qd, RES_PRF_QUES, file); 286 do_section(&handle, ns_s_an, RES_PRF_ANS, file); 287 do_section(&handle, ns_s_ns, RES_PRF_AUTH, file); 288 do_section(&handle, ns_s_ar, RES_PRF_ADD, file); 289 if (qdcount == 0 && ancount == 0 && 290 nscount == 0 && arcount == 0) 291 putc('\n', file); 292 } 293 294 const u_char * 295 p_cdnname(const u_char *cp, const u_char *msg, int len, FILE *file) { 296 char name[MAXDNAME]; 297 int n; 298 299 if ((n = dn_expand(msg, msg + len, cp, name, sizeof name)) < 0) 300 return (NULL); 301 if (name[0] == '\0') 302 putc('.', file); 303 else 304 fputs(name, file); 305 return (cp + n); 306 } 307 308 const u_char * 309 p_cdname(const u_char *cp, const u_char *msg, FILE *file) { 310 return (p_cdnname(cp, msg, PACKETSZ, file)); 311 } 312 313 /* Return a fully-qualified domain name from a compressed name (with 314 length supplied). */ 315 316 const u_char * 317 p_fqnname( 318 const u_char *cp, 319 const u_char *msg, 320 int msglen, 321 char *name, 322 int namelen 323 ) 324 { 325 int n, newlen; 326 327 if ((n = dn_expand(msg, cp + msglen, cp, name, namelen)) < 0) 328 return (NULL); 329 newlen = (int)strlen(name); 330 if (newlen == 0 || name[newlen - 1] != '.') { 331 if (newlen + 1 >= namelen) /* Lack space for final dot */ 332 return (NULL); 333 else 334 strcpy(name + newlen, "."); 335 } 336 return (cp + n); 337 } 338 339 /* XXX: the rest of these functions need to become length-limited, too. */ 340 341 const u_char * 342 p_fqname(const u_char *cp, const u_char *msg, FILE *file) { 343 char name[MAXDNAME]; 344 const u_char *n; 345 346 n = p_fqnname(cp, msg, MAXCDNAME, name, sizeof name); 347 if (n == NULL) 348 return (NULL); 349 fputs(name, file); 350 return (n); 351 } 352 353 /* 354 * Names of RR classes and qclasses. Classes and qclasses are the same, except 355 * that C_ANY is a qclass but not a class. (You can ask for records of class 356 * C_ANY, but you can't have any records of that class in the database.) 357 */ 358 const struct res_sym __p_class_syms[] = { 359 {C_IN, "IN"}, 360 {C_CHAOS, "CHAOS"}, 361 {C_HS, "HS"}, 362 {C_HS, "HESIOD"}, 363 {C_ANY, "ANY"}, 364 {C_NONE, "NONE"}, 365 {C_IN, (char *)0} 366 }; 367 368 /* 369 * Names of message sections. 370 */ 371 const struct res_sym __p_default_section_syms[] = { 372 {ns_s_qd, "QUERY"}, 373 {ns_s_an, "ANSWER"}, 374 {ns_s_ns, "AUTHORITY"}, 375 {ns_s_ar, "ADDITIONAL"}, 376 {0, (char *)0} 377 }; 378 379 const struct res_sym __p_update_section_syms[] = { 380 {S_ZONE, "ZONE"}, 381 {S_PREREQ, "PREREQUISITE"}, 382 {S_UPDATE, "UPDATE"}, 383 {S_ADDT, "ADDITIONAL"}, 384 {0, (char *)0} 385 }; 386 387 /* 388 * Names of RR types and qtypes. Types and qtypes are the same, except 389 * that T_ANY is a qtype but not a type. (You can ask for records of type 390 * T_ANY, but you can't have any records of that type in the database.) 391 */ 392 const struct res_sym __p_type_syms[] = { 393 {T_A, "A", "address"}, 394 {T_NS, "NS", "name server"}, 395 {T_MD, "MD", "mail destination (deprecated)"}, 396 {T_MF, "MF", "mail forwarder (deprecated)"}, 397 {T_CNAME, "CNAME", "canonical name"}, 398 {T_SOA, "SOA", "start of authority"}, 399 {T_MB, "MB", "mailbox"}, 400 {T_MG, "MG", "mail group member"}, 401 {T_MR, "MR", "mail rename"}, 402 {T_NULL, "NULL", "null"}, 403 {T_WKS, "WKS", "well-known service (deprecated)"}, 404 {T_PTR, "PTR", "domain name pointer"}, 405 {T_HINFO, "HINFO", "host information"}, 406 {T_MINFO, "MINFO", "mailbox information"}, 407 {T_MX, "MX", "mail exchanger"}, 408 {T_TXT, "TXT", "text"}, 409 {T_RP, "RP", "responsible person"}, 410 {T_AFSDB, "AFSDB", "DCE or AFS server"}, 411 {T_X25, "X25", "X25 address"}, 412 {T_ISDN, "ISDN", "ISDN address"}, 413 {T_RT, "RT", "router"}, 414 {T_NSAP, "NSAP", "nsap address"}, 415 {T_NSAP_PTR, "NSAP_PTR", "domain name pointer"}, 416 {T_SIG, "SIG", "signature"}, 417 {T_KEY, "KEY", "key"}, 418 {T_PX, "PX", "mapping information"}, 419 {T_GPOS, "GPOS", "geographical position (withdrawn)"}, 420 {T_AAAA, "AAAA", "IPv6 address"}, 421 {T_LOC, "LOC", "location"}, 422 {T_NXT, "NXT", "next valid name (unimplemented)"}, 423 {T_EID, "EID", "endpoint identifier (unimplemented)"}, 424 {T_NIMLOC, "NIMLOC", "NIMROD locator (unimplemented)"}, 425 {T_SRV, "SRV", "server selection"}, 426 {T_ATMA, "ATMA", "ATM address (unimplemented)"}, 427 {T_IXFR, "IXFR", "incremental zone transfer"}, 428 {T_AXFR, "AXFR", "zone transfer"}, 429 {T_MAILB, "MAILB", "mailbox-related data (deprecated)"}, 430 {T_MAILA, "MAILA", "mail agent (deprecated)"}, 431 {T_NAPTR, "NAPTR", "URN Naming Authority"}, 432 {T_ANY, "ANY", "\"any\""}, 433 {0, NULL, NULL} 434 }; 435 436 int 437 sym_ston(const struct res_sym *syms, const char *name, int *success) { 438 for ((void)NULL; syms->name != 0; syms++) { 439 if (strcasecmp (name, syms->name) == 0) { 440 if (success) 441 *success = 1; 442 return (syms->number); 443 } 444 } 445 if (success) 446 *success = 0; 447 return (syms->number); /* The default value. */ 448 } 449 450 const char * 451 sym_ntos(const struct res_sym *syms, int number, int *success) { 452 static char unname[20]; 453 454 for ((void)NULL; syms->name != 0; syms++) { 455 if (number == syms->number) { 456 if (success) 457 *success = 1; 458 return (syms->name); 459 } 460 } 461 462 sprintf(unname, "%d", number); 463 if (success) 464 *success = 0; 465 return (unname); 466 } 467 468 const char * 469 sym_ntop(const struct res_sym *syms, int number, int *success) { 470 static char unname[20]; 471 472 for ((void)NULL; syms->name != 0; syms++) { 473 if (number == syms->number) { 474 if (success) 475 *success = 1; 476 return (syms->humanname); 477 } 478 } 479 sprintf(unname, "%d", number); 480 if (success) 481 *success = 0; 482 return (unname); 483 } 484 485 /* 486 * Return a string for the type. 487 */ 488 const char * 489 p_type(int type) { 490 return (sym_ntos(__p_type_syms, type, (int *)0)); 491 } 492 493 /* 494 * Return a string for the type. 495 */ 496 const char * 497 p_section(int section, int opcode) { 498 const struct res_sym *symbols; 499 500 switch (opcode) { 501 case ns_o_update: 502 symbols = __p_update_section_syms; 503 break; 504 default: 505 symbols = __p_default_section_syms; 506 break; 507 } 508 return (sym_ntos(symbols, section, (int *)0)); 509 } 510 511 /* 512 * Return a mnemonic for class. 513 */ 514 const char * 515 p_class(int class) { 516 return (sym_ntos(__p_class_syms, class, (int *)0)); 517 } 518 519 /* 520 * Return a mnemonic for an option 521 */ 522 const char * 523 p_option(u_long option) { 524 static char nbuf[40]; 525 526 switch (option) { 527 case RES_INIT: return "init"; 528 case RES_DEBUG: return "debug"; 529 case RES_AAONLY: return "aaonly(unimpl)"; 530 case RES_USEVC: return "usevc"; 531 case RES_PRIMARY: return "primry(unimpl)"; 532 case RES_IGNTC: return "igntc"; 533 case RES_RECURSE: return "recurs"; 534 case RES_DEFNAMES: return "defnam"; 535 case RES_STAYOPEN: return "styopn"; 536 case RES_DNSRCH: return "dnsrch"; 537 case RES_INSECURE1: return "insecure1"; 538 case RES_INSECURE2: return "insecure2"; 539 default: sprintf(nbuf, "?0x%lx?", (unsigned long)option); 540 return (nbuf); 541 } 542 } 543 544 /* 545 * Return a mnemonic for a time to live. 546 */ 547 const char * 548 p_time(u_int32_t value) { 549 static char nbuf[40]; 550 551 if (ns_format_ttl(value, nbuf, sizeof nbuf) < 0) 552 sprintf(nbuf, "%u", value); 553 return (nbuf); 554 } 555 556 557 /* 558 * routines to convert between on-the-wire RR format and zone file format. 559 * Does not contain conversion to/from decimal degrees; divide or multiply 560 * by 60*60*1000 for that. 561 */ 562 563 static unsigned int poweroften[10] = {1, 10, 100, 1000, 10000, 100000, 564 1000000,10000000,100000000,1000000000}; 565 566 /* takes an XeY precision/size value, returns a string representation. */ 567 static const char * 568 precsize_ntoa( 569 u_int8_t prec 570 ) 571 { 572 static char retbuf[sizeof "90000000.00"]; 573 unsigned long val; 574 int mantissa, exponent; 575 576 mantissa = (int)((prec >> 4) & 0x0f) % 10; 577 exponent = (int)((prec >> 0) & 0x0f) % 10; 578 579 val = mantissa * poweroften[exponent]; 580 581 (void) sprintf(retbuf, "%ld.%.2ld", val/100, val%100); 582 return (retbuf); 583 } 584 585 /* converts ascii size/precision X * 10**Y(cm) to 0xXY. moves pointer. */ 586 static u_int8_t 587 precsize_aton( 588 char **strptr 589 ) 590 { 591 unsigned int mval = 0, cmval = 0; 592 u_int8_t retval = 0; 593 char *cp; 594 int exponent; 595 int mantissa; 596 597 cp = *strptr; 598 599 while (isdigit(*cp)) 600 mval = mval * 10 + (*cp++ - '0'); 601 602 if (*cp == '.') { /* centimeters */ 603 cp++; 604 if (isdigit(*cp)) { 605 cmval = (*cp++ - '0') * 10; 606 if (isdigit(*cp)) { 607 cmval += (*cp++ - '0'); 608 } 609 } 610 } 611 cmval = (mval * 100) + cmval; 612 613 for (exponent = 0; exponent < 9; exponent++) 614 if (cmval < poweroften[exponent+1]) 615 break; 616 617 mantissa = cmval / poweroften[exponent]; 618 if (mantissa > 9) 619 mantissa = 9; 620 621 retval = (u_int8_t)((mantissa << 4) | exponent); 622 623 *strptr = cp; 624 625 return (retval); 626 } 627 628 /* converts ascii lat/lon to unsigned encoded 32-bit number. moves pointer. */ 629 static u_int32_t 630 latlon2ul( 631 char **latlonstrptr, 632 int *which 633 ) 634 { 635 char *cp; 636 u_int32_t retval; 637 int deg = 0, min = 0, secs = 0, secsfrac = 0; 638 639 cp = *latlonstrptr; 640 641 while (isdigit(*cp)) 642 deg = deg * 10 + (*cp++ - '0'); 643 644 while (isspace(*cp)) 645 cp++; 646 647 if (!(isdigit(*cp))) 648 goto fndhemi; 649 650 while (isdigit(*cp)) 651 min = min * 10 + (*cp++ - '0'); 652 653 while (isspace(*cp)) 654 cp++; 655 656 if (!(isdigit(*cp))) 657 goto fndhemi; 658 659 while (isdigit(*cp)) 660 secs = secs * 10 + (*cp++ - '0'); 661 662 if (*cp == '.') { /* decimal seconds */ 663 cp++; 664 if (isdigit(*cp)) { 665 secsfrac = (*cp++ - '0') * 100; 666 if (isdigit(*cp)) { 667 secsfrac += (*cp++ - '0') * 10; 668 if (isdigit(*cp)) { 669 secsfrac += (*cp++ - '0'); 670 } 671 } 672 } 673 } 674 675 while (!isspace(*cp)) /* if any trailing garbage */ 676 cp++; 677 678 while (isspace(*cp)) 679 cp++; 680 681 fndhemi: 682 switch (*cp) { 683 case 'N': case 'n': 684 case 'E': case 'e': 685 retval = ((unsigned)1<<31) 686 + (((((deg * 60) + min) * 60) + secs) * 1000) 687 + secsfrac; 688 break; 689 case 'S': case 's': 690 case 'W': case 'w': 691 retval = ((unsigned)1<<31) 692 - (((((deg * 60) + min) * 60) + secs) * 1000) 693 - secsfrac; 694 break; 695 default: 696 retval = 0; /* invalid value -- indicates error */ 697 break; 698 } 699 700 switch (*cp) { 701 case 'N': case 'n': 702 case 'S': case 's': 703 *which = 1; /* latitude */ 704 break; 705 case 'E': case 'e': 706 case 'W': case 'w': 707 *which = 2; /* longitude */ 708 break; 709 default: 710 *which = 0; /* error */ 711 break; 712 } 713 714 cp++; /* skip the hemisphere */ 715 716 while (!isspace(*cp)) /* if any trailing garbage */ 717 cp++; 718 719 while (isspace(*cp)) /* move to next field */ 720 cp++; 721 722 *latlonstrptr = cp; 723 724 return (retval); 725 } 726 727 /* converts a zone file representation in a string to an RDATA on-the-wire 728 * representation. */ 729 int 730 loc_aton( 731 const char *ascii, 732 u_char *binary 733 ) 734 { 735 const char *cp, *maxcp; 736 u_char *bcp; 737 738 u_int32_t latit = 0, longit = 0, alt = 0; 739 u_int32_t lltemp1 = 0, lltemp2 = 0; 740 int altmeters = 0, altfrac = 0, altsign = 1; 741 u_int8_t hp = 0x16; /* default = 1e6 cm = 10000.00m = 10km */ 742 u_int8_t vp = 0x13; /* default = 1e3 cm = 10.00m */ 743 u_int8_t siz = 0x12; /* default = 1e2 cm = 1.00m */ 744 int which1 = 0, which2 = 0; 745 746 cp = ascii; 747 maxcp = cp + strlen(ascii); 748 749 lltemp1 = latlon2ul((char **)&cp, &which1); 750 751 lltemp2 = latlon2ul((char **)&cp, &which2); 752 753 switch (which1 + which2) { 754 case 3: /* 1 + 2, the only valid combination */ 755 if ((which1 == 1) && (which2 == 2)) { /* normal case */ 756 latit = lltemp1; 757 longit = lltemp2; 758 } else if ((which1 == 2) && (which2 == 1)) { /* reversed */ 759 longit = lltemp1; 760 latit = lltemp2; 761 } else { /* some kind of brokenness */ 762 return (0); 763 } 764 break; 765 default: /* we didn't get one of each */ 766 return (0); 767 } 768 769 /* altitude */ 770 if (*cp == '-') { 771 altsign = -1; 772 cp++; 773 } 774 775 if (*cp == '+') 776 cp++; 777 778 while (isdigit(*cp)) 779 altmeters = altmeters * 10 + (*cp++ - '0'); 780 781 if (*cp == '.') { /* decimal meters */ 782 cp++; 783 if (isdigit(*cp)) { 784 altfrac = (*cp++ - '0') * 10; 785 if (isdigit(*cp)) { 786 altfrac += (*cp++ - '0'); 787 } 788 } 789 } 790 791 alt = (10000000 + (altsign * (altmeters * 100 + altfrac))); 792 793 while (!isspace(*cp) && (cp < maxcp)) /* if trailing garbage or m */ 794 cp++; 795 796 while (isspace(*cp) && (cp < maxcp)) 797 cp++; 798 799 if (cp >= maxcp) 800 goto defaults; 801 802 siz = precsize_aton((char **)&cp); 803 804 while (!isspace(*cp) && (cp < maxcp)) /* if trailing garbage or m */ 805 cp++; 806 807 while (isspace(*cp) && (cp < maxcp)) 808 cp++; 809 810 if (cp >= maxcp) 811 goto defaults; 812 813 hp = precsize_aton((char **)&cp); 814 815 while (!isspace(*cp) && (cp < maxcp)) /* if trailing garbage or m */ 816 cp++; 817 818 while (isspace(*cp) && (cp < maxcp)) 819 cp++; 820 821 if (cp >= maxcp) 822 goto defaults; 823 824 vp = precsize_aton((char **)&cp); 825 826 defaults: 827 828 bcp = binary; 829 *bcp++ = (u_int8_t) 0; /* version byte */ 830 *bcp++ = siz; 831 *bcp++ = hp; 832 *bcp++ = vp; 833 PUTLONG(latit,bcp); 834 PUTLONG(longit,bcp); 835 PUTLONG(alt,bcp); 836 837 return (16); /* size of RR in octets */ 838 } 839 840 /* takes an on-the-wire LOC RR and formats it in a human readable format. */ 841 const char * 842 loc_ntoa( 843 const u_char *binary, 844 char *ascii 845 ) 846 { 847 static char *error = "?"; 848 const u_char *cp = binary; 849 850 int latdeg, latmin, latsec, latsecfrac; 851 int longdeg, longmin, longsec, longsecfrac; 852 char northsouth, eastwest; 853 int altmeters, altfrac, altsign; 854 855 const u_int32_t referencealt = 100000 * 100; 856 857 int32_t latval, longval, altval; 858 u_int32_t templ; 859 u_int8_t sizeval, hpval, vpval, versionval; 860 861 char *sizestr, *hpstr, *vpstr; 862 863 versionval = *cp++; 864 865 if (versionval) { 866 (void) sprintf(ascii, "; error: unknown LOC RR version"); 867 return (ascii); 868 } 869 870 sizeval = *cp++; 871 872 hpval = *cp++; 873 vpval = *cp++; 874 875 GETLONG(templ, cp); 876 latval = (templ - ((unsigned)1<<31)); 877 878 GETLONG(templ, cp); 879 longval = (templ - ((unsigned)1<<31)); 880 881 GETLONG(templ, cp); 882 if (templ < referencealt) { /* below WGS 84 spheroid */ 883 altval = referencealt - templ; 884 altsign = -1; 885 } else { 886 altval = templ - referencealt; 887 altsign = 1; 888 } 889 890 if (latval < 0) { 891 northsouth = 'S'; 892 latval = -latval; 893 } else 894 northsouth = 'N'; 895 896 latsecfrac = latval % 1000; 897 latval = latval / 1000; 898 latsec = latval % 60; 899 latval = latval / 60; 900 latmin = latval % 60; 901 latval = latval / 60; 902 latdeg = latval; 903 904 if (longval < 0) { 905 eastwest = 'W'; 906 longval = -longval; 907 } else 908 eastwest = 'E'; 909 910 longsecfrac = longval % 1000; 911 longval = longval / 1000; 912 longsec = longval % 60; 913 longval = longval / 60; 914 longmin = longval % 60; 915 longval = longval / 60; 916 longdeg = longval; 917 918 altfrac = altval % 100; 919 altmeters = (altval / 100) * altsign; 920 921 if ((sizestr = strdup(precsize_ntoa(sizeval))) == NULL) 922 sizestr = error; 923 if ((hpstr = strdup(precsize_ntoa(hpval))) == NULL) 924 hpstr = error; 925 if ((vpstr = strdup(precsize_ntoa(vpval))) == NULL) 926 vpstr = error; 927 928 sprintf(ascii, 929 "%d %.2d %.2d.%.3d %c %d %.2d %.2d.%.3d %c %d.%.2dm %sm %sm %sm", 930 latdeg, latmin, latsec, latsecfrac, northsouth, 931 longdeg, longmin, longsec, longsecfrac, eastwest, 932 altmeters, altfrac, sizestr, hpstr, vpstr); 933 934 if (sizestr != error) 935 free(sizestr); 936 if (hpstr != error) 937 free(hpstr); 938 if (vpstr != error) 939 free(vpstr); 940 941 return (ascii); 942 } 943 944 945 /* Return the number of DNS hierarchy levels in the name. */ 946 int 947 dn_count_labels(const char *name) { 948 int i, len, count; 949 950 len = (int)strlen(name); 951 for (i = 0, count = 0; i < len; i++) { 952 /* XXX need to check for \. or use named's nlabels(). */ 953 if (name[i] == '.') 954 count++; 955 } 956 957 /* don't count initial wildcard */ 958 if (name[0] == '*') 959 if (count) 960 count--; 961 962 /* don't count the null label for root. */ 963 /* if terminating '.' not found, must adjust */ 964 /* count to include last label */ 965 if (len > 0 && name[len-1] != '.') 966 count++; 967 return (count); 968 } 969 970 971 /* 972 * Make dates expressed in seconds-since-Jan-1-1970 easy to read. 973 * SIG records are required to be printed like this, by the Secure DNS RFC. 974 */ 975 char * 976 p_secstodate (u_long secs) { 977 static char output[15]; /* YYYYMMDDHHMMSS and null */ 978 time_t clock = (time_t)secs; 979 struct tm *time; 980 981 time = gmtime(&clock); 982 time->tm_year += 1900; 983 time->tm_mon += 1; 984 sprintf(output, "%04d%02d%02d%02d%02d%02d", 985 time->tm_year, time->tm_mon, time->tm_mday, 986 time->tm_hour, time->tm_min, time->tm_sec); 987 return (output); 988 } 989
