OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libc/] [sys/] [linux/] [net/] [res_debug.c] - Blame information for rev 207

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.