Coverage Report

Created: 2023-06-07 06:23

/src/bind9/lib/dns/rdata/generic/nid_104.c
Line
Count
Source (jump to first uncovered line)
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_NID_104_C
15
#define RDATA_GENERIC_NID_104_C
16
17
#include <string.h>
18
19
#include <isc/net.h>
20
21
10.6k
#define RRTYPE_NID_ATTRIBUTES (0)
22
23
static isc_result_t
24
717
fromtext_nid(ARGS_FROMTEXT) {
25
717
  isc_token_t token;
26
717
  unsigned char locator[NS_LOCATORSZ];
27
28
717
  REQUIRE(type == dns_rdatatype_nid);
29
30
717
  UNUSED(type);
31
717
  UNUSED(rdclass);
32
717
  UNUSED(origin);
33
717
  UNUSED(options);
34
717
  UNUSED(callbacks);
35
36
717
  RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
37
717
              false));
38
709
  if (token.value.as_ulong > 0xffffU) {
39
24
    RETTOK(ISC_R_RANGE);
40
24
  }
41
685
  RETERR(uint16_tobuffer(token.value.as_ulong, target));
42
43
685
  RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
44
685
              false));
45
46
649
  if (locator_pton(DNS_AS_STR(token), locator) != 1) {
47
51
    RETTOK(DNS_R_SYNTAX);
48
51
  }
49
598
  return (mem_tobuffer(target, locator, NS_LOCATORSZ));
