Context Navigation

source: rtems-libbsd/freebsd/lib/libc/resolv/res_debug.c @ 2017a6d

55-freebsd-126-freebsd-12freebsd-9.3

Last change on this file since 2017a6d was 165dd8e, checked in by Sebastian Huber <sebastian.huber@…>, on 04/08/15 at 13:37:49
Update to FreeBSD Stable/9 2015-04-08
Property mode set to `100644`
File size: 32.4 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: