2 * Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2001, 2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and 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.
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.
18 /* $Id: naptr_35.c,v 1.43.2.3 2004/03/09 06:11:37 marka Exp $ */
20 /* Reviewed: Thu Mar 16 16:52:50 PST 2000 by bwelling */
24 #ifndef RDATA_IN_1_NAPTR_35_C
25 #define RDATA_IN_1_NAPTR_35_C
27 #define RRTYPE_NAPTR_ATTRIBUTES (0)
29 static inline isc_result_t
30 fromtext_in_naptr(ARGS_FROMTEXT
) {
36 REQUIRE(rdclass
== 1);
45 RETERR(isc_lex_getmastertoken(lexer
, &token
, isc_tokentype_number
,
47 if (token
.value
.as_ulong
> 0xffffU
)
49 RETERR(uint16_tobuffer(token
.value
.as_ulong
, target
));
54 RETERR(isc_lex_getmastertoken(lexer
, &token
, isc_tokentype_number
,
56 if (token
.value
.as_ulong
> 0xffffU
)
58 RETERR(uint16_tobuffer(token
.value
.as_ulong
, target
));
63 RETERR(isc_lex_getmastertoken(lexer
, &token
, isc_tokentype_qstring
,
65 RETTOK(txt_fromtext(&token
.value
.as_textregion
, target
));
70 RETERR(isc_lex_getmastertoken(lexer
, &token
, isc_tokentype_qstring
,
72 RETTOK(txt_fromtext(&token
.value
.as_textregion
, target
));
77 RETERR(isc_lex_getmastertoken(lexer
, &token
, isc_tokentype_qstring
,
79 RETTOK(txt_fromtext(&token
.value
.as_textregion
, target
));
84 RETERR(isc_lex_getmastertoken(lexer
, &token
, isc_tokentype_string
,
86 dns_name_init(&name
, NULL
);
87 buffer_fromregion(&buffer
, &token
.value
.as_region
);
88 origin
= (origin
!= NULL
) ? origin
: dns_rootname
;
89 RETTOK(dns_name_fromtext(&name
, &buffer
, origin
, downcase
, target
));
90 return (ISC_R_SUCCESS
);
93 static inline isc_result_t
94 totext_in_naptr(ARGS_TOTEXT
) {
99 char buf
[sizeof "64000"];
102 REQUIRE(rdata
->type
== 35);
103 REQUIRE(rdata
->rdclass
== 1);
104 REQUIRE(rdata
->length
!= 0);
106 dns_name_init(&name
, NULL
);
107 dns_name_init(&prefix
, NULL
);
109 dns_rdata_toregion(rdata
, ®ion
);
114 num
= uint16_fromregion(®ion
);
115 isc_region_consume(®ion
, 2);
116 sprintf(buf
, "%u", num
);
117 RETERR(str_totext(buf
, target
));
118 RETERR(str_totext(" ", target
));
123 num
= uint16_fromregion(®ion
);
124 isc_region_consume(®ion
, 2);
125 sprintf(buf
, "%u", num
);
126 RETERR(str_totext(buf
, target
));
127 RETERR(str_totext(" ", target
));
132 RETERR(txt_totext(®ion
, target
));
133 RETERR(str_totext(" ", target
));
138 RETERR(txt_totext(®ion
, target
));
139 RETERR(str_totext(" ", target
));
144 RETERR(txt_totext(®ion
, target
));
145 RETERR(str_totext(" ", target
));
150 dns_name_fromregion(&name
, ®ion
);
151 sub
= name_prefix(&name
, tctx
->origin
, &prefix
);
152 return (dns_name_totext(&prefix
, sub
, target
));
155 static inline isc_result_t
156 fromwire_in_naptr(ARGS_FROMWIRE
) {
161 REQUIRE(rdclass
== 1);
166 dns_decompress_setmethods(dctx
, DNS_COMPRESS_NONE
);
168 dns_name_init(&name
, NULL
);
173 isc_buffer_activeregion(source
, &sr
);
175 return (ISC_R_UNEXPECTEDEND
);
176 RETERR(mem_tobuffer(target
, sr
.base
, 4));
177 isc_buffer_forward(source
, 4);
182 RETERR(txt_fromwire(source
, target
));
187 RETERR(txt_fromwire(source
, target
));
192 RETERR(txt_fromwire(source
, target
));
197 return (dns_name_fromwire(&name
, source
, dctx
, downcase
, target
));
200 static inline isc_result_t
201 towire_in_naptr(ARGS_TOWIRE
) {
203 dns_offsets_t offsets
;
206 REQUIRE(rdata
->type
== 35);
207 REQUIRE(rdata
->rdclass
== 1);
208 REQUIRE(rdata
->length
!= 0);
210 dns_compress_setmethods(cctx
, DNS_COMPRESS_NONE
);
214 dns_rdata_toregion(rdata
, &sr
);
215 RETERR(mem_tobuffer(target
, sr
.base
, 4));
216 isc_region_consume(&sr
, 4);
221 RETERR(mem_tobuffer(target
, sr
.base
, sr
.base
[0] + 1));
222 isc_region_consume(&sr
, sr
.base
[0] + 1);
227 RETERR(mem_tobuffer(target
, sr
.base
, sr
.base
[0] + 1));
228 isc_region_consume(&sr
, sr
.base
[0] + 1);
233 RETERR(mem_tobuffer(target
, sr
.base
, sr
.base
[0] + 1));
234 isc_region_consume(&sr
, sr
.base
[0] + 1);
239 dns_name_init(&name
, offsets
);
240 dns_name_fromregion(&name
, &sr
);
241 return (dns_name_towire(&name
, cctx
, target
));
245 compare_in_naptr(ARGS_COMPARE
) {
248 isc_region_t region1
;
249 isc_region_t region2
;
252 REQUIRE(rdata1
->type
== rdata2
->type
);
253 REQUIRE(rdata1
->rdclass
== rdata2
->rdclass
);
254 REQUIRE(rdata1
->type
== 35);
255 REQUIRE(rdata1
->rdclass
== 1);
256 REQUIRE(rdata1
->length
!= 0);
257 REQUIRE(rdata2
->length
!= 0);
259 dns_rdata_toregion(rdata1
, ®ion1
);
260 dns_rdata_toregion(rdata2
, ®ion2
);
265 order
= memcmp(region1
.base
, region2
.base
, 4);
267 return (order
< 0 ? -1 : 1);
268 isc_region_consume(®ion1
, 4);
269 isc_region_consume(®ion2
, 4);
274 len
= ISC_MIN(region1
.base
[0], region2
.base
[0]);
275 order
= memcmp(region1
.base
, region2
.base
, len
+ 1);
277 return (order
< 0 ? -1 : 1);
278 isc_region_consume(®ion1
, region1
.base
[0] + 1);
279 isc_region_consume(®ion2
, region2
.base
[0] + 1);
284 len
= ISC_MIN(region1
.base
[0], region2
.base
[0]);
285 order
= memcmp(region1
.base
, region2
.base
, len
+ 1);
287 return (order
< 0 ? -1 : 1);
288 isc_region_consume(®ion1
, region1
.base
[0] + 1);
289 isc_region_consume(®ion2
, region2
.base
[0] + 1);
294 len
= ISC_MIN(region1
.base
[0], region2
.base
[0]);
295 order
= memcmp(region1
.base
, region2
.base
, len
+ 1);
297 return (order
< 0 ? -1 : 1);
298 isc_region_consume(®ion1
, region1
.base
[0] + 1);
299 isc_region_consume(®ion2
, region2
.base
[0] + 1);
304 dns_name_init(&name1
, NULL
);
305 dns_name_init(&name2
, NULL
);
307 dns_name_fromregion(&name1
, ®ion1
);
308 dns_name_fromregion(&name2
, ®ion2
);
310 return (dns_name_rdatacompare(&name1
, &name2
));
313 static inline isc_result_t
314 fromstruct_in_naptr(ARGS_FROMSTRUCT
) {
315 dns_rdata_in_naptr_t
*naptr
= source
;
319 REQUIRE(rdclass
== 1);
320 REQUIRE(source
!= NULL
);
321 REQUIRE(naptr
->common
.rdtype
== type
);
322 REQUIRE(naptr
->common
.rdclass
== rdclass
);
323 REQUIRE(naptr
->flags
!= NULL
|| naptr
->flags_len
== 0);
324 REQUIRE(naptr
->service
!= NULL
&& naptr
->service_len
== 0);
325 REQUIRE(naptr
->regexp
!= NULL
&& naptr
->regexp_len
== 0);
330 RETERR(uint16_tobuffer(naptr
->order
, target
));
331 RETERR(uint16_tobuffer(naptr
->preference
, target
));
332 RETERR(uint8_tobuffer(naptr
->flags_len
, target
));
333 RETERR(mem_tobuffer(target
, naptr
->flags
, naptr
->flags_len
));
334 RETERR(uint8_tobuffer(naptr
->service_len
, target
));
335 RETERR(mem_tobuffer(target
, naptr
->service
, naptr
->service_len
));
336 RETERR(uint8_tobuffer(naptr
->regexp_len
, target
));
337 RETERR(mem_tobuffer(target
, naptr
->regexp
, naptr
->regexp_len
));
338 dns_name_toregion(&naptr
->replacement
, ®ion
);
339 return (isc_buffer_copyregion(target
, ®ion
));
342 static inline isc_result_t
343 tostruct_in_naptr(ARGS_TOSTRUCT
) {
344 dns_rdata_in_naptr_t
*naptr
= target
;
349 REQUIRE(rdata
->type
== 35);
350 REQUIRE(rdata
->rdclass
== 1);
351 REQUIRE(target
!= NULL
);
352 REQUIRE(rdata
->length
!= 0);
354 naptr
->common
.rdclass
= rdata
->rdclass
;
355 naptr
->common
.rdtype
= rdata
->type
;
356 ISC_LINK_INIT(&naptr
->common
, link
);
359 naptr
->service
= NULL
;
360 naptr
->regexp
= NULL
;
362 dns_rdata_toregion(rdata
, &r
);
364 naptr
->order
= uint16_fromregion(&r
);
365 isc_region_consume(&r
, 2);
367 naptr
->preference
= uint16_fromregion(&r
);
368 isc_region_consume(&r
, 2);
370 naptr
->flags_len
= uint8_fromregion(&r
);
371 isc_region_consume(&r
, 1);
372 INSIST(naptr
->flags_len
<= r
.length
);
373 naptr
->flags
= mem_maybedup(mctx
, r
.base
, naptr
->flags_len
);
374 if (naptr
->flags
== NULL
)
376 isc_region_consume(&r
, naptr
->flags_len
);
378 naptr
->service_len
= uint8_fromregion(&r
);
379 isc_region_consume(&r
, 1);
380 INSIST(naptr
->service_len
<= r
.length
);
381 naptr
->service
= mem_maybedup(mctx
, r
.base
, naptr
->service_len
);
382 if (naptr
->service
== NULL
)
384 isc_region_consume(&r
, naptr
->service_len
);
386 naptr
->regexp_len
= uint8_fromregion(&r
);
387 isc_region_consume(&r
, 1);
388 INSIST(naptr
->regexp_len
<= r
.length
);
389 naptr
->regexp
= mem_maybedup(mctx
, r
.base
, naptr
->regexp_len
);
390 if (naptr
->regexp
== NULL
)
392 isc_region_consume(&r
, naptr
->regexp_len
);
394 dns_name_init(&name
, NULL
);
395 dns_name_fromregion(&name
, &r
);
396 dns_name_init(&naptr
->replacement
, NULL
);
397 result
= name_duporclone(&name
, mctx
, &naptr
->replacement
);
398 if (result
!= ISC_R_SUCCESS
)
401 return (ISC_R_SUCCESS
);
404 if (mctx
!= NULL
&& naptr
->flags
!= NULL
)
405 isc_mem_free(mctx
, naptr
->flags
);
406 if (mctx
!= NULL
&& naptr
->service
!= NULL
)
407 isc_mem_free(mctx
, naptr
->service
);
408 if (mctx
!= NULL
&& naptr
->regexp
!= NULL
)
409 isc_mem_free(mctx
, naptr
->regexp
);
410 return (ISC_R_NOMEMORY
);
414 freestruct_in_naptr(ARGS_FREESTRUCT
) {
415 dns_rdata_in_naptr_t
*naptr
= source
;
417 REQUIRE(source
!= NULL
);
418 REQUIRE(naptr
->common
.rdclass
== 1);
419 REQUIRE(naptr
->common
.rdtype
== 35);
421 if (naptr
->mctx
== NULL
)
424 if (naptr
->flags
!= NULL
)
425 isc_mem_free(naptr
->mctx
, naptr
->flags
);
426 if (naptr
->service
!= NULL
)
427 isc_mem_free(naptr
->mctx
, naptr
->service
);
428 if (naptr
->regexp
!= NULL
)
429 isc_mem_free(naptr
->mctx
, naptr
->regexp
);
430 dns_name_free(&naptr
->replacement
, naptr
->mctx
);
434 static inline isc_result_t
435 additionaldata_in_naptr(ARGS_ADDLDATA
) {
437 dns_offsets_t offsets
;
439 dns_rdatatype_t atype
;
440 unsigned int i
, flagslen
;
443 REQUIRE(rdata
->type
== 35);
444 REQUIRE(rdata
->rdclass
== 1);
449 dns_rdata_toregion(rdata
, &sr
);
450 isc_region_consume(&sr
, 4);
456 flagslen
= sr
.base
[0];
457 cp
= (char *)&sr
.base
[1];
458 for (i
= 0; i
< flagslen
; i
++, cp
++) {
459 if (*cp
== 'S' || *cp
== 's') {
460 atype
= dns_rdatatype_srv
;
463 if (*cp
== 'A' || *cp
== 'a') {
464 atype
= dns_rdatatype_a
;
468 isc_region_consume(&sr
, flagslen
+ 1);
473 isc_region_consume(&sr
, sr
.base
[0] + 1);
478 isc_region_consume(&sr
, sr
.base
[0] + 1);
483 dns_name_init(&name
, offsets
);
484 dns_name_fromregion(&name
, &sr
);
487 return ((add
)(arg
, &name
, atype
));
489 return (ISC_R_SUCCESS
);
492 static inline isc_result_t
493 digest_in_naptr(ARGS_DIGEST
) {
495 unsigned int length
, n
;
499 REQUIRE(rdata
->type
== 35);
500 REQUIRE(rdata
->rdclass
== 1);
502 dns_rdata_toregion(rdata
, &r1
);
510 isc_region_consume(&r2
, 4);
517 isc_region_consume(&r2
, n
);
524 isc_region_consume(&r2
, n
);
531 isc_region_consume(&r2
, n
);
534 * Digest the RR up to the replacement name.
537 result
= (digest
)(arg
, &r1
);
538 if (result
!= ISC_R_SUCCESS
)
545 dns_name_init(&name
, NULL
);
546 dns_name_fromregion(&name
, &r2
);
548 return (dns_name_digest(&name
, digest
, arg
));
551 #endif /* RDATA_IN_1_NAPTR_35_C */