50
649
}
51
52
static isc_result_t
53
1.12k
totext_nid(ARGS_TOTEXT) {
54
1.12k
  isc_region_t region;
55
1.12k
  char buf[sizeof("xxxx:xxxx:xxxx:xxxx")];
56
1.12k
  unsigned short num;
57
58
1.12k
  REQUIRE(rdata->type == dns_rdatatype_nid);
59
1.12k
  REQUIRE(rdata->length != 0);
60
61
1.12k
  UNUSED(tctx);
62
63
1.12k
  dns_rdata_toregion(rdata, &region);
64
1.12k
  num = uint16_fromregion(&region);
65
1.12k
  isc_region_consume(&region, 2);
66
1.12k
  snprintf(buf, sizeof(buf), "%u", num);
67
1.12k
  RETERR(str_totext(buf, target));
68
69
1.12k
  RETERR(str_totext(" ", target));
70
71
1.12k
  snprintf(buf, sizeof(buf), "%x:%x:%x:%x",
72
1.12k
     region.base[0] << 8 | region.base[1],
73
1.12k
     region.base[2] << 8 | region.base[3],
74
1.12k
     region.base[4] << 8 | region.base[5],
75
1.12k
     region.base[6] << 8 | region.base[7]);
76
1.12k
  return (str_totext(buf, target));
77
1.12k
}
78
79
static isc_result_t
80
1.36k
fromwire_nid(ARGS_FROMWIRE) {
81
1.36k
  isc_region_t sregion;
82
83
1.36k
  REQUIRE(type == dns_rdatatype_nid);
84
85
1.36k
  UNUSED(type);
86
1.36k
  UNUSED(rdclass);
87
1.36k
  UNUSED(dctx);
88
89
1.36k
  isc_buffer_activeregion(source, &sregion);
90
1.36k
  if (sregion.length != 10) {
91
64
    return (DNS_R_FORMERR);
92
64
  }
93
1.30k
  isc_buffer_forward(source, sregion.length);
94
1.30k
  return (mem_tobuffer(target, sregion.base, sregion.length));
95
1.36k
}
96
97
static isc_result_t
98
569
towire_nid(ARGS_TOWIRE) {
99
569
  REQUIRE(rdata->type == dns_rdatatype_nid);
100
569
  REQUIRE(rdata->length == 10);
101
102
569
  UNUSED(cctx);
103
104
569
  return (mem_tobuffer(target, rdata->data, rdata->length));
105
569
}
106
107
static int
108
1.57k
compare_nid(ARGS_COMPARE) {
109
1.57k
  isc_region_t region1;
110
1.57k
  isc_region_t region2;
111
112
1.57k
  REQUIRE(rdata1->type == rdata2->type);
113
1.57k
  REQUIRE(rdata1->rdclass == rdata2->rdclass);
114
1.57k
  REQUIRE(rdata1->type == dns_rdatatype_nid);
115
1.57k
  REQUIRE(rdata1->length == 10);
116
1.57k
  REQUIRE(rdata2->length == 10);
117
118
1.57k
  dns_rdata_toregion(rdata1, &region1);
119
1.57k
  dns_rdata_toregion(rdata2, &region2);
120
1.57k
  return (isc_region_compare(&region1, &region2));
121
1.57k
}
122
123
static isc_result_t
124
0
fromstruct_nid(ARGS_FROMSTRUCT) {
125
0
  dns_rdata_nid_t *nid = source;
126
127
0
  REQUIRE(type == dns_rdatatype_nid);
128
0
  REQUIRE(nid != NULL);
129
0
  REQUIRE(nid->common.rdtype == type);
130
0
  REQUIRE(nid->common.rdclass == rdclass);
131
132
0
  UNUSED(type);
133
0
  UNUSED(rdclass);
134
135
0
  RETERR(uint16_tobuffer(nid->pref, target));
136
0
  return (mem_tobuffer(target, nid->nid, sizeof(nid->nid)));
137
0
}
138
139
static isc_result_t
140
0
tostruct_nid(ARGS_TOSTRUCT) {
141
0
  isc_region_t region;
142
0
  dns_rdata_nid_t *nid = target;
143
144
0
  REQUIRE(rdata->type == dns_rdatatype_nid);
145
0
  REQUIRE(nid != NULL);
146
0
  REQUIRE(rdata->length == 10);
147
148
0
  UNUSED(mctx);
149
150
0
  nid->common.rdclass = rdata->rdclass;
151
0
  nid->common.rdtype = rdata->type;
152
0
  ISC_LINK_INIT(&nid->common, link);
153
154
0
  dns_rdata_toregion(rdata, &region);
155
0
  nid->pref = uint16_fromregion(&region);
156
0
  memmove(nid->nid, region.base, region.length);
157
0
  return (ISC_R_SUCCESS);
158
0
}
159
160
static void
161
0
freestruct_nid(ARGS_FREESTRUCT) {
162
0
  dns_rdata_nid_t *nid = source;
163
164
0
  REQUIRE(nid != NULL);
165
0
  REQUIRE(nid->common.rdtype == dns_rdatatype_nid);
166
167
0
  return;
168
0
}
169
170
static isc_result_t
171
0
additionaldata_nid(ARGS_ADDLDATA) {
172
0
  REQUIRE(rdata->type == dns_rdatatype_nid);
173
0
  REQUIRE(rdata->length == 10);
174
175
0
  UNUSED(rdata);
176
0
  UNUSED(owner);
177
0
  UNUSED(add);
178
0
  UNUSED(arg);
179
180
0
  return (ISC_R_SUCCESS);
181
0
}
182
183
static isc_result_t
184
0
digest_nid(ARGS_DIGEST) {
185
0
  isc_region_t r;
186
187
0
  REQUIRE(rdata->type == dns_rdatatype_nid);
188
0
  REQUIRE(rdata->length == 10);
189
190
0
  dns_rdata_toregion(rdata, &r);
191
192
0
  return ((digest)(arg, &r));
193
0
}
194
195
static bool
196
0
checkowner_nid(ARGS_CHECKOWNER) {
197
0
  REQUIRE(type == dns_rdatatype_nid);
198
199
0
  UNUSED(name);
200
0
  UNUSED(type);
201
0
  UNUSED(rdclass);
202
0
  UNUSED(wildcard);
203
204
0
  return (true);
205
0
}
206
207
static bool
208
0
checknames_nid(ARGS_CHECKNAMES) {
209
0
  REQUIRE(rdata->type == dns_rdatatype_nid);
210
0
  REQUIRE(rdata->length == 10);
211
212
0
  UNUSED(rdata);
213
0
  UNUSED(owner);
214
0
  UNUSED(bad);
215
216
0
  return (true);
217
0
}
218
219
static int
220
0
casecompare_nid(ARGS_COMPARE) {
221
0
  return (compare_nid(rdata1, rdata2));
222
0
}
223
224
#endif /* RDATA_GENERIC_NID_104_C */