Context Navigation

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

4.1155-freebsd-126-freebsd-12freebsd-9.3

Last change on this file since d48955b was d48955b, checked in by Sebastian Huber <sebastian.huber@…>, on 11/06/13 at 08:02:16
Add and use <machine/rtems-bsd-user-space.h>
Property mode set to `100644`
File size: 31.6 KB

Line
1	#include <machine/rtems-bsd-user-space.h>
2
3	/*
4	* Copyright (c) 1985
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	* 4. Neither the name of the University nor the names of its contributors
16	* may be used to endorse or promote products derived from this software
17	* without specific prior written permission.
18	*
19	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29	* SUCH DAMAGE.
30	*/
31
32	/*
33	* Portions Copyright (c) 1993 by Digital Equipment Corporation.
34	*
35	* Permission to use, copy, modify, and distribute this software for any
36	* purpose with or without fee is hereby granted, provided that the above
37	* copyright notice and this permission notice appear in all copies, and that
38	* the name of Digital Equipment Corporation not be used in advertising or
39	* publicity pertaining to distribution of the document or software without
40	* specific, written prior permission.
41	*
42	* THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
43	* WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
44	* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
45	* CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
46	* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
47	* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
48	* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
49	* SOFTWARE.
50	*/
51
52	/*
53	* Portions Copyright (c) 1995 by International Business Machines, Inc.
54	*
55	* International Business Machines, Inc. (hereinafter called IBM) grants
56	* permission under its copyrights to use, copy, modify, and distribute this
57	* Software with or without fee, provided that the above copyright notice and
58	* all paragraphs of this notice appear in all copies, and that the name of IBM
59	* not be used in connection with the marketing of any product incorporating
60	* the Software or modifications thereof, without specific, written prior
61	* permission.
62	*
63	* To the extent it has a right to do so, IBM grants an immunity from suit
64	* under its patents, if any, for the use, sale or manufacture of products to
65	* the extent that such products are used for performing Domain Name System
66	* dynamic updates in TCP/IP networks by means of the Software. No immunity is
67	* granted for any product per se or for any other function of any product.
68	*
69	* THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
70	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
71	* PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
72	* DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
73	* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
74	* IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
75	*/
76
77	/*
78	* Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
79	* Portions Copyright (c) 1996-1999 by Internet Software Consortium.
80	*
81	* Permission to use, copy, modify, and distribute this software for any
82	* purpose with or without fee is hereby granted, provided that the above
83	* copyright notice and this permission notice appear in all copies.
84	*
85	* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
86	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
87	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
88	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
89	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
90	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
91	* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
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.10.18.6 2008/04/03 23:15:15 marka 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_tkey, "TKEY", "tkey"},
500	{ns_t_tsig, "TSIG", "transaction signature"},
501	{ns_t_ixfr, "IXFR", "incremental zone transfer"},
502	{ns_t_axfr, "AXFR", "zone transfer"},
503	{ns_t_zxfr, "ZXFR", "compressed zone transfer"},
504	{ns_t_mailb, "MAILB", "mailbox-related data (deprecated)"},
505	{ns_t_maila, "MAILA", "mail agent (deprecated)"},
506	{ns_t_naptr, "NAPTR", "URN Naming Authority"},
507	{ns_t_kx, "KX", "Key Exchange"},
508	{ns_t_cert, "CERT", "Certificate"},
509	{ns_t_a6, "A6", "IPv6 Address"},
510	{ns_t_dname, "DNAME", "dname"},
511	{ns_t_sink, "SINK", "Kitchen Sink (experimental)"},
512	{ns_t_opt, "OPT", "EDNS Options"},
513	{ns_t_any, "ANY", "\"any\""},
514	{0, NULL, NULL}
515	};
516
517	/*%
518	* Names of DNS rcodes.
519	*/
520	const struct res_sym __p_rcode_syms[] = {
521	{ns_r_noerror, "NOERROR", "no error"},
522	{ns_r_formerr, "FORMERR", "format error"},
523	{ns_r_servfail, "SERVFAIL", "server failed"},
524	{ns_r_nxdomain, "NXDOMAIN", "no such domain name"},
525	{ns_r_notimpl, "NOTIMP", "not implemented"},
526	{ns_r_refused, "REFUSED", "refused"},
527	{ns_r_yxdomain, "YXDOMAIN", "domain name exists"},
528	{ns_r_yxrrset, "YXRRSET", "rrset exists"},
529	{ns_r_nxrrset, "NXRRSET", "rrset doesn't exist"},
530	{ns_r_notauth, "NOTAUTH", "not authoritative"},
531	{ns_r_notzone, "NOTZONE", "Not in zone"},
532	{ns_r_max, "", ""},
533	{ns_r_badsig, "BADSIG", "bad signature"},
534	{ns_r_badkey, "BADKEY", "bad key"},
535	{ns_r_badtime, "BADTIME", "bad time"},
536	{0, NULL, NULL}
537	};
538
539	int
540	sym_ston(const struct res_sym syms, const char name, int *success) {
541	for ((void)NULL; syms->name != 0; syms++) {
542	if (strcasecmp (name, syms->name) == 0) {
543	if (success)
544	*success = 1;
545	return (syms->number);
546	}
547	}
548	if (success)
549	*success = 0;
550	return (syms->number); /%< The default value. /
551	}
552
553	const char *
554	sym_ntos(const struct res_sym syms, int number, int success) {
555	char *unname = sym_ntos_unname;
556
557	for ((void)NULL; syms->name != 0; syms++) {
558	if (number == syms->number) {
559	if (success)
560	*success = 1;
561	return (syms->name);
562	}
563	}
564
565	sprintf(unname, "%d", number); /%< XXX nonreentrant /
566	if (success)
567	*success = 0;
568	return (unname);
569	}
570
571	const char *
572	sym_ntop(const struct res_sym syms, int number, int success) {
573	char *unname = sym_ntop_unname;
574
575	for ((void)NULL; syms->name != 0; syms++) {
576	if (number == syms->number) {
577	if (success)
578	*success = 1;
579	return (syms->humanname);
580	}
581	}
582	sprintf(unname, "%d", number); /%< XXX nonreentrant /
583	if (success)
584	*success = 0;
585	return (unname);
586	}
587
588	/*%
589	* Return a string for the type.
590	*/
591	const char *
592	p_type(int type) {
593	int success;
594	const char *result;
595	static char typebuf[20];
596
597	result = sym_ntos(__p_type_syms, type, &success);
598	if (success)
599	return (result);
600	if (type < 0 \|\| type > 0xffff)
601	return ("BADTYPE");
602	sprintf(typebuf, "TYPE%d", type);
603	return (typebuf);
604	}
605
606	/*%
607	* Return a string for the type.
608	*/
609	const char *
610	p_section(int section, int opcode) {
611	const struct res_sym *symbols;
612
613	switch (opcode) {
614	case ns_o_update:
615	symbols = __p_update_section_syms;
616	break;
617	default:
618	symbols = __p_default_section_syms;
619	break;
620	}
621	return (sym_ntos(symbols, section, (int *)0));
622	}
623
624	/*%
625	* Return a mnemonic for class.
626	*/
627	const char *
628	p_class(int class) {
629	int success;
630	const char *result;
631	static char classbuf[20];
632
633	result = sym_ntos(__p_class_syms, class, &success);
634	if (success)
635	return (result);
636	if (class < 0 \|\| class > 0xffff)
637	return ("BADCLASS");
638	sprintf(classbuf, "CLASS%d", class);
639	return (classbuf);
640	}
641
642	/*%
643	* Return a mnemonic for an option
644	*/
645	const char *
646	p_option(u_long option) {
647	char *nbuf = p_option_nbuf;
648
649	switch (option) {
650	case RES_INIT: return "init";
651	case RES_DEBUG: return "debug";
652	case RES_AAONLY: return "aaonly(unimpl)";
653	case RES_USEVC: return "usevc";
654	case RES_PRIMARY: return "primry(unimpl)";
655	case RES_IGNTC: return "igntc";
656	case RES_RECURSE: return "recurs";
657	case RES_DEFNAMES: return "defnam";
658	case RES_STAYOPEN: return "styopn";
659	case RES_DNSRCH: return "dnsrch";
660	case RES_INSECURE1: return "insecure1";
661	case RES_INSECURE2: return "insecure2";
662	case RES_NOALIASES: return "noaliases";
663	case RES_USE_INET6: return "inet6";
664	#ifdef RES_USE_EDNS0 /%< KAME extension /
665	case RES_USE_EDNS0: return "edns0";
666	case RES_NSID: return "nsid";
667	#endif
668	#ifdef RES_USE_DNAME
669	case RES_USE_DNAME: return "dname";
670	#endif
671	#ifdef RES_USE_DNSSEC
672	case RES_USE_DNSSEC: return "dnssec";
673	#endif
674	#ifdef RES_NOTLDQUERY
675	case RES_NOTLDQUERY: return "no-tld-query";
676	#endif
677	#ifdef RES_NO_NIBBLE2
678	case RES_NO_NIBBLE2: return "no-nibble2";
679	#endif
680	/* XXX nonreentrant */
681	default: sprintf(nbuf, "?0x%lx?", (u_long)option);
682	return (nbuf);
683	}
684	}
685
686	/*%
687	* Return a mnemonic for a time to live.
688	*/
689	const char *
690	p_time(u_int32_t value) {
691	char *nbuf = p_time_nbuf;
692
693	if (ns_format_ttl(value, nbuf, sizeof nbuf) < 0)
694	sprintf(nbuf, "%u", value);
695	return (nbuf);
696	}
697
698	/*%
699	* Return a string for the rcode.
700	*/
701	const char *
702	p_rcode(int rcode) {
703	return (sym_ntos(__p_rcode_syms, rcode, (int *)0));
704	}
705
706	/*%
707	* Return a string for a res_sockaddr_union.
708	*/
709	const char *
710	p_sockun(union res_sockaddr_union u, char *buf, size_t size) {
711	char ret[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:123.123.123.123"];
712
713	switch (u.sin.sin_family) {
714	case AF_INET:
715	inet_ntop(AF_INET, &u.sin.sin_addr, ret, sizeof ret);
716	break;
717	#ifdef HAS_INET6_STRUCTS
718	case AF_INET6:
719	inet_ntop(AF_INET6, &u.sin6.sin6_addr, ret, sizeof ret);
720	break;
721	#endif
722	default:
723	sprintf(ret, "[af%d]", u.sin.sin_family);
724	break;
725	}
726	if (size > 0U) {
727	strncpy(buf, ret, size - 1);
728	buf[size - 1] = '0';
729	}
730	return (buf);
731	}
732
733	/*%
734	* routines to convert between on-the-wire RR format and zone file format.
735	* Does not contain conversion to/from decimal degrees; divide or multiply
736	* by 60601000 for that.
737	*/
738
739	static unsigned int poweroften[10] = {1, 10, 100, 1000, 10000, 100000,
740	1000000,10000000,100000000,1000000000};
741
742	/% takes an XeY precision/size value, returns a string representation. /
743	static const char *
744	precsize_ntoa(prec)
745	u_int8_t prec;
746	{
747	char *retbuf = precsize_ntoa_retbuf;
748	unsigned long val;
749	int mantissa, exponent;
750
751	mantissa = (int)((prec >> 4) & 0x0f) % 10;
752	exponent = (int)((prec >> 0) & 0x0f) % 10;
753
754	val = mantissa * poweroften[exponent];
755
756	(void) sprintf(retbuf, "%lu.%.2lu", val/100, val%100);
757	return (retbuf);
758	}
759
760	/% converts ascii size/precision X 10*Y(cm) to 0xXY. moves pointer. /
761	static u_int8_t
762	precsize_aton(const char **strptr) {
763	unsigned int mval = 0, cmval = 0;
764	u_int8_t retval = 0;
765	const char *cp;
766	int exponent;
767	int mantissa;
768
769	cp = *strptr;
770
771	while (isdigit((unsigned char)*cp))
772	mval = mval * 10 + (*cp++ - '0');
773
774	if (cp == '.') { /%< centimeters */
775	cp++;
776	if (isdigit((unsigned char)*cp)) {
777	cmval = (cp++ - '0') 10;
778	if (isdigit((unsigned char)*cp)) {
779	cmval += (*cp++ - '0');
780	}
781	}
782	}
783	cmval = (mval * 100) + cmval;
784
785	for (exponent = 0; exponent < 9; exponent++)
786	if (cmval < poweroften[exponent+1])
787	break;
788
789	mantissa = cmval / poweroften[exponent];
790	if (mantissa > 9)
791	mantissa = 9;
792
793	retval = (mantissa << 4) \| exponent;
794
795	*strptr = cp;
796
797	return (retval);
798	}
799
800	/% converts ascii lat/lon to unsigned encoded 32-bit number. moves pointer. /
801	static u_int32_t
802	latlon2ul(const char *latlonstrptr, int which) {
803	const char *cp;
804	u_int32_t retval;
805	int deg = 0, min = 0, secs = 0, secsfrac = 0;
806
807	cp = *latlonstrptr;
808
809	while (isdigit((unsigned char)*cp))
810	deg = deg * 10 + (*cp++ - '0');
811
812	while (isspace((unsigned char)*cp))
813	cp++;
814
815	if (!(isdigit((unsigned char)*cp)))
816	goto fndhemi;
817
818	while (isdigit((unsigned char)*cp))
819	min = min * 10 + (*cp++ - '0');
820
821	while (isspace((unsigned char)*cp))
822	cp++;
823
824	if (!(isdigit((unsigned char)*cp)))
825	goto fndhemi;
826
827	while (isdigit((unsigned char)*cp))
828	secs = secs * 10 + (*cp++ - '0');
829
830	if (cp == '.') { /%< decimal seconds */
831	cp++;
832	if (isdigit((unsigned char)*cp)) {
833	secsfrac = (cp++ - '0') 100;
834	if (isdigit((unsigned char)*cp)) {
835	secsfrac += (cp++ - '0') 10;
836	if (isdigit((unsigned char)*cp)) {
837	secsfrac += (*cp++ - '0');
838	}
839	}
840	}
841	}
842
843	while (!isspace((unsigned char)cp)) /%< if any trailing garbage */
844	cp++;
845
846	while (isspace((unsigned char)*cp))
847	cp++;
848
849	fndhemi:
850	switch (*cp) {
851	case 'N': case 'n':
852	case 'E': case 'e':
853	retval = ((unsigned)1<<31)
854	+ (((((deg * 60) + min) * 60) + secs) * 1000)
855	+ secsfrac;
856	break;
857	case 'S': case 's':
858	case 'W': case 'w':
859	retval = ((unsigned)1<<31)
860	- (((((deg * 60) + min) * 60) + secs) * 1000)
861	- secsfrac;
862	break;
863	default:
864	retval = 0; /%< invalid value -- indicates error /
865	break;
866	}
867
868	switch (*cp) {
869	case 'N': case 'n':
870	case 'S': case 's':
871	which = 1; /%< latitude */
872	break;
873	case 'E': case 'e':
874	case 'W': case 'w':
875	which = 2; /%< longitude */
876	break;
877	default:
878	which = 0; /%< error */
879	break;
880	}
881
882	cp++; /%< skip the hemisphere /
883	while (!isspace((unsigned char)cp)) /%< if any trailing garbage */
884	cp++;
885
886	while (isspace((unsigned char)cp)) /%< move to next field */
887	cp++;
888
889	*latlonstrptr = cp;
890
891	return (retval);
892	}
893
894	/*%
895	* converts a zone file representation in a string to an RDATA on-the-wire
896	* representation. */
897	int
898	loc_aton(ascii, binary)
899	const char *ascii;
900	u_char *binary;
901	{
902	const char cp, maxcp;
903	u_char *bcp;
904
905	u_int32_t latit = 0, longit = 0, alt = 0;
906	u_int32_t lltemp1 = 0, lltemp2 = 0;
907	int altmeters = 0, altfrac = 0, altsign = 1;
908	u_int8_t hp = 0x16; /%< default = 1e6 cm = 10000.00m = 10km /
909	u_int8_t vp = 0x13; /%< default = 1e3 cm = 10.00m /
910	u_int8_t siz = 0x12; /%< default = 1e2 cm = 1.00m /
911	int which1 = 0, which2 = 0;
912
913	cp = ascii;
914	maxcp = cp + strlen(ascii);
915
916	lltemp1 = latlon2ul(&cp, &which1);
917
918	lltemp2 = latlon2ul(&cp, &which2);
919
920	switch (which1 + which2) {
921	case 3: /%< 1 + 2, the only valid combination /
922	if ((which1 == 1) && (which2 == 2)) { /%< normal case /
923	latit = lltemp1;
924	longit = lltemp2;
925	} else if ((which1 == 2) && (which2 == 1)) { /%< reversed /
926	longit = lltemp1;
927	latit = lltemp2;
928	} else { /%< some kind of brokenness /
929	return (0);
930	}
931	break;
932	default: /%< we didn't get one of each /
933	return (0);
934	}
935
936	/* altitude */
937	if (*cp == '-') {
938	altsign = -1;
939	cp++;
940	}
941
942	if (*cp == '+')
943	cp++;
944
945	while (isdigit((unsigned char)*cp))
946	altmeters = altmeters * 10 + (*cp++ - '0');
947
948	if (cp == '.') { /%< decimal meters */
949	cp++;
950	if (isdigit((unsigned char)*cp)) {
951	altfrac = (cp++ - '0') 10;
952	if (isdigit((unsigned char)*cp)) {
953	altfrac += (*cp++ - '0');
954	}
955	}
956	}
957
958	alt = (10000000 + (altsign * (altmeters * 100 + altfrac)));
959
960	while (!isspace((unsigned char)cp) && (cp < maxcp)) /%< if trailing garbage or m */
961	cp++;
962
963	while (isspace((unsigned char)*cp) && (cp < maxcp))
964	cp++;
965
966	if (cp >= maxcp)
967	goto defaults;
968
969	siz = precsize_aton(&cp);
970
971	while (!isspace((unsigned char)cp) && (cp < maxcp)) /%< if trailing garbage or m */
972	cp++;
973
974	while (isspace((unsigned char)*cp) && (cp < maxcp))
975	cp++;
976
977	if (cp >= maxcp)
978	goto defaults;
979
980	hp = precsize_aton(&cp);
981
982	while (!isspace((unsigned char)cp) && (cp < maxcp)) /%< if trailing garbage or m */
983	cp++;
984
985	while (isspace((unsigned char)*cp) && (cp < maxcp))
986	cp++;
987
988	if (cp >= maxcp)
989	goto defaults;
990
991	vp = precsize_aton(&cp);
992
993	defaults:
994
995	bcp = binary;
996	bcp++ = (u_int8_t) 0; /%< version byte */
997	*bcp++ = siz;
998	*bcp++ = hp;
999	*bcp++ = vp;
1000	PUTLONG(latit,bcp);
1001	PUTLONG(longit,bcp);
1002	PUTLONG(alt,bcp);
1003
1004	return (16); /%< size of RR in octets /
1005	}
1006
1007	/% takes an on-the-wire LOC RR and formats it in a human readable format. /
1008	const char *
1009	loc_ntoa(binary, ascii)
1010	const u_char *binary;
1011	char *ascii;
1012	{
1013	static const char *error = "?";
1014	static char tmpbuf[sizeof
1015	"1000 60 60.000 N 1000 60 60.000 W -12345678.00m 90000000.00m 90000000.00m 90000000.00m"];
1016	const u_char *cp = binary;
1017
1018	int latdeg, latmin, latsec, latsecfrac;
1019	int longdeg, longmin, longsec, longsecfrac;
1020	char northsouth, eastwest;
1021	const char *altsign;
1022	int altmeters, altfrac;
1023
1024	const u_int32_t referencealt = 100000 * 100;
1025
1026	int32_t latval, longval, altval;
1027	u_int32_t templ;
1028	u_int8_t sizeval, hpval, vpval, versionval;
1029
1030	char sizestr, hpstr, *vpstr;
1031
1032	versionval = *cp++;
1033
1034	if (ascii == NULL)
1035	ascii = tmpbuf;
1036
1037	if (versionval) {
1038	(void) sprintf(ascii, "; error: unknown LOC RR version");
1039	return (ascii);
1040	}
1041
1042	sizeval = *cp++;
1043
1044	hpval = *cp++;
1045	vpval = *cp++;
1046
1047	GETLONG(templ, cp);
1048	latval = (templ - ((unsigned)1<<31));
1049
1050	GETLONG(templ, cp);
1051	longval = (templ - ((unsigned)1<<31));
1052
1053	GETLONG(templ, cp);
1054	if (templ < referencealt) { /%< below WGS 84 spheroid /
1055	altval = referencealt - templ;
1056	altsign = "-";
1057	} else {
1058	altval = templ - referencealt;
1059	altsign = "";
1060	}
1061
1062	if (latval < 0) {
1063	northsouth = 'S';
1064	latval = -latval;
1065	} else
1066	northsouth = 'N';
1067
1068	latsecfrac = latval % 1000;
1069	latval = latval / 1000;
1070	latsec = latval % 60;
1071	latval = latval / 60;
1072	latmin = latval % 60;
1073	latval = latval / 60;
1074	latdeg = latval;
1075
1076	if (longval < 0) {
1077	eastwest = 'W';
1078	longval = -longval;
1079	} else
1080	eastwest = 'E';
1081
1082	longsecfrac = longval % 1000;
1083	longval = longval / 1000;
1084	longsec = longval % 60;
1085	longval = longval / 60;
1086	longmin = longval % 60;
1087	longval = longval / 60;
1088	longdeg = longval;
1089
1090	altfrac = altval % 100;
1091	altmeters = (altval / 100);
1092
1093	sizestr = strdup(precsize_ntoa(sizeval));
1094	hpstr = strdup(precsize_ntoa(hpval));
1095	vpstr = strdup(precsize_ntoa(vpval));
1096
1097	sprintf(ascii,
1098	"%d %.2d %.2d.%.3d %c %d %.2d %.2d.%.3d %c %s%d.%.2dm %sm %sm %sm",
1099	latdeg, latmin, latsec, latsecfrac, northsouth,
1100	longdeg, longmin, longsec, longsecfrac, eastwest,
1101	altsign, altmeters, altfrac,
1102	(sizestr != NULL) ? sizestr : error,
1103	(hpstr != NULL) ? hpstr : error,
1104	(vpstr != NULL) ? vpstr : error);
1105
1106	if (sizestr != NULL)
1107	free(sizestr);
1108	if (hpstr != NULL)
1109	free(hpstr);
1110	if (vpstr != NULL)
1111	free(vpstr);
1112
1113	return (ascii);
1114	}
1115
1116
1117	/% Return the number of DNS hierarchy levels in the name. /
1118	int
1119	dn_count_labels(const char *name) {
1120	int i, len, count;
1121
1122	len = strlen(name);
1123	for (i = 0, count = 0; i < len; i++) {
1124	/* XXX need to check for \. or use named's nlabels(). */
1125	if (name[i] == '.')
1126	count++;
1127	}
1128
1129	/* don't count initial wildcard */
1130	if (name[0] == '*')
1131	if (count)
1132	count--;
1133
1134	/* don't count the null label for root. */
1135	/* if terminating '.' not found, must adjust */
1136	/* count to include last label */
1137	if (len > 0 && name[len-1] != '.')
1138	count++;
1139	return (count);
1140	}
1141
1142	/*%
1143	* Make dates expressed in seconds-since-Jan-1-1970 easy to read.
1144	* SIG records are required to be printed like this, by the Secure DNS RFC.
1145	*/
1146	char *
1147	p_secstodate (u_long secs) {
1148	char *output = p_secstodate_output;
1149	time_t clock = secs;
1150	struct tm *time;
1151	#ifdef HAVE_TIME_R
1152	struct tm res;
1153
1154	time = gmtime_r(&clock, &res);
1155	#else
1156	time = gmtime(&clock);
1157	#endif
1158	time->tm_year += 1900;
1159	time->tm_mon += 1;
1160	sprintf(output, "%04d%02d%02d%02d%02d%02d",
1161	time->tm_year, time->tm_mon, time->tm_mday,
1162	time->tm_hour, time->tm_min, time->tm_sec);
1163	return (output);
1164	}
1165
1166	u_int16_t
1167	res_nametoclass(const char buf, int successp) {
1168	unsigned long result;
1169	char *endptr;
1170	int success;
1171
1172	result = sym_ston(__p_class_syms, buf, &success);
1173	if (success)
1174	goto done;
1175
1176	if (strncasecmp(buf, "CLASS", 5) != 0 \|\|
1177	!isdigit((unsigned char)buf[5]))
1178	goto done;
1179	errno = 0;
1180	result = strtoul(buf + 5, &endptr, 10);
1181	if (errno == 0 && *endptr == '\0' && result <= 0xffffU)
1182	success = 1;
1183	done:
1184	if (successp)
1185	*successp = success;
1186	return (result);
1187	}
1188
1189	u_int16_t
1190	res_nametotype(const char buf, int successp) {
1191	unsigned long result;
1192	char *endptr;
1193	int success;
1194
1195	result = sym_ston(__p_type_syms, buf, &success);
1196	if (success)
1197	goto done;
1198
1199	if (strncasecmp(buf, "type", 4) != 0 \|\|
1200	!isdigit((unsigned char)buf[4]))
1201	goto done;
1202	errno = 0;
1203	result = strtoul(buf + 4, &endptr, 10);
1204	if (errno == 0 && *endptr == '\0' && result <= 0xffffU)
1205	success = 1;
1206	done:
1207	if (successp)
1208	*successp = success;
1209	return (result);
1210	}
1211
1212	/*
1213	* Weak aliases for applications that use certain private entry points,
1214	* and fail to include <resolv.h>.
1215	*/
1216	#undef fp_resstat
1217	__weak_reference(__fp_resstat, fp_resstat);
1218	#undef p_fqnname
1219	__weak_reference(__p_fqnname, p_fqnname);
1220	#undef sym_ston
1221	__weak_reference(__sym_ston, sym_ston);
1222	#undef sym_ntos
1223	__weak_reference(__sym_ntos, sym_ntos);
1224	#undef sym_ntop
1225	__weak_reference(__sym_ntop, sym_ntop);
1226	#undef dn_count_labels
1227	__weak_reference(__dn_count_labels, dn_count_labels);
1228	#undef p_secstodate
1229	__weak_reference(__p_secstodate, p_secstodate);
1230
1231	/! \file /

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

Download in other formats: