?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Detect FPU by checking CPUID features.
[dragonfly.git] / contrib / bind-9.5.2 / lib / dns / name.c
blob638cdc86d00742ab2f4eefe499272f7eeab6f234
1 /*
2 * Copyright (C) 2004-2008 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1998-2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /* $Id: name.c,v 1.163.128.2 2008/03/31 23:46:42 tbox Exp $ */
19
20 /*! \file */
21
22 #include <config.h>
23
24 #include <ctype.h>
25 #include <stdlib.h>
26
27 #include <isc/buffer.h>
28 #include <isc/hash.h>
29 #include <isc/mem.h>
30 #include <isc/once.h>
31 #include <isc/print.h>
32 #include <isc/string.h>
33 #include <isc/thread.h>
34 #include <isc/util.h>
35
36 #include <dns/compress.h>
37 #include <dns/name.h>
38 #include <dns/result.h>
39
40 #define VALID_NAME(n) ISC_MAGIC_VALID(n, DNS_NAME_MAGIC)
41
42 typedef enum {
43 ft_init = 0,
44 ft_start,
45 ft_ordinary,
46 ft_initialescape,
47 ft_escape,
48 ft_escdecimal,
49 ft_at
50 } ft_state;
51
52 typedef enum {
53 fw_start = 0,
54 fw_ordinary,
55 fw_copy,
56 fw_newcurrent
57 } fw_state;
58
59 static char digitvalue[256] = {
60 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /*16*/
61 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /*32*/
62 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /*48*/
63 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, /*64*/
64 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, /*80*/
65 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /*96*/
66 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, /*112*/
67 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /*128*/
68 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
69 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
70 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
71 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
72 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
73 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
74 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
75 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /*256*/
76 };
77
78 static unsigned char maptolower[] = {
79 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
80 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
81 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
82 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
83 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
84 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
85 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
86 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
87 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
88 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
89 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
90 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
91 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
92 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
93 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
94 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
95 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
96 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
97 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
98 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
99 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
100 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
101 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
102 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
103 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
104 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
105 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
106 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
107 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
108 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
109 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
110 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
111 };
112
113 #define CONVERTTOASCII(c)
114 #define CONVERTFROMASCII(c)
115
116 #define INIT_OFFSETS(name, var, default) \
117 if (name->offsets != NULL) \
118 var = name->offsets; \
119 else \
120 var = default;
121
122 #define SETUP_OFFSETS(name, var, default) \
123 if (name->offsets != NULL) \
124 var = name->offsets; \
125 else { \
126 var = default; \
127 set_offsets(name, var, NULL); \
128 }
129
130 /*%
131 * Note: If additional attributes are added that should not be set for
132 * empty names, MAKE_EMPTY() must be changed so it clears them.
133 */
134 #define MAKE_EMPTY(name) \
135 do { \
136 name->ndata = NULL; \
137 name->length = 0; \
138 name->labels = 0; \
139 name->attributes &= ~DNS_NAMEATTR_ABSOLUTE; \
140 } while (0);
141
142 /*%
143 * A name is "bindable" if it can be set to point to a new value, i.e.
144 * name->ndata and name->length may be changed.
145 */
146 #define BINDABLE(name) \
147 ((name->attributes & (DNS_NAMEATTR_READONLY|DNS_NAMEATTR_DYNAMIC)) \
148 == 0)
149
150 /*%
151 * Note that the name data must be a char array, not a string
152 * literal, to avoid compiler warnings about discarding
153 * the const attribute of a string.
154 */
155 static unsigned char root_ndata[] = { '\0' };
156 static unsigned char root_offsets[] = { 0 };
157
158 static dns_name_t root =
159 {
160 DNS_NAME_MAGIC,
161 root_ndata, 1, 1,
162 DNS_NAMEATTR_READONLY | DNS_NAMEATTR_ABSOLUTE,
163 root_offsets, NULL,
164 {(void *)-1, (void *)-1},
165 {NULL, NULL}
166 };
167
168 /* XXXDCL make const? */
169 LIBDNS_EXTERNAL_DATA dns_name_t *dns_rootname = &root;
170
171 static unsigned char wild_ndata[] = { '\001', '*' };
172 static unsigned char wild_offsets[] = { 0 };
173
174 static dns_name_t wild =
175 {
176 DNS_NAME_MAGIC,
177 wild_ndata, 2, 1,
178 DNS_NAMEATTR_READONLY,
179 wild_offsets, NULL,
180 {(void *)-1, (void *)-1},
181 {NULL, NULL}
182 };
183
184 /* XXXDCL make const? */
185 LIBDNS_EXTERNAL_DATA dns_name_t *dns_wildcardname = &wild;
186
187 unsigned int
188 dns_fullname_hash(dns_name_t *name, isc_boolean_t case_sensitive);
189
190 /*
191 * dns_name_t to text post-conversion procedure.
192 */
193 #ifdef ISC_PLATFORM_USETHREADS
194 static int thread_key_initialized = 0;
195 static isc_mutex_t thread_key_mutex;
196 static isc_mem_t *thread_key_mctx = NULL;
197 static isc_thread_key_t totext_filter_proc_key;
198 static isc_once_t once = ISC_ONCE_INIT;
199 #else
200 static dns_name_totextfilter_t totext_filter_proc = NULL;
201 #endif
202
203 static void
204 set_offsets(const dns_name_t *name, unsigned char *offsets,
205 dns_name_t *set_name);
206
207 void
208 dns_name_init(dns_name_t *name, unsigned char *offsets) {
209 /*
210 * Initialize 'name'.
211 */
212 DNS_NAME_INIT(name, offsets);
213 }
214
215 void
216 dns_name_reset(dns_name_t *name) {
217 REQUIRE(VALID_NAME(name));
218 REQUIRE(BINDABLE(name));
219
220 DNS_NAME_RESET(name);
221 }
222
223 void
224 dns_name_invalidate(dns_name_t *name) {
225 /*
226 * Make 'name' invalid.
227 */
228
229 REQUIRE(VALID_NAME(name));
230
231 name->magic = 0;
232 name->ndata = NULL;
233 name->length = 0;
234 name->labels = 0;
235 name->attributes = 0;
236 name->offsets = NULL;
237 name->buffer = NULL;
238 ISC_LINK_INIT(name, link);
239 }
240
241 void
242 dns_name_setbuffer(dns_name_t *name, isc_buffer_t *buffer) {
243 /*
244 * Dedicate a buffer for use with 'name'.
245 */
246
247 REQUIRE(VALID_NAME(name));
248 REQUIRE((buffer != NULL && name->buffer == NULL) ||
249 (buffer == NULL));
250
251 name->buffer = buffer;
252 }
253
254 isc_boolean_t
255 dns_name_hasbuffer(const dns_name_t *name) {
256 /*
257 * Does 'name' have a dedicated buffer?
258 */
259
260 REQUIRE(VALID_NAME(name));
261
262 if (name->buffer != NULL)
263 return (ISC_TRUE);
264
265 return (ISC_FALSE);
266 }
267
268 isc_boolean_t
269 dns_name_isabsolute(const dns_name_t *name) {
270
271 /*
272 * Does 'name' end in the root label?
273 */
274
275 REQUIRE(VALID_NAME(name));
276
277 if ((name->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
278 return (ISC_TRUE);
279 return (ISC_FALSE);
280 }
281
282 #define hyphenchar(c) ((c) == 0x2d)
283 #define asterchar(c) ((c) == 0x2a)
284 #define alphachar(c) (((c) >= 0x41 && (c) <= 0x5a) \
285 || ((c) >= 0x61 && (c) <= 0x7a))
286 #define digitchar(c) ((c) >= 0x30 && (c) <= 0x39)
287 #define borderchar(c) (alphachar(c) || digitchar(c))
288 #define middlechar(c) (borderchar(c) || hyphenchar(c))
289 #define domainchar(c) ((c) > 0x20 && (c) < 0x7f)
290
291 isc_boolean_t
292 dns_name_ismailbox(const dns_name_t *name) {
293 unsigned char *ndata, ch;
294 unsigned int n;
295 isc_boolean_t first;
296
297 REQUIRE(VALID_NAME(name));
298 REQUIRE(name->labels > 0);
299 REQUIRE(name->attributes & DNS_NAMEATTR_ABSOLUTE);
300
301 /*
302 * Root label.
303 */
304 if (name->length == 1)
305 return (ISC_TRUE);
306
307 ndata = name->ndata;
308 n = *ndata++;
309 INSIST(n <= 63);
310 while (n--) {
311 ch = *ndata++;
312 if (!domainchar(ch))
313 return (ISC_FALSE);
314 }
315
316 if (ndata == name->ndata + name->length)
317 return (ISC_FALSE);
318
319 /*
320 * RFC292/RFC1123 hostname.
321 */
322 while (ndata < (name->ndata + name->length)) {
323 n = *ndata++;
324 INSIST(n <= 63);
325 first = ISC_TRUE;
326 while (n--) {
327 ch = *ndata++;
328 if (first || n == 0) {
329 if (!borderchar(ch))
330 return (ISC_FALSE);
331 } else {
332 if (!middlechar(ch))
333 return (ISC_FALSE);
334 }
335 first = ISC_FALSE;
336 }
337 }
338 return (ISC_TRUE);
339 }
340
341 isc_boolean_t
342 dns_name_ishostname(const dns_name_t *name, isc_boolean_t wildcard) {
343 unsigned char *ndata, ch;
344 unsigned int n;
345 isc_boolean_t first;
346
347 REQUIRE(VALID_NAME(name));
348 REQUIRE(name->labels > 0);
349 REQUIRE(name->attributes & DNS_NAMEATTR_ABSOLUTE);
350
351 /*
352 * Root label.
353 */
354 if (name->length == 1)
355 return (ISC_TRUE);
356
357 /*
358 * Skip wildcard if this is a ownername.
359 */
360 ndata = name->ndata;
361 if (wildcard && ndata[0] == 1 && ndata[1] == '*')
362 ndata += 2;
363
364 /*
365 * RFC292/RFC1123 hostname.
366 */
367 while (ndata < (name->ndata + name->length)) {
368 n = *ndata++;
369 INSIST(n <= 63);
370 first = ISC_TRUE;
371 while (n--) {
372 ch = *ndata++;
373 if (first || n == 0) {
374 if (!borderchar(ch))
375 return (ISC_FALSE);
376 } else {
377 if (!middlechar(ch))
378 return (ISC_FALSE);
379 }
380 first = ISC_FALSE;
381 }
382 }
383 return (ISC_TRUE);
384 }
385
386 isc_boolean_t
387 dns_name_iswildcard(const dns_name_t *name) {
388 unsigned char *ndata;
389
390 /*
391 * Is 'name' a wildcard name?
392 */
393
394 REQUIRE(VALID_NAME(name));
395 REQUIRE(name->labels > 0);
396
397 if (name->length >= 2) {
398 ndata = name->ndata;
399 if (ndata[0] == 1 && ndata[1] == '*')
400 return (ISC_TRUE);
401 }
402
403 return (ISC_FALSE);
404 }
405
406 isc_boolean_t
407 dns_name_internalwildcard(const dns_name_t *name) {
408 unsigned char *ndata;
409 unsigned int count;
410 unsigned int label;
411
412 /*
413 * Does 'name' contain a internal wildcard?
414 */
415
416 REQUIRE(VALID_NAME(name));
417 REQUIRE(name->labels > 0);
418
419 /*
420 * Skip first label.
421 */
422 ndata = name->ndata;
423 count = *ndata++;
424 INSIST(count <= 63);
425 ndata += count;
426 label = 1;
427 /*
428 * Check all but the last of the remaining labels.
429 */
430 while (label + 1 < name->labels) {
431 count = *ndata++;
432 INSIST(count <= 63);
433 if (count == 1 && *ndata == '*')
434 return (ISC_TRUE);
435 ndata += count;
436 label++;
437 }
438 return (ISC_FALSE);
439 }
440
441 static inline unsigned int
442 name_hash(dns_name_t *name, isc_boolean_t case_sensitive) {
443 unsigned int length;
444 const unsigned char *s;
445 unsigned int h = 0;
446 unsigned char c;
447
448 length = name->length;
449 if (length > 16)
450 length = 16;
451
452 /*
453 * This hash function is similar to the one Ousterhout
454 * uses in Tcl.
455 */
456 s = name->ndata;
457 if (case_sensitive) {
458 while (length > 0) {
459 h += ( h << 3 ) + *s;
460 s++;
461 length--;
462 }
463 } else {
464 while (length > 0) {
465 c = maptolower[*s];
466 h += ( h << 3 ) + c;
467 s++;
468 length--;
469 }
470 }
471
472 return (h);
473 }
474
475 unsigned int
476 dns_name_hash(dns_name_t *name, isc_boolean_t case_sensitive) {
477 /*
478 * Provide a hash value for 'name'.
479 */
480 REQUIRE(VALID_NAME(name));
481
482 if (name->labels == 0)
483 return (0);
484
485 return (name_hash(name, case_sensitive));
486 }
487
488 unsigned int
489 dns_name_fullhash(dns_name_t *name, isc_boolean_t case_sensitive) {
490 /*
491 * Provide a hash value for 'name'.
492 */
493 REQUIRE(VALID_NAME(name));
494
495 if (name->labels == 0)
496 return (0);
497
498 return (isc_hash_calc((const unsigned char *)name->ndata,
499 name->length, case_sensitive));
500 }
501
502 unsigned int
503 dns_fullname_hash(dns_name_t *name, isc_boolean_t case_sensitive) {
504 /*
505 * This function was deprecated due to the breakage of the name space
506 * convention. We only keep this internally to provide binary backward
507 * compatibility.
508 */
509 REQUIRE(VALID_NAME(name));
510
511 return (dns_name_fullhash(name, case_sensitive));
512 }
513
514 unsigned int
515 dns_name_hashbylabel(dns_name_t *name, isc_boolean_t case_sensitive) {
516 unsigned char *offsets;
517 dns_offsets_t odata;
518 dns_name_t tname;
519 unsigned int h = 0;
520 unsigned int i;
521
522 /*
523 * Provide a hash value for 'name'.
524 */
525 REQUIRE(VALID_NAME(name));
526
527 if (name->labels == 0)
528 return (0);
529 else if (name->labels == 1)
530 return (name_hash(name, case_sensitive));
531
532 SETUP_OFFSETS(name, offsets, odata);
533 DNS_NAME_INIT(&tname, NULL);
534 tname.labels = 1;
535 h = 0;
536 for (i = 0; i < name->labels; i++) {
537 tname.ndata = name->ndata + offsets[i];
538 if (i == name->labels - 1)
539 tname.length = name->length - offsets[i];
540 else
541 tname.length = offsets[i + 1] - offsets[i];
542 h += name_hash(&tname, case_sensitive);
543 }
544
545 return (h);
546 }
547
548 dns_namereln_t
549 dns_name_fullcompare(const dns_name_t *name1, const dns_name_t *name2,
550 int *orderp, unsigned int *nlabelsp)
551 {
552 unsigned int l1, l2, l, count1, count2, count, nlabels;
553 int cdiff, ldiff, chdiff;
554 unsigned char *label1, *label2;
555 unsigned char *offsets1, *offsets2;
556 dns_offsets_t odata1, odata2;
557 dns_namereln_t namereln = dns_namereln_none;
558
559 /*
560 * Determine the relative ordering under the DNSSEC order relation of
561 * 'name1' and 'name2', and also determine the hierarchical
562 * relationship of the names.
563 *
564 * Note: It makes no sense for one of the names to be relative and the
565 * other absolute. If both names are relative, then to be meaningfully
566 * compared the caller must ensure that they are both relative to the
567 * same domain.
568 */
569
570 REQUIRE(VALID_NAME(name1));
571 REQUIRE(VALID_NAME(name2));
572 REQUIRE(orderp != NULL);
573 REQUIRE(nlabelsp != NULL);
574 /*
575 * Either name1 is absolute and name2 is absolute, or neither is.
576 */
577 REQUIRE((name1->attributes & DNS_NAMEATTR_ABSOLUTE) ==
578 (name2->attributes & DNS_NAMEATTR_ABSOLUTE));
579
580 SETUP_OFFSETS(name1, offsets1, odata1);
581 SETUP_OFFSETS(name2, offsets2, odata2);
582
583 nlabels = 0;
584 l1 = name1->labels;
585 l2 = name2->labels;
586 ldiff = (int)l1 - (int)l2;
587 if (ldiff < 0)
588 l = l1;
589 else
590 l = l2;
591
592 while (l > 0) {
593 l--;
594 l1--;
595 l2--;
596 label1 = &name1->ndata[offsets1[l1]];
597 label2 = &name2->ndata[offsets2[l2]];
598 count1 = *label1++;
599 count2 = *label2++;
600
601 /*
602 * We dropped bitstring labels, and we don't support any
603 * other extended label types.
604 */
605 INSIST(count1 <= 63 && count2 <= 63);
606
607 cdiff = (int)count1 - (int)count2;
608 if (cdiff < 0)
609 count = count1;
610 else
611 count = count2;
612
613 while (count > 0) {
614 chdiff = (int)maptolower[*label1] -
615 (int)maptolower[*label2];
616 if (chdiff != 0) {
617 *orderp = chdiff;
618 goto done;
619 }
620 count--;
621 label1++;
622 label2++;
623 }
624 if (cdiff != 0) {
625 *orderp = cdiff;
626 goto done;
627 }
628 nlabels++;
629 }
630
631 *orderp = ldiff;
632 if (ldiff < 0)
633 namereln = dns_namereln_contains;
634 else if (ldiff > 0)
635 namereln = dns_namereln_subdomain;
636 else
637 namereln = dns_namereln_equal;
638
639 done:
640 *nlabelsp = nlabels;
641
642 if (nlabels > 0 && namereln == dns_namereln_none)
643 namereln = dns_namereln_commonancestor;
644
645 return (namereln);
646 }
647
648 int
649 dns_name_compare(const dns_name_t *name1, const dns_name_t *name2) {
650 int order;
651 unsigned int nlabels;
652
653 /*
654 * Determine the relative ordering under the DNSSEC order relation of
655 * 'name1' and 'name2'.
656 *
657 * Note: It makes no sense for one of the names to be relative and the
658 * other absolute. If both names are relative, then to be meaningfully
659 * compared the caller must ensure that they are both relative to the
660 * same domain.
661 */
662
663 (void)dns_name_fullcompare(name1, name2, &order, &nlabels);
664
665 return (order);
666 }
667
668 isc_boolean_t
669 dns_name_equal(const dns_name_t *name1, const dns_name_t *name2) {
670 unsigned int l, count;
671 unsigned char c;
672 unsigned char *label1, *label2;
673
674 /*
675 * Are 'name1' and 'name2' equal?
676 *
677 * Note: It makes no sense for one of the names to be relative and the
678 * other absolute. If both names are relative, then to be meaningfully
679 * compared the caller must ensure that they are both relative to the
680 * same domain.
681 */
682
683 REQUIRE(VALID_NAME(name1));
684 REQUIRE(VALID_NAME(name2));
685 /*
686 * Either name1 is absolute and name2 is absolute, or neither is.
687 */
688 REQUIRE((name1->attributes & DNS_NAMEATTR_ABSOLUTE) ==
689 (name2->attributes & DNS_NAMEATTR_ABSOLUTE));
690
691 if (name1->length != name2->length)
692 return (ISC_FALSE);
693
694 l = name1->labels;
695
696 if (l != name2->labels)
697 return (ISC_FALSE);
698
699 label1 = name1->ndata;
700 label2 = name2->ndata;
701 while (l > 0) {
702 l--;
703 count = *label1++;
704 if (count != *label2++)
705 return (ISC_FALSE);
706
707 INSIST(count <= 63); /* no bitstring support */
708
709 while (count > 0) {
710 count--;
711 c = maptolower[*label1++];
712 if (c != maptolower[*label2++])
713 return (ISC_FALSE);
714 }
715 }
716
717 return (ISC_TRUE);
718 }
719
720 isc_boolean_t
721 dns_name_caseequal(const dns_name_t *name1, const dns_name_t *name2) {
722
723 /*
724 * Are 'name1' and 'name2' equal?
725 *
726 * Note: It makes no sense for one of the names to be relative and the
727 * other absolute. If both names are relative, then to be meaningfully
728 * compared the caller must ensure that they are both relative to the
729 * same domain.
730 */
731
732 REQUIRE(VALID_NAME(name1));
733 REQUIRE(VALID_NAME(name2));
734 /*
735 * Either name1 is absolute and name2 is absolute, or neither is.
736 */
737 REQUIRE((name1->attributes & DNS_NAMEATTR_ABSOLUTE) ==
738 (name2->attributes & DNS_NAMEATTR_ABSOLUTE));
739
740 if (name1->length != name2->length)
741 return (ISC_FALSE);
742
743 if (memcmp(name1->ndata, name2->ndata, name1->length) != 0)
744 return (ISC_FALSE);
745
746 return (ISC_TRUE);
747 }
748
749 int
750 dns_name_rdatacompare(const dns_name_t *name1, const dns_name_t *name2) {
751 unsigned int l1, l2, l, count1, count2, count;
752 unsigned char c1, c2;
753 unsigned char *label1, *label2;
754
755 /*
756 * Compare two absolute names as rdata.
757 */
758
759 REQUIRE(VALID_NAME(name1));
760 REQUIRE(name1->labels > 0);
761 REQUIRE((name1->attributes & DNS_NAMEATTR_ABSOLUTE) != 0);
762 REQUIRE(VALID_NAME(name2));
763 REQUIRE(name2->labels > 0);
764 REQUIRE((name2->attributes & DNS_NAMEATTR_ABSOLUTE) != 0);
765
766 l1 = name1->labels;
767 l2 = name2->labels;
768
769 l = (l1 < l2) ? l1 : l2;
770
771 label1 = name1->ndata;
772 label2 = name2->ndata;
773 while (l > 0) {
774 l--;
775 count1 = *label1++;
776 count2 = *label2++;
777
778 /* no bitstring support */
779 INSIST(count1 <= 63 && count2 <= 63);
780
781 if (count1 != count2)
782 return ((count1 < count2) ? -1 : 1);
783 count = count1;
784 while (count > 0) {
785 count--;
786 c1 = maptolower[*label1++];
787 c2 = maptolower[*label2++];
788 if (c1 < c2)
789 return (-1);
790 else if (c1 > c2)
791 return (1);
792 }
793 }
794
795 /*
796 * If one name had more labels than the other, their common
797 * prefix must have been different because the shorter name
798 * ended with the root label and the longer one can't have
799 * a root label in the middle of it. Therefore, if we get
800 * to this point, the lengths must be equal.
801 */
802 INSIST(l1 == l2);
803
804 return (0);
805 }
806
807 isc_boolean_t
808 dns_name_issubdomain(const dns_name_t *name1, const dns_name_t *name2) {
809 int order;
810 unsigned int nlabels;
811 dns_namereln_t namereln;
812
813 /*
814 * Is 'name1' a subdomain of 'name2'?
815 *
816 * Note: It makes no sense for one of the names to be relative and the
817 * other absolute. If both names are relative, then to be meaningfully
818 * compared the caller must ensure that they are both relative to the
819 * same domain.
820 */
821
822 namereln = dns_name_fullcompare(name1, name2, &order, &nlabels);
823 if (namereln == dns_namereln_subdomain ||
824 namereln == dns_namereln_equal)
825 return (ISC_TRUE);
826
827 return (ISC_FALSE);
828 }
829
830 isc_boolean_t
831 dns_name_matcheswildcard(const dns_name_t *name, const dns_name_t *wname) {
832 int order;
833 unsigned int nlabels, labels;
834 dns_name_t tname;
835
836 REQUIRE(VALID_NAME(name));
837 REQUIRE(name->labels > 0);
838 REQUIRE(VALID_NAME(wname));
839 labels = wname->labels;
840 REQUIRE(labels > 0);
841 REQUIRE(dns_name_iswildcard(wname));
842
843 DNS_NAME_INIT(&tname, NULL);
844 dns_name_getlabelsequence(wname, 1, labels - 1, &tname);
845 if (dns_name_fullcompare(name, &tname, &order, &nlabels) ==
846 dns_namereln_subdomain)
847 return (ISC_TRUE);
848 return (ISC_FALSE);
849 }
850
851 unsigned int
852 dns_name_countlabels(const dns_name_t *name) {
853 /*
854 * How many labels does 'name' have?
855 */
856
857 REQUIRE(VALID_NAME(name));
858
859 ENSURE(name->labels <= 128);
860
861 return (name->labels);
862 }
863
864 void
865 dns_name_getlabel(const dns_name_t *name, unsigned int n, dns_label_t *label) {
866 unsigned char *offsets;
867 dns_offsets_t odata;
868
869 /*
870 * Make 'label' refer to the 'n'th least significant label of 'name'.
871 */
872
873 REQUIRE(VALID_NAME(name));
874 REQUIRE(name->labels > 0);
875 REQUIRE(n < name->labels);
876 REQUIRE(label != NULL);
877
878 SETUP_OFFSETS(name, offsets, odata);
879
880 label->base = &name->ndata[offsets[n]];
881 if (n == name->labels - 1)
882 label->length = name->length - offsets[n];
883 else
884 label->length = offsets[n + 1] - offsets[n];
885 }
886
887 void
888 dns_name_getlabelsequence(const dns_name_t *source,
889 unsigned int first, unsigned int n,
890 dns_name_t *target)
891 {
892 unsigned char *offsets;
893 dns_offsets_t odata;
894 unsigned int firstoffset, endoffset;
895
896 /*
897 * Make 'target' refer to the 'n' labels including and following
898 * 'first' in 'source'.
899 */
900
901 REQUIRE(VALID_NAME(source));
902 REQUIRE(VALID_NAME(target));
903 REQUIRE(first <= source->labels);
904 REQUIRE(first + n <= source->labels);
905 REQUIRE(BINDABLE(target));
906
907 SETUP_OFFSETS(source, offsets, odata);
908
909 if (first == source->labels)
910 firstoffset = source->length;
911 else
912 firstoffset = offsets[first];
913
914 if (first + n == source->labels)
915 endoffset = source->length;
916 else
917 endoffset = offsets[first + n];
918
919 target->ndata = &source->ndata[firstoffset];
920 target->length = endoffset - firstoffset;
921
922 if (first + n == source->labels && n > 0 &&
923 (source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
924 target->attributes |= DNS_NAMEATTR_ABSOLUTE;
925 else
926 target->attributes &= ~DNS_NAMEATTR_ABSOLUTE;
927
928 target->labels = n;
929
930 /*
931 * If source and target are the same, and we're making target
932 * a prefix of source, the offsets table is correct already
933 * so we don't need to call set_offsets().
934 */
935 if (target->offsets != NULL &&
936 (target != source || first != 0))
937 set_offsets(target, target->offsets, NULL);
938 }
939
940 void
941 dns_name_clone(const dns_name_t *source, dns_name_t *target) {
942
943 /*
944 * Make 'target' refer to the same name as 'source'.
945 */
946
947 REQUIRE(VALID_NAME(source));
948 REQUIRE(VALID_NAME(target));
949 REQUIRE(BINDABLE(target));
950
951 target->ndata = source->ndata;
952 target->length = source->length;
953 target->labels = source->labels;
954 target->attributes = source->attributes &
955 (unsigned int)~(DNS_NAMEATTR_READONLY | DNS_NAMEATTR_DYNAMIC |
956 DNS_NAMEATTR_DYNOFFSETS);
957 if (target->offsets != NULL && source->labels > 0) {
958 if (source->offsets != NULL)
959 memcpy(target->offsets, source->offsets,
960 source->labels);
961 else
962 set_offsets(target, target->offsets, NULL);
963 }
964 }
965
966 void
967 dns_name_fromregion(dns_name_t *name, const isc_region_t *r) {
968 unsigned char *offsets;
969 dns_offsets_t odata;
970 unsigned int len;
971 isc_region_t r2;
972
973 /*
974 * Make 'name' refer to region 'r'.
975 */
976
977 REQUIRE(VALID_NAME(name));
978 REQUIRE(r != NULL);
979 REQUIRE(BINDABLE(name));
980
981 INIT_OFFSETS(name, offsets, odata);
982
983 if (name->buffer != NULL) {
984 isc_buffer_clear(name->buffer);
985 isc_buffer_availableregion(name->buffer, &r2);
986 len = (r->length < r2.length) ? r->length : r2.length;
987 if (len > DNS_NAME_MAXWIRE)
988 len = DNS_NAME_MAXWIRE;
989 memcpy(r2.base, r->base, len);
990 name->ndata = r2.base;
991 name->length = len;
992 } else {
993 name->ndata = r->base;
994 name->length = (r->length <= DNS_NAME_MAXWIRE) ?
995 r->length : DNS_NAME_MAXWIRE;
996 }
997
998 if (r->length > 0)
999 set_offsets(name, offsets, name);
1000 else {
1001 name->labels = 0;
1002 name->attributes &= ~DNS_NAMEATTR_ABSOLUTE;
1003 }
1004
1005 if (name->buffer != NULL)
1006 isc_buffer_add(name->buffer, name->length);
1007 }
1008
1009 void
1010 dns_name_toregion(dns_name_t *name, isc_region_t *r) {
1011 /*
1012 * Make 'r' refer to 'name'.
1013 */
1014
1015 REQUIRE(VALID_NAME(name));
1016 REQUIRE(r != NULL);
1017
1018 DNS_NAME_TOREGION(name, r);
1019 }
1020
1021
1022 isc_result_t
1023 dns_name_fromtext(dns_name_t *name, isc_buffer_t *source,
1024 dns_name_t *origin, unsigned int options,
1025 isc_buffer_t *target)
1026 {
1027 unsigned char *ndata, *label;
1028 char *tdata;
1029 char c;
1030 ft_state state;
1031 unsigned int value, count;
1032 unsigned int n1, n2, tlen, nrem, nused, digits, labels, tused;
1033 isc_boolean_t done;
1034 unsigned char *offsets;
1035 dns_offsets_t odata;
1036 isc_boolean_t downcase;
1037
1038 /*
1039 * Convert the textual representation of a DNS name at source
1040 * into uncompressed wire form stored in target.
1041 *
1042 * Notes:
1043 * Relative domain names will have 'origin' appended to them
1044 * unless 'origin' is NULL, in which case relative domain names
1045 * will remain relative.
1046 */
1047
1048 REQUIRE(VALID_NAME(name));
1049 REQUIRE(ISC_BUFFER_VALID(source));
1050 REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) ||
1051 (target == NULL && ISC_BUFFER_VALID(name->buffer)));
1052
1053 downcase = ISC_TF((options & DNS_NAME_DOWNCASE) != 0);
1054
1055 if (target == NULL && name->buffer != NULL) {
1056 target = name->buffer;
1057 isc_buffer_clear(target);
1058 }
1059
1060 REQUIRE(BINDABLE(name));
1061
1062 INIT_OFFSETS(name, offsets, odata);
1063 offsets[0] = 0;
1064
1065 /*
1066 * Initialize things to make the compiler happy; they're not required.
1067 */
1068 n1 = 0;
1069 n2 = 0;
1070 label = NULL;
1071 digits = 0;
1072 value = 0;
1073 count = 0;
1074
1075 /*
1076 * Make 'name' empty in case of failure.
1077 */
1078 MAKE_EMPTY(name);
1079
1080 /*
1081 * Set up the state machine.
1082 */
1083 tdata = (char *)source->base + source->current;
1084 tlen = isc_buffer_remaininglength(source);
1085 tused = 0;
1086 ndata = isc_buffer_used(target);
1087 nrem = isc_buffer_availablelength(target);
1088 if (nrem > 255)
1089 nrem = 255;
1090 nused = 0;
1091 labels = 0;
1092 done = ISC_FALSE;
1093 state = ft_init;
1094
1095 while (nrem > 0 && tlen > 0 && !done) {
1096 c = *tdata++;
1097 tlen--;
1098 tused++;
1099
1100 switch (state) {
1101 case ft_init:
1102 /*
1103 * Is this the root name?
1104 */
1105 if (c == '.') {
1106 if (tlen != 0)
1107 return (DNS_R_EMPTYLABEL);
1108 labels++;
1109 *ndata++ = 0;
1110 nrem--;
1111 nused++;
1112 done = ISC_TRUE;
1113 break;
1114 }
1115 if (c == '@' && tlen == 0) {
1116 state = ft_at;
1117 break;
1118 }
1119
1120 /* FALLTHROUGH */
1121 case ft_start:
1122 label = ndata;
1123 ndata++;
1124 nrem--;
1125 nused++;
1126 count = 0;
1127 if (c == '\\') {
1128 state = ft_initialescape;
1129 break;
1130 }
1131 state = ft_ordinary;
1132 if (nrem == 0)
1133 return (ISC_R_NOSPACE);
1134 /* FALLTHROUGH */
1135 case ft_ordinary:
1136 if (c == '.') {
1137 if (count == 0)
1138 return (DNS_R_EMPTYLABEL);
1139 *label = count;
1140 labels++;
1141 INSIST(labels <= 127);
1142 offsets[labels] = nused;
1143 if (tlen == 0) {
1144 labels++;
1145 *ndata++ = 0;
1146 nrem--;
1147 nused++;
1148 done = ISC_TRUE;
1149 }
1150 state = ft_start;
1151 } else if (c == '\\') {
1152 state = ft_escape;
1153 } else {
1154 if (count >= 63)
1155 return (DNS_R_LABELTOOLONG);
1156 count++;
1157 CONVERTTOASCII(c);
1158 if (downcase)
1159 c = maptolower[(int)c];
1160 *ndata++ = c;
1161 nrem--;
1162 nused++;
1163 }
1164 break;
1165 case ft_initialescape:
1166 if (c == '[') {
1167 /*
1168 * This looks like a bitstring label, which
1169 * was deprecated. Intentionally drop it.
1170 */
1171 return (DNS_R_BADLABELTYPE);
1172 }
1173 state = ft_escape;
1174 /* FALLTHROUGH */
1175 case ft_escape:
1176 if (!isdigit(c & 0xff)) {
1177 if (count >= 63)
1178 return (DNS_R_LABELTOOLONG);
1179 count++;
1180 CONVERTTOASCII(c);
1181 if (downcase)
1182 c = maptolower[(int)c];
1183 *ndata++ = c;
1184 nrem--;
1185 nused++;
1186 state = ft_ordinary;
1187 break;
1188 }
1189 digits = 0;
1190 value = 0;
1191 state = ft_escdecimal;
1192 /* FALLTHROUGH */
1193 case ft_escdecimal:
1194 if (!isdigit(c & 0xff))
1195 return (DNS_R_BADESCAPE);
1196 value *= 10;
1197 value += digitvalue[(int)c];
1198 digits++;
1199 if (digits == 3) {
1200 if (value > 255)
1201 return (DNS_R_BADESCAPE);
1202 if (count >= 63)
1203 return (DNS_R_LABELTOOLONG);
1204 count++;
1205 if (downcase)
1206 value = maptolower[value];
1207 *ndata++ = value;
1208 nrem--;
1209 nused++;
1210 state = ft_ordinary;
1211 }
1212 break;
1213 default:
1214 FATAL_ERROR(__FILE__, __LINE__,
1215 "Unexpected state %d", state);
1216 /* Does not return. */
1217 }
1218 }
1219
1220 if (!done) {
1221 if (nrem == 0)
1222 return (ISC_R_NOSPACE);
1223 INSIST(tlen == 0);
1224 if (state != ft_ordinary && state != ft_at)
1225 return (ISC_R_UNEXPECTEDEND);
1226 if (state == ft_ordinary) {
1227 INSIST(count != 0);
1228 *label = count;
1229 labels++;
1230 INSIST(labels <= 127);
1231 offsets[labels] = nused;
1232 }
1233 if (origin != NULL) {
1234 if (nrem < origin->length)
1235 return (ISC_R_NOSPACE);
1236 label = origin->ndata;
1237 n1 = origin->length;
1238 nrem -= n1;
1239 while (n1 > 0) {
1240 n2 = *label++;
1241 INSIST(n2 <= 63); /* no bitstring support */
1242 *ndata++ = n2;
1243 n1 -= n2 + 1;
1244 nused += n2 + 1;
1245 while (n2 > 0) {
1246 c = *label++;
1247 if (downcase)
1248 c = maptolower[(int)c];
1249 *ndata++ = c;
1250 n2--;
1251 }
1252 labels++;
1253 if (n1 > 0) {
1254 INSIST(labels <= 127);
1255 offsets[labels] = nused;
1256 }
1257 }
1258 if ((origin->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
1259 name->attributes |= DNS_NAMEATTR_ABSOLUTE;
1260 }
1261 } else
1262 name->attributes |= DNS_NAMEATTR_ABSOLUTE;
1263
1264 name->ndata = (unsigned char *)target->base + target->used;
1265 name->labels = labels;
1266 name->length = nused;
1267
1268 isc_buffer_forward(source, tused);
1269 isc_buffer_add(target, name->length);
1270
1271 return (ISC_R_SUCCESS);
1272 }
1273
1274 #ifdef ISC_PLATFORM_USETHREADS
1275 static void
1276 free_specific(void *arg) {
1277 dns_name_totextfilter_t *mem = arg;
1278 isc_mem_put(thread_key_mctx, mem, sizeof(*mem));
1279 /* Stop use being called again. */
1280 (void)isc_thread_key_setspecific(totext_filter_proc_key, NULL);
1281 }
1282
1283 static void
1284 thread_key_mutex_init(void) {
1285 RUNTIME_CHECK(isc_mutex_init(&thread_key_mutex) == ISC_R_SUCCESS);
1286 }
1287
1288 static isc_result_t
1289 totext_filter_proc_key_init(void) {
1290 isc_result_t result;
1291
1292 /*
1293 * We need the call to isc_once_do() to support profiled mutex
1294 * otherwise thread_key_mutex could be initialized at compile time.
1295 */
1296 result = isc_once_do(&once, thread_key_mutex_init);
1297 if (result != ISC_R_SUCCESS)
1298 return (result);
1299
1300 if (!thread_key_initialized) {
1301 LOCK(&thread_key_mutex);
1302 if (thread_key_mctx == NULL)
1303 result = isc_mem_create2(0, 0, &thread_key_mctx, 0);
1304 if (result != ISC_R_SUCCESS)
1305 goto unlock;
1306 isc_mem_setname(thread_key_mctx, "threadkey", NULL);
1307 isc_mem_setdestroycheck(thread_key_mctx, ISC_FALSE);
1308
1309 if (!thread_key_initialized &&
1310 isc_thread_key_create(&totext_filter_proc_key,
1311 free_specific) != 0) {
1312 result = ISC_R_FAILURE;
1313 isc_mem_detach(&thread_key_mctx);
1314 } else
1315 thread_key_initialized = 1;
1316 unlock:
1317 UNLOCK(&thread_key_mutex);
1318 }
1319 return (result);
1320 }
1321 #endif
1322
1323 isc_result_t
1324 dns_name_totext(dns_name_t *name, isc_boolean_t omit_final_dot,
1325 isc_buffer_t *target)
1326 {
1327 unsigned char *ndata;
1328 char *tdata;
1329 unsigned int nlen, tlen;
1330 unsigned char c;
1331 unsigned int trem, count;
1332 unsigned int labels;
1333 isc_boolean_t saw_root = ISC_FALSE;
1334 unsigned int oused = target->used;
1335 #ifdef ISC_PLATFORM_USETHREADS
1336 dns_name_totextfilter_t *mem;
1337 dns_name_totextfilter_t totext_filter_proc = NULL;
1338 isc_result_t result;
1339 #endif
1340
1341 /*
1342 * This function assumes the name is in proper uncompressed
1343 * wire format.
1344 */
1345 REQUIRE(VALID_NAME(name));
1346 REQUIRE(ISC_BUFFER_VALID(target));
1347
1348 #ifdef ISC_PLATFORM_USETHREADS
1349 result = totext_filter_proc_key_init();
1350 if (result != ISC_R_SUCCESS)
1351 return (result);
1352 #endif
1353 ndata = name->ndata;
1354 nlen = name->length;
1355 labels = name->labels;
1356 tdata = isc_buffer_used(target);
1357 tlen = isc_buffer_availablelength(target);
1358
1359 trem = tlen;
1360
1361 if (labels == 0 && nlen == 0) {
1362 /*
1363 * Special handling for an empty name.
1364 */
1365 if (trem == 0)
1366 return (ISC_R_NOSPACE);
1367
1368 /*
1369 * The names of these booleans are misleading in this case.
1370 * This empty name is not necessarily from the root node of
1371 * the DNS root zone, nor is a final dot going to be included.
1372 * They need to be set this way, though, to keep the "@"
1373 * from being trounced.
1374 */
1375 saw_root = ISC_TRUE;
1376 omit_final_dot = ISC_FALSE;
1377 *tdata++ = '@';
1378 trem--;
1379
1380 /*
1381 * Skip the while() loop.
1382 */
1383 nlen = 0;
1384 } else if (nlen == 1 && labels == 1 && *ndata == '\0') {
1385 /*
1386 * Special handling for the root label.
1387 */
1388 if (trem == 0)
1389 return (ISC_R_NOSPACE);
1390
1391 saw_root = ISC_TRUE;
1392 omit_final_dot = ISC_FALSE;
1393 *tdata++ = '.';
1394 trem--;
1395
1396 /*
1397 * Skip the while() loop.
1398 */
1399 nlen = 0;
1400 }
1401
1402 while (labels > 0 && nlen > 0 && trem > 0) {
1403 labels--;
1404 count = *ndata++;
1405 nlen--;
1406 if (count == 0) {
1407 saw_root = ISC_TRUE;
1408 break;
1409 }
1410 if (count < 64) {
1411 INSIST(nlen >= count);
1412 while (count > 0) {
1413 c = *ndata;
1414 switch (c) {
1415 case 0x22: /* '"' */
1416 case 0x28: /* '(' */
1417 case 0x29: /* ')' */
1418 case 0x2E: /* '.' */
1419 case 0x3B: /* ';' */
1420 case 0x5C: /* '\\' */
1421 /* Special modifiers in zone files. */
1422 case 0x40: /* '@' */
1423 case 0x24: /* '$' */
1424 if (trem < 2)
1425 return (ISC_R_NOSPACE);
1426 *tdata++ = '\\';
1427 CONVERTFROMASCII(c);
1428 *tdata++ = c;
1429 ndata++;
1430 trem -= 2;
1431 nlen--;
1432 break;
1433 default:
1434 if (c > 0x20 && c < 0x7f) {
1435 if (trem == 0)
1436 return (ISC_R_NOSPACE);
1437 CONVERTFROMASCII(c);
1438 *tdata++ = c;
1439 ndata++;
1440 trem--;
1441 nlen--;
1442 } else {
1443 if (trem < 4)
1444 return (ISC_R_NOSPACE);
1445 *tdata++ = 0x5c;
1446 *tdata++ = 0x30 +
1447 ((c / 100) % 10);
1448 *tdata++ = 0x30 +
1449 ((c / 10) % 10);
1450 *tdata++ = 0x30 + (c % 10);
1451 trem -= 4;
1452 ndata++;
1453 nlen--;
1454 }
1455 }
1456 count--;
1457 }
1458 } else {
1459 FATAL_ERROR(__FILE__, __LINE__,
1460 "Unexpected label type %02x", count);
1461 /* NOTREACHED */
1462 }
1463
1464 /*
1465 * The following assumes names are absolute. If not, we
1466 * fix things up later. Note that this means that in some
1467 * cases one more byte of text buffer is required than is
1468 * needed in the final output.
1469 */
1470 if (trem == 0)
1471 return (ISC_R_NOSPACE);
1472 *tdata++ = '.';
1473 trem--;
1474 }
1475
1476 if (nlen != 0 && trem == 0)
1477 return (ISC_R_NOSPACE);
1478
1479 if (!saw_root || omit_final_dot)
1480 trem++;
1481
1482 isc_buffer_add(target, tlen - trem);
1483
1484 #ifdef ISC_PLATFORM_USETHREADS
1485 mem = isc_thread_key_getspecific(totext_filter_proc_key);
1486 if (mem != NULL)
1487 totext_filter_proc = *mem;
1488 #endif
1489 if (totext_filter_proc != NULL)
1490 return ((*totext_filter_proc)(target, oused, saw_root));
1491
1492 return (ISC_R_SUCCESS);
1493 }
1494
1495 isc_result_t
1496 dns_name_tofilenametext(dns_name_t *name, isc_boolean_t omit_final_dot,
1497 isc_buffer_t *target)
1498 {
1499 unsigned char *ndata;
1500 char *tdata;
1501 unsigned int nlen, tlen;
1502 unsigned char c;
1503 unsigned int trem, count;
1504 unsigned int labels;
1505
1506 /*
1507 * This function assumes the name is in proper uncompressed
1508 * wire format.
1509 */
1510 REQUIRE(VALID_NAME(name));
1511 REQUIRE((name->attributes & DNS_NAMEATTR_ABSOLUTE) != 0);
1512 REQUIRE(ISC_BUFFER_VALID(target));
1513
1514 ndata = name->ndata;
1515 nlen = name->length;
1516 labels = name->labels;
1517 tdata = isc_buffer_used(target);
1518 tlen = isc_buffer_availablelength(target);
1519
1520 trem = tlen;
1521
1522 if (nlen == 1 && labels == 1 && *ndata == '\0') {
1523 /*
1524 * Special handling for the root label.
1525 */
1526 if (trem == 0)
1527 return (ISC_R_NOSPACE);
1528
1529 omit_final_dot = ISC_FALSE;
1530 *tdata++ = '.';
1531 trem--;
1532
1533 /*
1534 * Skip the while() loop.
1535 */
1536 nlen = 0;
1537 }
1538
1539 while (labels > 0 && nlen > 0 && trem > 0) {
1540 labels--;
1541 count = *ndata++;
1542 nlen--;
1543 if (count == 0)
1544 break;
1545 if (count < 64) {
1546 INSIST(nlen >= count);
1547 while (count > 0) {
1548 c = *ndata;
1549 if ((c >= 0x30 && c <= 0x39) || /* digit */
1550 (c >= 0x41 && c <= 0x5A) || /* uppercase */
1551 (c >= 0x61 && c <= 0x7A) || /* lowercase */
1552 c == 0x2D || /* hyphen */
1553 c == 0x5F) /* underscore */
1554 {
1555 if (trem == 0)
1556 return (ISC_R_NOSPACE);
1557 /* downcase */
1558 if (c >= 0x41 && c <= 0x5A)
1559 c += 0x20;
1560 CONVERTFROMASCII(c);
1561 *tdata++ = c;
1562 ndata++;
1563 trem--;
1564 nlen--;
1565 } else {
1566 if (trem < 3)
1567 return (ISC_R_NOSPACE);
1568 sprintf(tdata, "%%%02X", c);
1569 tdata += 3;
1570 trem -= 3;
1571 ndata++;
1572 nlen--;
1573 }
1574 count--;
1575 }
1576 } else {
1577 FATAL_ERROR(__FILE__, __LINE__,
1578 "Unexpected label type %02x", count);
1579 /* NOTREACHED */
1580 }
1581
1582 /*
1583 * The following assumes names are absolute. If not, we
1584 * fix things up later. Note that this means that in some
1585 * cases one more byte of text buffer is required than is
1586 * needed in the final output.
1587 */
1588 if (trem == 0)
1589 return (ISC_R_NOSPACE);
1590 *tdata++ = '.';
1591 trem--;
1592 }
1593
1594 if (nlen != 0 && trem == 0)
1595 return (ISC_R_NOSPACE);
1596
1597 if (omit_final_dot)
1598 trem++;
1599
1600 isc_buffer_add(target, tlen - trem);
1601
1602 return (ISC_R_SUCCESS);
1603 }
1604
1605 isc_result_t
1606 dns_name_downcase(dns_name_t *source, dns_name_t *name, isc_buffer_t *target) {
1607 unsigned char *sndata, *ndata;
1608 unsigned int nlen, count, labels;
1609 isc_buffer_t buffer;
1610
1611 /*
1612 * Downcase 'source'.
1613 */
1614
1615 REQUIRE(VALID_NAME(source));
1616 REQUIRE(VALID_NAME(name));
1617 if (source == name) {
1618 REQUIRE((name->attributes & DNS_NAMEATTR_READONLY) == 0);
1619 isc_buffer_init(&buffer, source->ndata, source->length);
1620 target = &buffer;
1621 ndata = source->ndata;
1622 } else {
1623 REQUIRE(BINDABLE(name));
1624 REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) ||
1625 (target == NULL && ISC_BUFFER_VALID(name->buffer)));
1626 if (target == NULL) {
1627 target = name->buffer;
1628 isc_buffer_clear(name->buffer);
1629 }
1630 ndata = (unsigned char *)target->base + target->used;
1631 name->ndata = ndata;
1632 }
1633
1634 sndata = source->ndata;
1635 nlen = source->length;
1636 labels = source->labels;
1637
1638 if (nlen > (target->length - target->used)) {
1639 MAKE_EMPTY(name);
1640 return (ISC_R_NOSPACE);
1641 }
1642
1643 while (labels > 0 && nlen > 0) {
1644 labels--;
1645 count = *sndata++;
1646 *ndata++ = count;
1647 nlen--;
1648 if (count < 64) {
1649 INSIST(nlen >= count);
1650 while (count > 0) {
1651 *ndata++ = maptolower[(*sndata++)];
1652 nlen--;
1653 count--;
1654 }
1655 } else {
1656 FATAL_ERROR(__FILE__, __LINE__,
1657 "Unexpected label type %02x", count);
1658 /* Does not return. */
1659 }
1660 }
1661
1662 if (source != name) {
1663 name->labels = source->labels;
1664 name->length = source->length;
1665 if ((source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
1666 name->attributes = DNS_NAMEATTR_ABSOLUTE;
1667 else
1668 name->attributes = 0;
1669 if (name->labels > 0 && name->offsets != NULL)
1670 set_offsets(name, name->offsets, NULL);
1671 }
1672
1673 isc_buffer_add(target, name->length);
1674
1675 return (ISC_R_SUCCESS);
1676 }
1677
1678 static void
1679 set_offsets(const dns_name_t *name, unsigned char *offsets,
1680 dns_name_t *set_name)
1681 {
1682 unsigned int offset, count, length, nlabels;
1683 unsigned char *ndata;
1684 isc_boolean_t absolute;
1685
1686 ndata = name->ndata;
1687 length = name->length;
1688 offset = 0;
1689 nlabels = 0;
1690 absolute = ISC_FALSE;
1691 while (offset != length) {
1692 INSIST(nlabels < 128);
1693 offsets[nlabels++] = offset;
1694 count = *ndata++;
1695 offset++;
1696 INSIST(count <= 63);
1697 offset += count;
1698 ndata += count;
1699 INSIST(offset <= length);
1700 if (count == 0) {
1701 absolute = ISC_TRUE;
1702 break;
1703 }
1704 }
1705 if (set_name != NULL) {
1706 INSIST(set_name == name);
1707
1708 set_name->labels = nlabels;
1709 set_name->length = offset;
1710 if (absolute)
1711 set_name->attributes |= DNS_NAMEATTR_ABSOLUTE;
1712 else
1713 set_name->attributes &= ~DNS_NAMEATTR_ABSOLUTE;
1714 }
1715 INSIST(nlabels == name->labels);
1716 INSIST(offset == name->length);
1717 }
1718
1719 isc_result_t
1720 dns_name_fromwire(dns_name_t *name, isc_buffer_t *source,
1721 dns_decompress_t *dctx, unsigned int options,
1722 isc_buffer_t *target)
1723 {
1724 unsigned char *cdata, *ndata;
1725 unsigned int cused; /* Bytes of compressed name data used */
1726 unsigned int nused, labels, n, nmax;
1727 unsigned int current, new_current, biggest_pointer;
1728 isc_boolean_t done;
1729 fw_state state = fw_start;
1730 unsigned int c;
1731 unsigned char *offsets;
1732 dns_offsets_t odata;
1733 isc_boolean_t downcase;
1734 isc_boolean_t seen_pointer;
1735
1736 /*
1737 * Copy the possibly-compressed name at source into target,
1738 * decompressing it. Loop prevention is performed by checking
1739 * the new pointer against biggest_pointer.
1740 */
1741
1742 REQUIRE(VALID_NAME(name));
1743 REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) ||
1744 (target == NULL && ISC_BUFFER_VALID(name->buffer)));
1745
1746 downcase = ISC_TF((options & DNS_NAME_DOWNCASE) != 0);
1747
1748 if (target == NULL && name->buffer != NULL) {
1749 target = name->buffer;
1750 isc_buffer_clear(target);
1751 }
1752
1753 REQUIRE(dctx != NULL);
1754 REQUIRE(BINDABLE(name));
1755
1756 INIT_OFFSETS(name, offsets, odata);
1757
1758 /*
1759 * Make 'name' empty in case of failure.
1760 */
1761 MAKE_EMPTY(name);
1762
1763 /*
1764 * Initialize things to make the compiler happy; they're not required.
1765 */
1766 n = 0;
1767 new_current = 0;
1768
1769 /*
1770 * Set up.
1771 */
1772 labels = 0;
1773 done = ISC_FALSE;
1774
1775 ndata = isc_buffer_used(target);
1776 nused = 0;
1777 seen_pointer = ISC_FALSE;
1778
1779 /*
1780 * Find the maximum number of uncompressed target name
1781 * bytes we are willing to generate. This is the smaller
1782 * of the available target buffer length and the
1783 * maximum legal domain name length (255).
1784 */
1785 nmax = isc_buffer_availablelength(target);
1786 if (nmax > DNS_NAME_MAXWIRE)
1787 nmax = DNS_NAME_MAXWIRE;
1788
1789 cdata = isc_buffer_current(source);
1790 cused = 0;
1791
1792 current = source->current;
1793 biggest_pointer = current;
1794
1795 /*
1796 * Note: The following code is not optimized for speed, but
1797 * rather for correctness. Speed will be addressed in the future.
1798 */
1799
1800 while (current < source->active && !done) {
1801 c = *cdata++;
1802 current++;
1803 if (!seen_pointer)
1804 cused++;
1805
1806 switch (state) {
1807 case fw_start:
1808 if (c < 64) {
1809 offsets[labels] = nused;
1810 labels++;
1811 if (nused + c + 1 > nmax)
1812 goto full;
1813 nused += c + 1;
1814 *ndata++ = c;
1815 if (c == 0)
1816 done = ISC_TRUE;
1817 n = c;
1818 state = fw_ordinary;
1819 } else if (c >= 128 && c < 192) {
1820 /*
1821 * 14 bit local compression pointer.
1822 * Local compression is no longer an
1823 * IETF draft.
1824 */
1825 return (DNS_R_BADLABELTYPE);
1826 } else if (c >= 192) {
1827 /*
1828 * Ordinary 14-bit pointer.
1829 */
1830 if ((dctx->allowed & DNS_COMPRESS_GLOBAL14) ==
1831 0)
1832 return (DNS_R_DISALLOWED);
1833 new_current = c & 0x3F;
1834 n = 1;
1835 state = fw_newcurrent;
1836 } else
1837 return (DNS_R_BADLABELTYPE);
1838 break;
1839 case fw_ordinary:
1840 if (downcase)
1841 c = maptolower[c];
1842 /* FALLTHROUGH */
1843 case fw_copy:
1844 *ndata++ = c;
1845 n--;
1846 if (n == 0)
1847 state = fw_start;
1848 break;
1849 case fw_newcurrent:
1850 new_current *= 256;
1851 new_current += c;
1852 n--;
1853 if (n != 0)
1854 break;
1855 if (new_current >= biggest_pointer)
1856 return (DNS_R_BADPOINTER);
1857 biggest_pointer = new_current;
1858 current = new_current;
1859 cdata = (unsigned char *)source->base + current;
1860 seen_pointer = ISC_TRUE;
1861 state = fw_start;
1862 break;
1863 default:
1864 FATAL_ERROR(__FILE__, __LINE__,
1865 "Unknown state %d", state);
1866 /* Does not return. */
1867 }
1868 }
1869
1870 if (!done)
1871 return (ISC_R_UNEXPECTEDEND);
1872
1873 name->ndata = (unsigned char *)target->base + target->used;
1874 name->labels = labels;
1875 name->length = nused;
1876 name->attributes |= DNS_NAMEATTR_ABSOLUTE;
1877
1878 isc_buffer_forward(source, cused);
1879 isc_buffer_add(target, name->length);
1880
1881 return (ISC_R_SUCCESS);
1882
1883 full:
1884 if (nmax == DNS_NAME_MAXWIRE)
1885 /*
1886 * The name did not fit even though we had a buffer
1887 * big enough to fit a maximum-length name.
1888 */
1889 return (DNS_R_NAMETOOLONG);
1890 else
1891 /*
1892 * The name might fit if only the caller could give us a
1893 * big enough buffer.
1894 */
1895 return (ISC_R_NOSPACE);
1896 }
1897
1898 isc_result_t
1899 dns_name_towire(const dns_name_t *name, dns_compress_t *cctx,
1900 isc_buffer_t *target)
1901 {
1902 unsigned int methods;
1903 isc_uint16_t offset;
1904 dns_name_t gp; /* Global compression prefix */
1905 isc_boolean_t gf; /* Global compression target found */
1906 isc_uint16_t go; /* Global compression offset */
1907 dns_offsets_t clo;
1908 dns_name_t clname;
1909
1910 /*
1911 * Convert 'name' into wire format, compressing it as specified by the
1912 * compression context 'cctx', and storing the result in 'target'.
1913 */
1914
1915 REQUIRE(VALID_NAME(name));
1916 REQUIRE(cctx != NULL);
1917 REQUIRE(ISC_BUFFER_VALID(target));
1918
1919 /*
1920 * If 'name' doesn't have an offsets table, make a clone which
1921 * has one.
1922 */
1923 if (name->offsets == NULL) {
1924 DNS_NAME_INIT(&clname, clo);
1925 dns_name_clone(name, &clname);
1926 name = &clname;
1927 }
1928 DNS_NAME_INIT(&gp, NULL);
1929
1930 offset = target->used; /*XXX*/
1931
1932 methods = dns_compress_getmethods(cctx);
1933
1934 if ((name->attributes & DNS_NAMEATTR_NOCOMPRESS) == 0 &&
1935 (methods & DNS_COMPRESS_GLOBAL14) != 0)
1936 gf = dns_compress_findglobal(cctx, name, &gp, &go);
1937 else
1938 gf = ISC_FALSE;
1939
1940 /*
1941 * If the offset is too high for 14 bit global compression, we're
1942 * out of luck.
1943 */
1944 if (gf && go >= 0x4000)
1945 gf = ISC_FALSE;
1946
1947 /*
1948 * Will the compression pointer reduce the message size?
1949 */
1950 if (gf && (gp.length + 2) >= name->length)
1951 gf = ISC_FALSE;
1952
1953 if (gf) {
1954 if (target->length - target->used < gp.length)
1955 return (ISC_R_NOSPACE);
1956 (void)memcpy((unsigned char *)target->base + target->used,
1957 gp.ndata, (size_t)gp.length);
1958 isc_buffer_add(target, gp.length);
1959 go |= 0xc000;
1960 if (target->length - target->used < 2)
1961 return (ISC_R_NOSPACE);
1962 isc_buffer_putuint16(target, go);
1963 if (gp.length != 0)
1964 dns_compress_add(cctx, name, &gp, offset);
1965 } else {
1966 if (target->length - target->used < name->length)
1967 return (ISC_R_NOSPACE);
1968 (void)memcpy((unsigned char *)target->base + target->used,
1969 name->ndata, (size_t)name->length);
1970 isc_buffer_add(target, name->length);
1971 dns_compress_add(cctx, name, name, offset);
1972 }
1973 return (ISC_R_SUCCESS);
1974 }
1975
1976 isc_result_t
1977 dns_name_concatenate(dns_name_t *prefix, dns_name_t *suffix, dns_name_t *name,
1978 isc_buffer_t *target)
1979 {
1980 unsigned char *ndata, *offsets;
1981 unsigned int nrem, labels, prefix_length, length;
1982 isc_boolean_t copy_prefix = ISC_TRUE;
1983 isc_boolean_t copy_suffix = ISC_TRUE;
1984 isc_boolean_t absolute = ISC_FALSE;
1985 dns_name_t tmp_name;
1986 dns_offsets_t odata;
1987
1988 /*
1989 * Concatenate 'prefix' and 'suffix'.
1990 */
1991
1992 REQUIRE(prefix == NULL || VALID_NAME(prefix));
1993 REQUIRE(suffix == NULL || VALID_NAME(suffix));
1994 REQUIRE(name == NULL || VALID_NAME(name));
1995 REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) ||
1996 (target == NULL && name != NULL && ISC_BUFFER_VALID(name->buffer)));
1997 if (prefix == NULL || prefix->labels == 0)
1998 copy_prefix = ISC_FALSE;
1999 if (suffix == NULL || suffix->labels == 0)
2000 copy_suffix = ISC_FALSE;
2001 if (copy_prefix &&
2002 (prefix->attributes & DNS_NAMEATTR_ABSOLUTE) != 0) {
2003 absolute = ISC_TRUE;
2004 REQUIRE(!copy_suffix);
2005 }
2006 if (name == NULL) {
2007 DNS_NAME_INIT(&tmp_name, odata);
2008 name = &tmp_name;
2009 }
2010 if (target == NULL) {
2011 INSIST(name->buffer != NULL);
2012 target = name->buffer;
2013 isc_buffer_clear(name->buffer);
2014 }
2015
2016 REQUIRE(BINDABLE(name));
2017
2018 /*
2019 * Set up.
2020 */
2021 nrem = target->length - target->used;
2022 ndata = (unsigned char *)target->base + target->used;
2023 if (nrem > DNS_NAME_MAXWIRE)
2024 nrem = DNS_NAME_MAXWIRE;
2025 length = 0;
2026 prefix_length = 0;
2027 labels = 0;
2028 if (copy_prefix) {
2029 prefix_length = prefix->length;
2030 length += prefix_length;
2031 labels += prefix->labels;
2032 }
2033 if (copy_suffix) {
2034 length += suffix->length;
2035 labels += suffix->labels;
2036 }
2037 if (length > DNS_NAME_MAXWIRE) {
2038 MAKE_EMPTY(name);
2039 return (DNS_R_NAMETOOLONG);
2040 }
2041 if (length > nrem) {
2042 MAKE_EMPTY(name);
2043 return (ISC_R_NOSPACE);
2044 }
2045
2046 if (copy_suffix) {
2047 if ((suffix->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
2048 absolute = ISC_TRUE;
2049 if (suffix == name && suffix->buffer == target)
2050 memmove(ndata + prefix_length, suffix->ndata,
2051 suffix->length);
2052 else
2053 memcpy(ndata + prefix_length, suffix->ndata,
2054 suffix->length);
2055 }
2056
2057 /*
2058 * If 'prefix' and 'name' are the same object, and the object has
2059 * a dedicated buffer, and we're using it, then we don't have to
2060 * copy anything.
2061 */
2062 if (copy_prefix && (prefix != name || prefix->buffer != target))
2063 memcpy(ndata, prefix->ndata, prefix_length);
2064
2065 name->ndata = ndata;
2066 name->labels = labels;
2067 name->length = length;
2068 if (absolute)
2069 name->attributes = DNS_NAMEATTR_ABSOLUTE;
2070 else
2071 name->attributes = 0;
2072
2073 if (name->labels > 0 && name->offsets != NULL) {
2074 INIT_OFFSETS(name, offsets, odata);
2075 set_offsets(name, offsets, NULL);
2076 }
2077
2078 isc_buffer_add(target, name->length);
2079
2080 return (ISC_R_SUCCESS);
2081 }
2082
2083 void
2084 dns_name_split(dns_name_t *name, unsigned int suffixlabels,
2085 dns_name_t *prefix, dns_name_t *suffix)
2086
2087 {
2088 unsigned int splitlabel;
2089
2090 REQUIRE(VALID_NAME(name));
2091 REQUIRE(suffixlabels > 0);
2092 REQUIRE(suffixlabels < name->labels);
2093 REQUIRE(prefix != NULL || suffix != NULL);
2094 REQUIRE(prefix == NULL ||
2095 (VALID_NAME(prefix) &&
2096 prefix->buffer != NULL &&
2097 BINDABLE(prefix)));
2098 REQUIRE(suffix == NULL ||
2099 (VALID_NAME(suffix) &&
2100 suffix->buffer != NULL &&
2101 BINDABLE(suffix)));
2102
2103 splitlabel = name->labels - suffixlabels;
2104
2105 if (prefix != NULL)
2106 dns_name_getlabelsequence(name, 0, splitlabel, prefix);
2107
2108 if (suffix != NULL)
2109 dns_name_getlabelsequence(name, splitlabel,
2110 suffixlabels, suffix);
2111
2112 return;
2113 }
2114
2115 isc_result_t
2116 dns_name_dup(const dns_name_t *source, isc_mem_t *mctx,
2117 dns_name_t *target)
2118 {
2119 /*
2120 * Make 'target' a dynamically allocated copy of 'source'.
2121 */
2122
2123 REQUIRE(VALID_NAME(source));
2124 REQUIRE(source->length > 0);
2125 REQUIRE(VALID_NAME(target));
2126 REQUIRE(BINDABLE(target));
2127
2128 /*
2129 * Make 'target' empty in case of failure.
2130 */
2131 MAKE_EMPTY(target);
2132
2133 target->ndata = isc_mem_get(mctx, source->length);
2134 if (target->ndata == NULL)
2135 return (ISC_R_NOMEMORY);
2136
2137 memcpy(target->ndata, source->ndata, source->length);
2138
2139 target->length = source->length;
2140 target->labels = source->labels;
2141 target->attributes = DNS_NAMEATTR_DYNAMIC;
2142 if ((source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
2143 target->attributes |= DNS_NAMEATTR_ABSOLUTE;
2144 if (target->offsets != NULL) {
2145 if (source->offsets != NULL)
2146 memcpy(target->offsets, source->offsets,
2147 source->labels);
2148 else
2149 set_offsets(target, target->offsets, NULL);
2150 }
2151
2152 return (ISC_R_SUCCESS);
2153 }
2154
2155 isc_result_t
2156 dns_name_dupwithoffsets(dns_name_t *source, isc_mem_t *mctx,
2157 dns_name_t *target)
2158 {
2159 /*
2160 * Make 'target' a read-only dynamically allocated copy of 'source'.
2161 * 'target' will also have a dynamically allocated offsets table.
2162 */
2163
2164 REQUIRE(VALID_NAME(source));
2165 REQUIRE(source->length > 0);
2166 REQUIRE(VALID_NAME(target));
2167 REQUIRE(BINDABLE(target));
2168 REQUIRE(target->offsets == NULL);
2169
2170 /*
2171 * Make 'target' empty in case of failure.
2172 */
2173 MAKE_EMPTY(target);
2174
2175 target->ndata = isc_mem_get(mctx, source->length + source->labels);
2176 if (target->ndata == NULL)
2177 return (ISC_R_NOMEMORY);
2178
2179 memcpy(target->ndata, source->ndata, source->length);
2180
2181 target->length = source->length;
2182 target->labels = source->labels;
2183 target->attributes = DNS_NAMEATTR_DYNAMIC | DNS_NAMEATTR_DYNOFFSETS |
2184 DNS_NAMEATTR_READONLY;
2185 if ((source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
2186 target->attributes |= DNS_NAMEATTR_ABSOLUTE;
2187 target->offsets = target->ndata + source->length;
2188 if (source->offsets != NULL)
2189 memcpy(target->offsets, source->offsets, source->labels);
2190 else
2191 set_offsets(target, target->offsets, NULL);
2192
2193 return (ISC_R_SUCCESS);
2194 }
2195
2196 void
2197 dns_name_free(dns_name_t *name, isc_mem_t *mctx) {
2198 size_t size;
2199
2200 /*
2201 * Free 'name'.
2202 */
2203
2204 REQUIRE(VALID_NAME(name));
2205 REQUIRE((name->attributes & DNS_NAMEATTR_DYNAMIC) != 0);
2206
2207 size = name->length;
2208 if ((name->attributes & DNS_NAMEATTR_DYNOFFSETS) != 0)
2209 size += name->labels;
2210 isc_mem_put(mctx, name->ndata, size);
2211 dns_name_invalidate(name);
2212 }
2213
2214 isc_result_t
2215 dns_name_digest(dns_name_t *name, dns_digestfunc_t digest, void *arg) {
2216 dns_name_t downname;
2217 unsigned char data[256];
2218 isc_buffer_t buffer;
2219 isc_result_t result;
2220 isc_region_t r;
2221
2222 /*
2223 * Send 'name' in DNSSEC canonical form to 'digest'.
2224 */
2225
2226 REQUIRE(VALID_NAME(name));
2227 REQUIRE(digest != NULL);
2228
2229 DNS_NAME_INIT(&downname, NULL);
2230 isc_buffer_init(&buffer, data, sizeof(data));
2231
2232 result = dns_name_downcase(name, &downname, &buffer);
2233 if (result != ISC_R_SUCCESS)
2234 return (result);
2235
2236 isc_buffer_usedregion(&buffer, &r);
2237
2238 return ((digest)(arg, &r));
2239 }
2240
2241 isc_boolean_t
2242 dns_name_dynamic(dns_name_t *name) {
2243 REQUIRE(VALID_NAME(name));
2244
2245 /*
2246 * Returns whether there is dynamic memory associated with this name.
2247 */
2248
2249 return ((name->attributes & DNS_NAMEATTR_DYNAMIC) != 0 ?
2250 ISC_TRUE : ISC_FALSE);
2251 }
2252
2253 isc_result_t
2254 dns_name_print(dns_name_t *name, FILE *stream) {
2255 isc_result_t result;
2256 isc_buffer_t b;
2257 isc_region_t r;
2258 char t[1024];
2259
2260 /*
2261 * Print 'name' on 'stream'.
2262 */
2263
2264 REQUIRE(VALID_NAME(name));
2265
2266 isc_buffer_init(&b, t, sizeof(t));
2267 result = dns_name_totext(name, ISC_FALSE, &b);
2268 if (result != ISC_R_SUCCESS)
2269 return (result);
2270 isc_buffer_usedregion(&b, &r);
2271 fprintf(stream, "%.*s", (int)r.length, (char *)r.base);
2272
2273 return (ISC_R_SUCCESS);
2274 }
2275
2276 isc_result_t
2277 dns_name_settotextfilter(dns_name_totextfilter_t proc) {
2278 #ifdef ISC_PLATFORM_USETHREADS
2279 isc_result_t result;
2280 dns_name_totextfilter_t *mem;
2281 int res;
2282
2283 result = totext_filter_proc_key_init();
2284 if (result != ISC_R_SUCCESS)
2285 return (result);
2286
2287 /*
2288 * If we already have been here set / clear as appropriate.
2289 * Otherwise allocate memory.
2290 */
2291 mem = isc_thread_key_getspecific(totext_filter_proc_key);
2292 if (mem != NULL && proc != NULL) {
2293 *mem = proc;
2294 return (ISC_R_SUCCESS);
2295 }
2296 if (proc == NULL) {
2297 isc_mem_put(thread_key_mctx, mem, sizeof(*mem));
2298 res = isc_thread_key_setspecific(totext_filter_proc_key, NULL);
2299 if (res != 0)
2300 result = ISC_R_UNEXPECTED;
2301 return (result);
2302 }
2303
2304 mem = isc_mem_get(thread_key_mctx, sizeof(*mem));
2305 if (mem == NULL)
2306 return (ISC_R_NOMEMORY);
2307 *mem = proc;
2308 if (isc_thread_key_setspecific(totext_filter_proc_key, mem) != 0) {
2309 isc_mem_put(thread_key_mctx, mem, sizeof(*mem));
2310 result = ISC_R_UNEXPECTED;
2311 }
2312 return (result);
2313 #else
2314 totext_filter_proc = proc;
2315 return (ISC_R_SUCCESS);
2316 #endif
2317 }
2318
2319 void
2320 dns_name_format(dns_name_t *name, char *cp, unsigned int size) {
2321 isc_result_t result;
2322 isc_buffer_t buf;
2323
2324 REQUIRE(size > 0);
2325
2326 /*
2327 * Leave room for null termination after buffer.
2328 */
2329 isc_buffer_init(&buf, cp, size - 1);
2330 result = dns_name_totext(name, ISC_TRUE, &buf);
2331 if (result == ISC_R_SUCCESS) {
2332 /*
2333 * Null terminate.
2334 */
2335 isc_region_t r;
2336 isc_buffer_usedregion(&buf, &r);
2337 ((char *) r.base)[r.length] = '\0';
2338
2339 } else
2340 snprintf(cp, size, "<unknown>");
2341 }
2342
2343 isc_result_t
2344 dns_name_copy(dns_name_t *source, dns_name_t *dest, isc_buffer_t *target) {
2345 unsigned char *ndata;
2346
2347 /*
2348 * Make dest a copy of source.
2349 */
2350
2351 REQUIRE(VALID_NAME(source));
2352 REQUIRE(VALID_NAME(dest));
2353 REQUIRE(target != NULL || dest->buffer != NULL);
2354
2355 if (target == NULL) {
2356 target = dest->buffer;
2357 isc_buffer_clear(dest->buffer);
2358 }
2359
2360 REQUIRE(BINDABLE(dest));
2361
2362 /*
2363 * Set up.
2364 */
2365 if (target->length - target->used < source->length)
2366 return (ISC_R_NOSPACE);
2367
2368 ndata = (unsigned char *)target->base + target->used;
2369 dest->ndata = target->base;
2370
2371 memcpy(ndata, source->ndata, source->length);
2372
2373 dest->ndata = ndata;
2374 dest->labels = source->labels;
2375 dest->length = source->length;
2376 if ((source->attributes & DNS_NAMEATTR_ABSOLUTE) != 0)
2377 dest->attributes = DNS_NAMEATTR_ABSOLUTE;
2378 else
2379 dest->attributes = 0;
2380
2381 if (dest->labels > 0 && dest->offsets != NULL) {
2382 if (source->offsets != NULL)
2383 memcpy(dest->offsets, source->offsets, source->labels);
2384 else
2385 set_offsets(dest, dest->offsets, NULL);
2386 }
2387
2388 isc_buffer_add(target, dest->length);
2389
2390 return (ISC_R_SUCCESS);
2391 }
2392
2393 void
2394 dns_name_destroy(void) {
2395 #ifdef ISC_PLATFORM_USETHREADS
2396 RUNTIME_CHECK(isc_once_do(&once, thread_key_mutex_init)
2397 == ISC_R_SUCCESS);
2398
2399 LOCK(&thread_key_mutex);
2400 if (thread_key_initialized) {
2401 isc_mem_detach(&thread_key_mctx);
2402 isc_thread_key_delete(totext_filter_proc_key);
2403 thread_key_initialized = 0;
2404 }
2405 UNLOCK(&thread_key_mutex);
2406
2407 #endif
2408 }
DragonFly BSD