1 /* $NetBSD: https_65.c,v 1.2 2022/09/23 12:15:31 christos Exp $ */
2
3 /*
4 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
5 *
6 * SPDX-License-Identifier: MPL-2.0
7 *
8 * This Source Code Form is subject to the terms of the Mozilla Public
9 * License, v. 2.0. If a copy of the MPL was not distributed with this
10 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
11 *
12 * See the COPYRIGHT file distributed with this work for additional
13 * information regarding copyright ownership.
14 */
15
16 /* draft-ietf-dnsop-svcb-https-02 */
17
18 #ifndef RDATA_IN_1_HTTPS_65_C
19 #define RDATA_IN_1_HTTPS_65_C
20
21 #define RRTYPE_HTTPS_ATTRIBUTES 0
22
23 /*
24 * Most of these functions refer to equivalent functions for SVCB,
25 * since wire and presentation formats are identical.
26 */
27
28 static isc_result_t
fromtext_in_https(ARGS_FROMTEXT)29 fromtext_in_https(ARGS_FROMTEXT) {
30 REQUIRE(type == dns_rdatatype_https);
31 REQUIRE(rdclass == dns_rdataclass_in);
32
33 return (generic_fromtext_in_svcb(CALL_FROMTEXT));
34 }
35
36 static isc_result_t
totext_in_https(ARGS_TOTEXT)37 totext_in_https(ARGS_TOTEXT) {
38 REQUIRE(rdata->type == dns_rdatatype_https);
39 REQUIRE(rdata->rdclass == dns_rdataclass_in);
40 REQUIRE(rdata->length != 0);
41
42 return (generic_totext_in_svcb(CALL_TOTEXT));
43 }
44
45 static isc_result_t
fromwire_in_https(ARGS_FROMWIRE)46 fromwire_in_https(ARGS_FROMWIRE) {
47 REQUIRE(type == dns_rdatatype_https);
48 REQUIRE(rdclass == dns_rdataclass_in);
49
50 return (generic_fromwire_in_svcb(CALL_FROMWIRE));
51 }
52
53 static isc_result_t
towire_in_https(ARGS_TOWIRE)54 towire_in_https(ARGS_TOWIRE) {
55 REQUIRE(rdata->type == dns_rdatatype_https);
56 REQUIRE(rdata->length != 0);
57
58 return (generic_towire_in_svcb(CALL_TOWIRE));
59 }
60
61 static int
compare_in_https(ARGS_COMPARE)62 compare_in_https(ARGS_COMPARE) {
63 isc_region_t region1;
64 isc_region_t region2;
65
66 REQUIRE(rdata1->type == rdata2->type);
67 REQUIRE(rdata1->rdclass == rdata2->rdclass);
68 REQUIRE(rdata1->type == dns_rdatatype_https);
69 REQUIRE(rdata1->rdclass == dns_rdataclass_in);
70 REQUIRE(rdata1->length != 0);
71 REQUIRE(rdata2->length != 0);
72
73 dns_rdata_toregion(rdata1, ®ion1);
74 dns_rdata_toregion(rdata2, ®ion2);
75
76 return (isc_region_compare(®ion1, ®ion2));
77 }
78
79 static isc_result_t
fromstruct_in_https(ARGS_FROMSTRUCT)80 fromstruct_in_https(ARGS_FROMSTRUCT) {
81 dns_rdata_in_https_t *https = source;
82
83 REQUIRE(type == dns_rdatatype_https);
84 REQUIRE(rdclass == dns_rdataclass_in);
85 REQUIRE(https != NULL);
86 REQUIRE(https->common.rdtype == type);
87 REQUIRE(https->common.rdclass == rdclass);
88
89 return (generic_fromstruct_in_svcb(CALL_FROMSTRUCT));
90 }
91
92 static isc_result_t
tostruct_in_https(ARGS_TOSTRUCT)93 tostruct_in_https(ARGS_TOSTRUCT) {
94 dns_rdata_in_https_t *https = target;
95
96 REQUIRE(rdata->rdclass == dns_rdataclass_in);
97 REQUIRE(rdata->type == dns_rdatatype_https);
98 REQUIRE(https != NULL);
99 REQUIRE(rdata->length != 0);
100
101 return (generic_tostruct_in_svcb(CALL_TOSTRUCT));
102 }
103
104 static void
freestruct_in_https(ARGS_FREESTRUCT)105 freestruct_in_https(ARGS_FREESTRUCT) {
106 dns_rdata_in_https_t *https = source;
107
108 REQUIRE(https != NULL);
109 REQUIRE(https->common.rdclass == dns_rdataclass_in);
110 REQUIRE(https->common.rdtype == dns_rdatatype_https);
111
112 generic_freestruct_in_svcb(CALL_FREESTRUCT);
113 }
114
115 static isc_result_t
additionaldata_in_https(ARGS_ADDLDATA)116 additionaldata_in_https(ARGS_ADDLDATA) {
117 REQUIRE(rdata->type == dns_rdatatype_https);
118 REQUIRE(rdata->rdclass == dns_rdataclass_in);
119
120 return (generic_additionaldata_in_svcb(CALL_ADDLDATA));
121 }
122
123 static isc_result_t
digest_in_https(ARGS_DIGEST)124 digest_in_https(ARGS_DIGEST) {
125 isc_region_t region1;
126
127 REQUIRE(rdata->type == dns_rdatatype_https);
128 REQUIRE(rdata->rdclass == dns_rdataclass_in);
129
130 dns_rdata_toregion(rdata, ®ion1);
131 return ((digest)(arg, ®ion1));
132 }
133
134 static bool
checkowner_in_https(ARGS_CHECKOWNER)135 checkowner_in_https(ARGS_CHECKOWNER) {
136 REQUIRE(type == dns_rdatatype_https);
137 REQUIRE(rdclass == dns_rdataclass_in);
138
139 UNUSED(name);
140 UNUSED(type);
141 UNUSED(rdclass);
142 UNUSED(wildcard);
143
144 return (true);
145 }
146
147 static bool
checknames_in_https(ARGS_CHECKNAMES)148 checknames_in_https(ARGS_CHECKNAMES) {
149 REQUIRE(rdata->type == dns_rdatatype_https);
150 REQUIRE(rdata->rdclass == dns_rdataclass_in);
151
152 return (generic_checknames_in_svcb(CALL_CHECKNAMES));
153 }
154
155 static int
casecompare_in_https(ARGS_COMPARE)156 casecompare_in_https(ARGS_COMPARE) {
157 return (compare_in_https(rdata1, rdata2));
158 }
159
160 isc_result_t
dns_rdata_in_https_first(dns_rdata_in_https_t * https)161 dns_rdata_in_https_first(dns_rdata_in_https_t *https) {
162 REQUIRE(https != NULL);
163 REQUIRE(https->common.rdtype == dns_rdatatype_https);
164 REQUIRE(https->common.rdclass == dns_rdataclass_in);
165
166 return (generic_rdata_in_svcb_first(https));
167 }
168
169 isc_result_t
dns_rdata_in_https_next(dns_rdata_in_https_t * https)170 dns_rdata_in_https_next(dns_rdata_in_https_t *https) {
171 REQUIRE(https != NULL);
172 REQUIRE(https->common.rdtype == dns_rdatatype_https);
173 REQUIRE(https->common.rdclass == dns_rdataclass_in);
174
175 return (generic_rdata_in_svcb_next(https));
176 }
177
178 void
dns_rdata_in_https_current(dns_rdata_in_https_t * https,isc_region_t * region)179 dns_rdata_in_https_current(dns_rdata_in_https_t *https, isc_region_t *region) {
180 REQUIRE(https != NULL);
181 REQUIRE(https->common.rdtype == dns_rdatatype_https);
182 REQUIRE(https->common.rdclass == dns_rdataclass_in);
183 REQUIRE(region != NULL);
184
185 generic_rdata_in_svcb_current(https, region);
186 }
187
188 #endif /* RDATA_IN_1_HTTPS_65_C */
189