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