]>
Commit | Line | Data |
---|---|---|
28f540f4 RM |
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 | * --Copyright-- | |
54 | */ | |
55 | ||
56 | #if defined(LIBC_SCCS) && !defined(lint) | |
57 | static char sccsid[] = "@(#)res_debug.c 8.1 (Berkeley) 6/4/93"; | |
58 | static char rcsid[] = "$Id$"; | |
59 | #endif /* LIBC_SCCS and not lint */ | |
60 | ||
61 | #include <sys/param.h> | |
62 | #include <netinet/in.h> | |
63 | #include <arpa/inet.h> | |
64 | #include <arpa/nameser.h> | |
65 | ||
66 | #include <stdio.h> | |
67 | #include <resolv.h> | |
68 | #if defined(BSD) && (BSD >= 199103) | |
69 | # include <string.h> | |
70 | #else | |
71 | # include "../conf/portability.h" | |
72 | #endif | |
73 | ||
74 | #if defined(USE_OPTIONS_H) | |
75 | # include "../conf/options.h" | |
76 | #endif | |
77 | ||
78 | const char *_res_opcodes[] = { | |
79 | "QUERY", | |
80 | "IQUERY", | |
81 | "CQUERYM", | |
82 | "CQUERYU", /* experimental */ | |
83 | "NOTIFY", /* experimental */ | |
84 | "5", | |
85 | "6", | |
86 | "7", | |
87 | "8", | |
88 | "UPDATEA", | |
89 | "UPDATED", | |
90 | "UPDATEDA", | |
91 | "UPDATEM", | |
92 | "UPDATEMA", | |
93 | "ZONEINIT", | |
94 | "ZONEREF", | |
95 | }; | |
96 | ||
97 | const char *_res_resultcodes[] = { | |
98 | "NOERROR", | |
99 | "FORMERR", | |
100 | "SERVFAIL", | |
101 | "NXDOMAIN", | |
102 | "NOTIMP", | |
103 | "REFUSED", | |
104 | "6", | |
105 | "7", | |
106 | "8", | |
107 | "9", | |
108 | "10", | |
109 | "11", | |
110 | "12", | |
111 | "13", | |
112 | "14", | |
113 | "NOCHANGE", | |
114 | }; | |
115 | ||
116 | static char retbuf[16]; | |
117 | ||
118 | static const char * | |
119 | dewks(wks) | |
120 | int wks; | |
121 | { | |
122 | switch (wks) { | |
123 | case 5: return "rje"; | |
124 | case 7: return "echo"; | |
125 | case 9: return "discard"; | |
126 | case 11: return "systat"; | |
127 | case 13: return "daytime"; | |
128 | case 15: return "netstat"; | |
129 | case 17: return "qotd"; | |
130 | case 19: return "chargen"; | |
131 | case 20: return "ftp-data"; | |
132 | case 21: return "ftp"; | |
133 | case 23: return "telnet"; | |
134 | case 25: return "smtp"; | |
135 | case 37: return "time"; | |
136 | case 39: return "rlp"; | |
137 | case 42: return "name"; | |
138 | case 43: return "whois"; | |
139 | case 53: return "domain"; | |
140 | case 57: return "apts"; | |
141 | case 59: return "apfs"; | |
142 | case 67: return "bootps"; | |
143 | case 68: return "bootpc"; | |
144 | case 69: return "tftp"; | |
145 | case 77: return "rje"; | |
146 | case 79: return "finger"; | |
147 | case 87: return "link"; | |
148 | case 95: return "supdup"; | |
149 | case 100: return "newacct"; | |
150 | case 101: return "hostnames"; | |
151 | case 102: return "iso-tsap"; | |
152 | case 103: return "x400"; | |
153 | case 104: return "x400-snd"; | |
154 | case 105: return "csnet-ns"; | |
155 | case 109: return "pop-2"; | |
156 | case 111: return "sunrpc"; | |
157 | case 113: return "auth"; | |
158 | case 115: return "sftp"; | |
159 | case 117: return "uucp-path"; | |
160 | case 119: return "nntp"; | |
161 | case 121: return "erpc"; | |
162 | case 123: return "ntp"; | |
163 | case 133: return "statsrv"; | |
164 | case 136: return "profile"; | |
165 | case 144: return "NeWS"; | |
166 | case 161: return "snmp"; | |
167 | case 162: return "snmp-trap"; | |
168 | case 170: return "print-srv"; | |
169 | default: (void) sprintf(retbuf, "%d", wks); return (retbuf); | |
170 | } | |
171 | } | |
172 | ||
173 | static const char * | |
174 | deproto(protonum) | |
175 | int protonum; | |
176 | { | |
177 | switch (protonum) { | |
178 | case 1: return "icmp"; | |
179 | case 2: return "igmp"; | |
180 | case 3: return "ggp"; | |
181 | case 5: return "st"; | |
182 | case 6: return "tcp"; | |
183 | case 7: return "ucl"; | |
184 | case 8: return "egp"; | |
185 | case 9: return "igp"; | |
186 | case 11: return "nvp-II"; | |
187 | case 12: return "pup"; | |
188 | case 16: return "chaos"; | |
189 | case 17: return "udp"; | |
190 | default: (void) sprintf(retbuf, "%d", protonum); return (retbuf); | |
191 | } | |
192 | } | |
193 | ||
194 | static const u_char * | |
195 | do_rrset(msg, cp, cnt, pflag, file, hs) | |
196 | int cnt, pflag; | |
197 | const u_char *cp, *msg; | |
198 | const char *hs; | |
199 | FILE *file; | |
200 | { | |
201 | int n; | |
202 | int sflag; | |
203 | ||
204 | /* | |
205 | * Print answer records. | |
206 | */ | |
207 | sflag = (_res.pfcode & pflag); | |
208 | if (n = ntohs(cnt)) { | |
209 | if ((!_res.pfcode) || | |
210 | ((sflag) && (_res.pfcode & RES_PRF_HEAD1))) | |
211 | fprintf(file, hs); | |
212 | while (--n >= 0) { | |
213 | if ((!_res.pfcode) || sflag) { | |
214 | cp = p_rr(cp, msg, file); | |
215 | } else { | |
216 | unsigned int dlen; | |
217 | cp += __dn_skipname(cp, cp + MAXCDNAME); | |
218 | cp += INT16SZ; | |
219 | cp += INT16SZ; | |
220 | cp += INT32SZ; | |
221 | dlen = _getshort((u_char*)cp); | |
222 | cp += INT16SZ; | |
223 | cp += dlen; | |
224 | } | |
225 | if ((cp - msg) > PACKETSZ) | |
226 | return (NULL); | |
227 | } | |
228 | if ((!_res.pfcode) || | |
229 | ((sflag) && (_res.pfcode & RES_PRF_HEAD1))) | |
230 | putc('\n', file); | |
231 | } | |
232 | return (cp); | |
233 | } | |
234 | ||
235 | void | |
236 | __p_query(msg) | |
237 | const u_char *msg; | |
238 | { | |
239 | __fp_query(msg, stdout); | |
240 | } | |
241 | ||
242 | #ifdef ultrix | |
243 | /* ultrix 4.0's packaging has some icky packaging. alias for it here. | |
244 | * there is more junk of this kind over in res_comp.c. | |
245 | */ | |
246 | void | |
247 | p_query(msg) | |
248 | const u_char *msg; | |
249 | { | |
250 | __p_query(msg); | |
251 | } | |
252 | #endif | |
253 | ||
254 | /* | |
255 | * Print the current options. | |
256 | * This is intended to be primarily a debugging routine. | |
257 | */ | |
258 | void | |
259 | __fp_resstat(statp, file) | |
260 | struct __res_state *statp; | |
261 | FILE *file; | |
262 | { | |
263 | register u_long mask; | |
264 | ||
265 | fprintf(file, ";; res options:"); | |
266 | if (!statp) | |
267 | statp = &_res; | |
268 | for (mask = 1; mask != 0; mask <<= 1) | |
269 | if (statp->options & mask) | |
270 | fprintf(file, " %s", p_option(mask)); | |
271 | putc('\n', file); | |
272 | } | |
273 | ||
274 | /* | |
275 | * Print the contents of a query. | |
276 | * This is intended to be primarily a debugging routine. | |
277 | */ | |
278 | void | |
279 | __fp_nquery(msg, len, file) | |
280 | const u_char *msg; | |
281 | int len; | |
282 | FILE *file; | |
283 | { | |
284 | register const u_char *cp, *endMark; | |
285 | register const HEADER *hp; | |
286 | register int n; | |
287 | ||
288 | #define TruncTest(x) if (x >= endMark) goto trunc | |
289 | #define ErrorTest(x) if (x == NULL) goto error | |
290 | ||
291 | /* | |
292 | * Print header fields. | |
293 | */ | |
294 | hp = (HEADER *)msg; | |
295 | cp = msg + HFIXEDSZ; | |
296 | endMark = cp + len; | |
297 | if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEADX) || hp->rcode) { | |
298 | fprintf(file, ";; ->>HEADER<<- opcode: %s, status: %s, id: %d", | |
299 | _res_opcodes[hp->opcode], | |
300 | _res_resultcodes[hp->rcode], | |
301 | ntohs(hp->id)); | |
302 | putc('\n', file); | |
303 | } | |
304 | putc(';', file); | |
305 | if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD2)) { | |
306 | fprintf(file, "; flags:"); | |
307 | if (hp->qr) | |
308 | fprintf(file, " qr"); | |
309 | if (hp->aa) | |
310 | fprintf(file, " aa"); | |
311 | if (hp->tc) | |
312 | fprintf(file, " tc"); | |
313 | if (hp->rd) | |
314 | fprintf(file, " rd"); | |
315 | if (hp->ra) | |
316 | fprintf(file, " ra"); | |
317 | if (hp->pr) | |
318 | fprintf(file, " pr"); | |
319 | } | |
320 | if ((!_res.pfcode) || (_res.pfcode & RES_PRF_HEAD1)) { | |
321 | fprintf(file, "; Ques: %d", ntohs(hp->qdcount)); | |
322 | fprintf(file, ", Ans: %d", ntohs(hp->ancount)); | |
323 | fprintf(file, ", Auth: %d", ntohs(hp->nscount)); | |
324 | fprintf(file, ", Addit: %d", ntohs(hp->arcount)); | |
325 | } | |
326 | if ((!_res.pfcode) || (_res.pfcode & | |
327 | (RES_PRF_HEADX | RES_PRF_HEAD2 | RES_PRF_HEAD1))) { | |
328 | putc('\n',file); | |
329 | } | |
330 | /* | |
331 | * Print question records. | |
332 | */ | |
333 | if (n = ntohs(hp->qdcount)) { | |
334 | if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES)) | |
335 | fprintf(file, ";; QUESTIONS:\n"); | |
336 | while (--n >= 0) { | |
337 | fprintf(file, ";;\t"); | |
338 | TruncTest(cp); | |
339 | cp = p_cdname(cp, msg, file); | |
340 | ErrorTest(cp); | |
341 | TruncTest(cp); | |
342 | if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES)) | |
343 | fprintf(file, ", type = %s", | |
344 | __p_type(_getshort((u_char*)cp))); | |
345 | cp += INT16SZ; | |
346 | TruncTest(cp); | |
347 | if ((!_res.pfcode) || (_res.pfcode & RES_PRF_QUES)) | |
348 | fprintf(file, ", class = %s\n", | |
349 | __p_class(_getshort((u_char*)cp))); | |
350 | cp += INT16SZ; | |
351 | putc('\n', file); | |
352 | } | |
353 | } | |
354 | /* | |
355 | * Print authoritative answer records | |
356 | */ | |
357 | TruncTest(cp); | |
358 | cp = do_rrset(msg, cp, hp->ancount, RES_PRF_ANS, file, | |
359 | ";; ANSWERS:\n"); | |
360 | ErrorTest(cp); | |
361 | ||
362 | /* | |
363 | * print name server records | |
364 | */ | |
365 | TruncTest(cp); | |
366 | cp = do_rrset(msg, cp, hp->nscount, RES_PRF_AUTH, file, | |
367 | ";; AUTHORITY RECORDS:\n"); | |
368 | ErrorTest(cp); | |
369 | ||
370 | TruncTest(cp); | |
371 | /* | |
372 | * print additional records | |
373 | */ | |
374 | cp = do_rrset(msg, cp, hp->arcount, RES_PRF_ADD, file, | |
375 | ";; ADDITIONAL RECORDS:\n"); | |
376 | ErrorTest(cp); | |
377 | return; | |
378 | trunc: | |
379 | fprintf(file, "\n;; ...truncated\n"); | |
380 | return; | |
381 | error: | |
382 | fprintf(file, "\n;; ...malformed\n"); | |
383 | } | |
384 | ||
385 | void | |
386 | __fp_query(msg, file) | |
387 | const u_char *msg; | |
388 | FILE *file; | |
389 | { | |
390 | fp_nquery(msg, PACKETSZ, file); | |
391 | } | |
392 | ||
393 | const u_char * | |
394 | __p_cdnname(cp, msg, len, file) | |
395 | const u_char *cp, *msg; | |
396 | int len; | |
397 | FILE *file; | |
398 | { | |
399 | char name[MAXDNAME]; | |
400 | int n; | |
401 | ||
402 | if ((n = dn_expand(msg, msg + len, cp, name, sizeof name)) < 0) | |
403 | return (NULL); | |
404 | if (name[0] == '\0') | |
405 | putc('.', file); | |
406 | else | |
407 | fputs(name, file); | |
408 | return (cp + n); | |
409 | } | |
410 | ||
411 | const u_char * | |
412 | __p_cdname(cp, msg, file) | |
413 | const u_char *cp, *msg; | |
414 | FILE *file; | |
415 | { | |
416 | return (p_cdnname(cp, msg, PACKETSZ, file)); | |
417 | } | |
418 | ||
419 | /* XXX: the rest of these functions need to become length-limited, too. (vix) | |
420 | */ | |
421 | ||
422 | const u_char * | |
423 | __p_fqname(cp, msg, file) | |
424 | const u_char *cp, *msg; | |
425 | FILE *file; | |
426 | { | |
427 | char name[MAXDNAME]; | |
428 | int n, len; | |
429 | ||
430 | if ((n = dn_expand(msg, cp + MAXCDNAME, cp, name, sizeof name)) < 0) | |
431 | return (NULL); | |
432 | if (name[0] == '\0') { | |
433 | putc('.', file); | |
434 | } else { | |
435 | fputs(name, file); | |
436 | if (name[strlen(name) - 1] != '.') | |
437 | putc('.', file); | |
438 | } | |
439 | return (cp + n); | |
440 | } | |
441 | ||
442 | /* | |
443 | * Print resource record fields in human readable form. | |
444 | */ | |
445 | const u_char * | |
446 | __p_rr(cp, msg, file) | |
447 | const u_char *cp, *msg; | |
448 | FILE *file; | |
449 | { | |
450 | int type, class, dlen, n, c; | |
451 | struct in_addr inaddr; | |
452 | const u_char *cp1, *cp2; | |
453 | u_int32_t tmpttl, t; | |
454 | int lcnt; | |
455 | ||
456 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
457 | return (NULL); /* compression error */ | |
458 | type = _getshort((u_char*)cp); | |
459 | cp += INT16SZ; | |
460 | class = _getshort((u_char*)cp); | |
461 | cp += INT16SZ; | |
462 | tmpttl = _getlong((u_char*)cp); | |
463 | cp += INT32SZ; | |
464 | dlen = _getshort((u_char*)cp); | |
465 | cp += INT16SZ; | |
466 | cp1 = cp; | |
467 | if ((!_res.pfcode) || (_res.pfcode & RES_PRF_TTLID)) | |
468 | fprintf(file, "\t%lu", tmpttl); | |
469 | if ((!_res.pfcode) || (_res.pfcode & RES_PRF_CLASS)) | |
470 | fprintf(file, "\t%s", __p_class(class)); | |
471 | fprintf(file, "\t%s", __p_type(type)); | |
472 | /* | |
473 | * Print type specific data, if appropriate | |
474 | */ | |
475 | switch (type) { | |
476 | case T_A: | |
477 | switch (class) { | |
478 | case C_IN: | |
479 | case C_HS: | |
480 | bcopy(cp, (char *)&inaddr, INADDRSZ); | |
481 | if (dlen == 4) { | |
482 | fprintf(file, "\t%s", inet_ntoa(inaddr)); | |
483 | cp += dlen; | |
484 | } else if (dlen == 7) { | |
485 | char *address; | |
486 | u_char protocol; | |
487 | u_short port; | |
488 | ||
489 | address = inet_ntoa(inaddr); | |
490 | cp += INADDRSZ; | |
491 | protocol = *(u_char*)cp; | |
492 | cp += sizeof(u_char); | |
493 | port = _getshort((u_char*)cp); | |
494 | cp += INT16SZ; | |
495 | fprintf(file, "\t%s\t; proto %d, port %d", | |
496 | address, protocol, port); | |
497 | } | |
498 | break; | |
499 | default: | |
500 | cp += dlen; | |
501 | } | |
502 | break; | |
503 | case T_CNAME: | |
504 | case T_MB: | |
505 | case T_MG: | |
506 | case T_MR: | |
507 | case T_NS: | |
508 | case T_PTR: | |
509 | putc('\t', file); | |
510 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
511 | return (NULL); | |
512 | break; | |
513 | ||
514 | case T_HINFO: | |
515 | case T_ISDN: | |
516 | cp2 = cp + dlen; | |
517 | if (n = *cp++) { | |
518 | fprintf(file, "\t%.*s", n, cp); | |
519 | cp += n; | |
520 | } | |
521 | if ((cp < cp2) && (n = *cp++)) { | |
522 | fprintf(file, "\t%.*s", n, cp); | |
523 | cp += n; | |
524 | } else if (type == T_HINFO) | |
525 | fprintf(file, "\n;; *** Warning *** OS-type missing"); | |
526 | break; | |
527 | ||
528 | case T_SOA: | |
529 | putc('\t', file); | |
530 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
531 | return (NULL); | |
532 | putc(' ', file); | |
533 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
534 | return (NULL); | |
535 | fputs(" (\n", file); | |
536 | t = _getlong((u_char*)cp); cp += INT32SZ; | |
537 | fprintf(file, "\t\t\t%lu\t; serial\n", t); | |
538 | t = _getlong((u_char*)cp); cp += INT32SZ; | |
539 | fprintf(file, "\t\t\t%lu\t; refresh (%s)\n", t, __p_time(t)); | |
540 | t = _getlong((u_char*)cp); cp += INT32SZ; | |
541 | fprintf(file, "\t\t\t%lu\t; retry (%s)\n", t, __p_time(t)); | |
542 | t = _getlong((u_char*)cp); cp += INT32SZ; | |
543 | fprintf(file, "\t\t\t%lu\t; expire (%s)\n", t, __p_time(t)); | |
544 | t = _getlong((u_char*)cp); cp += INT32SZ; | |
545 | fprintf(file, "\t\t\t%lu )\t; minimum (%s)", t, __p_time(t)); | |
546 | break; | |
547 | ||
548 | case T_MX: | |
549 | case T_AFSDB: | |
550 | case T_RT: | |
551 | fprintf(file, "\t%d ", _getshort((u_char*)cp)); | |
552 | cp += INT16SZ; | |
553 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
554 | return (NULL); | |
555 | break; | |
556 | ||
557 | case T_PX: | |
558 | fprintf(file, "\t%d ", _getshort((u_char*)cp)); | |
559 | cp += INT16SZ; | |
560 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
561 | return (NULL); | |
562 | putc(' ', file); | |
563 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
564 | return (NULL); | |
565 | break; | |
566 | ||
567 | case T_TXT: | |
568 | case T_X25: | |
569 | (void) fputs("\t\"", file); | |
570 | cp2 = cp1 + dlen; | |
571 | while (cp < cp2) { | |
572 | if (n = (unsigned char) *cp++) { | |
573 | for (c = n; c > 0 && cp < cp2; c--) | |
574 | if ((*cp == '\n') || (*cp == '"')) { | |
575 | (void) putc('\\', file); | |
576 | (void) putc(*cp++, file); | |
577 | } else | |
578 | (void) putc(*cp++, file); | |
579 | } | |
580 | } | |
581 | putc('"', file); | |
582 | break; | |
583 | ||
584 | case T_NSAP: | |
585 | (void) fprintf(file, "\t%s", inet_nsap_ntoa(dlen, cp, NULL)); | |
586 | cp += dlen; | |
587 | break; | |
588 | ||
589 | case T_MINFO: | |
590 | case T_RP: | |
591 | putc('\t', file); | |
592 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
593 | return (NULL); | |
594 | putc(' ', file); | |
595 | if ((cp = p_fqname(cp, msg, file)) == NULL) | |
596 | return (NULL); | |
597 | break; | |
598 | ||
599 | case T_UINFO: | |
600 | putc('\t', file); | |
601 | fputs((char *)cp, file); | |
602 | cp += dlen; | |
603 | break; | |
604 | ||
605 | case T_UID: | |
606 | case T_GID: | |
607 | if (dlen == 4) { | |
608 | fprintf(file, "\t%u", _getlong((u_char*)cp)); | |
609 | cp += INT32SZ; | |
610 | } | |
611 | break; | |
612 | ||
613 | case T_WKS: | |
614 | if (dlen < INT32SZ + 1) | |
615 | break; | |
616 | bcopy(cp, (char *)&inaddr, INADDRSZ); | |
617 | cp += INT32SZ; | |
618 | fprintf(file, "\t%s %s ( ", | |
619 | inet_ntoa(inaddr), | |
620 | deproto((int) *cp)); | |
621 | cp += sizeof(u_char); | |
622 | n = 0; | |
623 | lcnt = 0; | |
624 | while (cp < cp1 + dlen) { | |
625 | c = *cp++; | |
626 | do { | |
627 | if (c & 0200) { | |
628 | if (lcnt == 0) { | |
629 | fputs("\n\t\t\t", file); | |
630 | lcnt = 5; | |
631 | } | |
632 | fputs(dewks(n), file); | |
633 | putc(' ', file); | |
634 | lcnt--; | |
635 | } | |
636 | c <<= 1; | |
637 | } while (++n & 07); | |
638 | } | |
639 | putc(')', file); | |
640 | break; | |
641 | ||
642 | #ifdef ALLOW_T_UNSPEC | |
643 | case T_UNSPEC: | |
644 | { | |
645 | int NumBytes = 8; | |
646 | u_char *DataPtr; | |
647 | int i; | |
648 | ||
649 | if (dlen < NumBytes) NumBytes = dlen; | |
650 | fprintf(file, "\tFirst %d bytes of hex data:", | |
651 | NumBytes); | |
652 | for (i = 0, DataPtr = cp; i < NumBytes; i++, DataPtr++) | |
653 | fprintf(file, " %x", *DataPtr); | |
654 | cp += dlen; | |
655 | } | |
656 | break; | |
657 | #endif /* ALLOW_T_UNSPEC */ | |
658 | ||
659 | default: | |
660 | fprintf(file, "\t?%d?", type); | |
661 | cp += dlen; | |
662 | } | |
663 | #if 0 | |
664 | fprintf(file, "\t; dlen=%d, ttl %s\n", dlen, __p_time(tmpttl)); | |
665 | #else | |
666 | putc('\n', file); | |
667 | #endif | |
668 | if (cp - cp1 != dlen) { | |
669 | fprintf(file, ";; packet size error (found %d, dlen was %d)\n", | |
670 | cp - cp1, dlen); | |
671 | cp = NULL; | |
672 | } | |
673 | return (cp); | |
674 | } | |
675 | ||
676 | static char nbuf[40]; | |
677 | ||
678 | /* | |
679 | * Return a string for the type | |
680 | */ | |
681 | const char * | |
682 | __p_type(type) | |
683 | int type; | |
684 | { | |
685 | switch (type) { | |
686 | case T_A: return "A"; | |
687 | case T_NS: return "NS"; | |
688 | case T_CNAME: return "CNAME"; | |
689 | case T_SOA: return "SOA"; | |
690 | case T_MB: return "MB"; | |
691 | case T_MG: return "MG"; | |
692 | case T_MR: return "MR"; | |
693 | case T_NULL: return "NULL"; | |
694 | case T_WKS: return "WKS"; | |
695 | case T_PTR: return "PTR"; | |
696 | case T_HINFO: return "HINFO"; | |
697 | case T_MINFO: return "MINFO"; | |
698 | case T_MX: return "MX"; | |
699 | case T_TXT: return "TXT"; | |
700 | case T_RP: return "RP"; | |
701 | case T_AFSDB: return "AFSDB"; | |
702 | case T_X25: return "X25"; | |
703 | case T_ISDN: return "ISDN"; | |
704 | case T_RT: return "RT"; | |
705 | case T_NSAP: return "NSAP"; | |
706 | case T_NSAP_PTR: return "NSAP_PTR"; | |
707 | case T_SIG: return "SIG"; | |
708 | case T_KEY: return "KEY"; | |
709 | case T_PX: return "PX"; | |
710 | case T_GPOS: return "GPOS"; | |
711 | case T_AAAA: return "AAAA"; | |
712 | case T_LOC: return "LOC"; | |
713 | case T_AXFR: return "AXFR"; | |
714 | case T_MAILB: return "MAILB"; | |
715 | case T_MAILA: return "MAILA"; | |
716 | case T_ANY: return "ANY"; | |
717 | case T_UINFO: return "UINFO"; | |
718 | case T_UID: return "UID"; | |
719 | case T_GID: return "GID"; | |
720 | #ifdef ALLOW_T_UNSPEC | |
721 | case T_UNSPEC: return "UNSPEC"; | |
722 | #endif /* ALLOW_T_UNSPEC */ | |
723 | default: (void)sprintf(nbuf, "%d", type); return (nbuf); | |
724 | } | |
725 | } | |
726 | ||
727 | /* | |
728 | * Return a mnemonic for class | |
729 | */ | |
730 | const char * | |
731 | __p_class(class) | |
732 | int class; | |
733 | { | |
734 | switch (class) { | |
735 | case C_IN: return "IN"; | |
736 | case C_HS: return "HS"; | |
737 | case C_ANY: return "ANY"; | |
738 | default: (void)sprintf(nbuf, "%d", class); return (nbuf); | |
739 | } | |
740 | } | |
741 | ||
742 | /* | |
743 | * Return a mnemonic for an option | |
744 | */ | |
745 | const char * | |
746 | __p_option(option) | |
747 | u_long option; | |
748 | { | |
749 | switch (option) { | |
750 | case RES_INIT: return "init"; | |
751 | case RES_DEBUG: return "debug"; | |
752 | case RES_AAONLY: return "aaonly"; | |
753 | case RES_USEVC: return "usevc"; | |
754 | case RES_PRIMARY: return "primry"; | |
755 | case RES_IGNTC: return "igntc"; | |
756 | case RES_RECURSE: return "recurs"; | |
757 | case RES_DEFNAMES: return "defnam"; | |
758 | case RES_STAYOPEN: return "styopn"; | |
759 | case RES_DNSRCH: return "dnsrch"; | |
760 | case RES_INSECURE1: return "insecure1"; | |
761 | case RES_INSECURE2: return "insecure2"; | |
762 | default: sprintf(nbuf, "?0x%x?", option); return (nbuf); | |
763 | } | |
764 | } | |
765 | ||
766 | /* | |
767 | * Return a mnemonic for a time to live | |
768 | */ | |
769 | char * | |
770 | __p_time(value) | |
771 | u_int32_t value; | |
772 | { | |
773 | int secs, mins, hours, days; | |
774 | register char *p; | |
775 | ||
776 | if (value == 0) { | |
777 | strcpy(nbuf, "0 secs"); | |
778 | return (nbuf); | |
779 | } | |
780 | ||
781 | secs = value % 60; | |
782 | value /= 60; | |
783 | mins = value % 60; | |
784 | value /= 60; | |
785 | hours = value % 24; | |
786 | value /= 24; | |
787 | days = value; | |
788 | value = 0; | |
789 | ||
790 | #define PLURALIZE(x) x, (x == 1) ? "" : "s" | |
791 | p = nbuf; | |
792 | if (days) { | |
793 | (void)sprintf(p, "%d day%s", PLURALIZE(days)); | |
794 | while (*++p); | |
795 | } | |
796 | if (hours) { | |
797 | if (days) | |
798 | *p++ = ' '; | |
799 | (void)sprintf(p, "%d hour%s", PLURALIZE(hours)); | |
800 | while (*++p); | |
801 | } | |
802 | if (mins) { | |
803 | if (days || hours) | |
804 | *p++ = ' '; | |
805 | (void)sprintf(p, "%d min%s", PLURALIZE(mins)); | |
806 | while (*++p); | |
807 | } | |
808 | if (secs || ! (days || hours || mins)) { | |
809 | if (days || hours || mins) | |
810 | *p++ = ' '; | |
811 | (void)sprintf(p, "%d sec%s", PLURALIZE(secs)); | |
812 | } | |
813 | return (nbuf); | |
814 | } |