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