res_debug.c@ 77775

Last change on this file since 77775 was 77662, checked in by vboxsync, 6 years ago
EFI: First step in UDK2018 merge. Does not build yet.
Property svn:eol-style set to `native`
File size: 27.7 KB

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

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

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/StdLib/BsdSocketLib/res_debug.c@ 77775

Download in other formats: