1 /*
2 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
3 *
4 * SPDX-License-Identifier: MPL-2.0
5 *
6 * This Source Code Form is subject to the terms of the Mozilla Public
7 * License, v. 2.0. If a copy of the MPL was not distributed with this
8 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
9 *
10 * See the COPYRIGHT file distributed with this work for additional
11 * information regarding copyright ownership.
12 */
13
14 #ifndef RDATA_GENERIC_MF_4_C
15 #define RDATA_GENERIC_MF_4_C
16
17 #define RRTYPE_MF_ATTRIBUTES (0)
18
19 static inline isc_result_t
fromtext_mf(ARGS_FROMTEXT)20 fromtext_mf(ARGS_FROMTEXT) {
21 isc_token_t token;
22 dns_name_t name;
23 isc_buffer_t buffer;
24
25 REQUIRE(type == dns_rdatatype_mf);
26
27 UNUSED(type);
28 UNUSED(rdclass);
29 UNUSED(callbacks);
30
31 RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
32 false));
33
34 dns_name_init(&name, NULL);
35 buffer_fromregion(&buffer, &token.value.as_region);
36 if (origin == NULL) {
37 origin = dns_rootname;
38 }
39 RETTOK(dns_name_fromtext(&name, &buffer, origin, options, target));
40 return (ISC_R_SUCCESS);
41 }
42
43 static inline isc_result_t
totext_mf(ARGS_TOTEXT)44 totext_mf(ARGS_TOTEXT) {
45 isc_region_t region;
46 dns_name_t name;
47 dns_name_t prefix;
48 bool sub;
49
50 REQUIRE(rdata->type == dns_rdatatype_mf);
51 REQUIRE(rdata->length != 0);
52
53 dns_name_init(&name, NULL);
54 dns_name_init(&prefix, NULL);
55
56 dns_rdata_toregion(rdata, ®ion);
57 dns_name_fromregion(&name, ®ion);
58
59 sub = name_prefix(&name, tctx->origin, &prefix);
60
61 return (dns_name_totext(&prefix, sub, target));
62 }
63
64 static inline isc_result_t
fromwire_mf(ARGS_FROMWIRE)65 fromwire_mf(ARGS_FROMWIRE) {
66 dns_name_t name;
67
68 REQUIRE(type == dns_rdatatype_mf);
69
70 UNUSED(type);
71 UNUSED(rdclass);
72
73 dns_decompress_setmethods(dctx, DNS_COMPRESS_GLOBAL14);
74
75 dns_name_init(&name, NULL);
76 return (dns_name_fromwire(&name, source, dctx, options, target));
77 }
78
79 static inline isc_result_t
towire_mf(ARGS_TOWIRE)80 towire_mf(ARGS_TOWIRE) {
81 dns_name_t name;
82 dns_offsets_t offsets;
83 isc_region_t region;
84
85 REQUIRE(rdata->type == dns_rdatatype_mf);
86 REQUIRE(rdata->length != 0);
87
88 dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
89
90 dns_name_init(&name, offsets);
91 dns_rdata_toregion(rdata, ®ion);
92 dns_name_fromregion(&name, ®ion);
93
94 return (dns_name_towire(&name, cctx, target));
95 }
96
97 static inline int
compare_mf(ARGS_COMPARE)98 compare_mf(ARGS_COMPARE) {
99 dns_name_t name1;
100 dns_name_t name2;
101 isc_region_t region1;
102 isc_region_t region2;
103
104 REQUIRE(rdata1->type == rdata2->type);
105 REQUIRE(rdata1->rdclass == rdata2->rdclass);
106 REQUIRE(rdata1->type == dns_rdatatype_mf);
107 REQUIRE(rdata1->length != 0);
108 REQUIRE(rdata2->length != 0);
109
110 dns_name_init(&name1, NULL);
111 dns_name_init(&name2, NULL);
112
113 dns_rdata_toregion(rdata1, ®ion1);
114 dns_rdata_toregion(rdata2, ®ion2);
115
116 dns_name_fromregion(&name1, ®ion1);
117 dns_name_fromregion(&name2, ®ion2);
118
119 return (dns_name_rdatacompare(&name1, &name2));
120 }
121
122 static inline isc_result_t
fromstruct_mf(ARGS_FROMSTRUCT)123 fromstruct_mf(ARGS_FROMSTRUCT) {
124 dns_rdata_mf_t *mf = source;
125 isc_region_t region;
126
127 REQUIRE(type == dns_rdatatype_mf);
128 REQUIRE(mf != NULL);
129 REQUIRE(mf->common.rdtype == type);
130 REQUIRE(mf->common.rdclass == rdclass);
131
132 UNUSED(type);
133 UNUSED(rdclass);
134
135 dns_name_toregion(&mf->mf, ®ion);
136 return (isc_buffer_copyregion(target, ®ion));
137 }
138
139 static inline isc_result_t
tostruct_mf(ARGS_TOSTRUCT)140 tostruct_mf(ARGS_TOSTRUCT) {
141 dns_rdata_mf_t *mf = target;
142 isc_region_t r;
143 dns_name_t name;
144
145 REQUIRE(rdata->type == dns_rdatatype_mf);
146 REQUIRE(mf != NULL);
147 REQUIRE(rdata->length != 0);
148
149 mf->common.rdclass = rdata->rdclass;
150 mf->common.rdtype = rdata->type;
151 ISC_LINK_INIT(&mf->common, link);
152
153 dns_name_init(&name, NULL);
154 dns_rdata_toregion(rdata, &r);
155 dns_name_fromregion(&name, &r);
156 dns_name_init(&mf->mf, NULL);
157 RETERR(name_duporclone(&name, mctx, &mf->mf));
158 mf->mctx = mctx;
159 return (ISC_R_SUCCESS);
160 }
161
162 static inline void
freestruct_mf(ARGS_FREESTRUCT)163 freestruct_mf(ARGS_FREESTRUCT) {
164 dns_rdata_mf_t *mf = source;
165
166 REQUIRE(mf != NULL);
167 REQUIRE(mf->common.rdtype == dns_rdatatype_mf);
168
169 if (mf->mctx == NULL) {
170 return;
171 }
172 dns_name_free(&mf->mf, mf->mctx);
173 mf->mctx = NULL;
174 }
175
176 static inline isc_result_t
additionaldata_mf(ARGS_ADDLDATA)177 additionaldata_mf(ARGS_ADDLDATA) {
178 dns_name_t name;
179 dns_offsets_t offsets;
180 isc_region_t region;
181
182 REQUIRE(rdata->type == dns_rdatatype_mf);
183
184 dns_name_init(&name, offsets);
185 dns_rdata_toregion(rdata, ®ion);
186 dns_name_fromregion(&name, ®ion);
187
188 return ((add)(arg, &name, dns_rdatatype_a));
189 }
190
191 static inline isc_result_t
digest_mf(ARGS_DIGEST)192 digest_mf(ARGS_DIGEST) {
193 isc_region_t r;
194 dns_name_t name;
195
196 REQUIRE(rdata->type == dns_rdatatype_mf);
197
198 dns_rdata_toregion(rdata, &r);
199 dns_name_init(&name, NULL);
200 dns_name_fromregion(&name, &r);
201
202 return (dns_name_digest(&name, digest, arg));
203 }
204
205 static inline bool
checkowner_mf(ARGS_CHECKOWNER)206 checkowner_mf(ARGS_CHECKOWNER) {
207 REQUIRE(type == dns_rdatatype_mf);
208
209 UNUSED(name);
210 UNUSED(type);
211 UNUSED(rdclass);
212 UNUSED(wildcard);
213
214 return (true);
215 }
216
217 static inline bool
checknames_mf(ARGS_CHECKNAMES)218 checknames_mf(ARGS_CHECKNAMES) {
219 REQUIRE(rdata->type == dns_rdatatype_mf);
220
221 UNUSED(rdata);
222 UNUSED(owner);
223 UNUSED(bad);
224
225 return (true);
226 }
227
228 static inline int
casecompare_mf(ARGS_COMPARE)229 casecompare_mf(ARGS_COMPARE) {
230 return (compare_mf(rdata1, rdata2));
231 }
232
233 #endif /* RDATA_GENERIC_MF_4_C */
234