/src/bind9/lib/dns/rdata/generic/amtrelay_260.c

Source
/*
 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
 *
 * See the COPYRIGHT file distributed with this work for additional
 * information regarding copyright ownership.
 */

#ifndef RDATA_GENERIC_AMTRELAY_260_C
#define RDATA_GENERIC_AMTRELAY_260_C

#include <string.h>

#include <isc/net.h>

#define RRTYPE_AMTRELAY_ATTRIBUTES (0)

static isc_result_t
fromtext_amtrelay(ARGS_FROMTEXT) {
  isc_token_t token;
  isc_buffer_t buffer;
  unsigned int discovery;
  unsigned int gateway;
  struct in_addr addr;
  unsigned char addr6[16];
  isc_region_t region;

  REQUIRE(type == dns_rdatatype_amtrelay);

  UNUSED(type);
  UNUSED(rdclass);
  UNUSED(callbacks);

  /*
   * Precedence.
   */
  RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
              false));
  if (token.value.as_ulong > 0xffU) {
    RETTOK(ISC_R_RANGE);
  }
  RETERR(uint8_tobuffer(token.value.as_ulong, target));

  /*
   * Discovery.
   */
  RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
              false));
  if (token.value.as_ulong > 1U) {
    RETTOK(ISC_R_RANGE);
  }
  discovery = token.value.as_ulong;

  /*
   * Gateway type.
   */
  RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
              false));
  if (token.value.as_ulong > 0x7fU) {
    RETTOK(ISC_R_RANGE);
  }
  RETERR(uint8_tobuffer(token.value.as_ulong | (discovery << 7), target));
  gateway = token.value.as_ulong;

  /*
   * Gateway (must exist).
   */
  RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
              false));

  if (gateway > 3) {
    return ISC_R_NOTIMPLEMENTED;
  }

  switch (gateway) {
  case 0:
    if (strcmp(DNS_AS_STR(token), ".") != 0) {
      RETTOK(DNS_R_SYNTAX);
    }
    return ISC_R_SUCCESS;
  case 1:
    if (inet_pton(AF_INET, DNS_AS_STR(token), &addr) != 1) {
      RETTOK(DNS_R_BADDOTTEDQUAD);
    }
    isc_buffer_availableregion(target, &region);
    if (region.length < 4) {
      return ISC_R_NOSPACE;
    }
    memmove(region.base, &addr, 4);
    isc_buffer_add(target, 4);
    return ISC_R_SUCCESS;

  case 2:
    if (inet_pton(AF_INET6, DNS_AS_STR(token), addr6) != 1) {
      RETTOK(DNS_R_BADAAAA);
    }
    isc_buffer_availableregion(target, &region);
    if (region.length < 16) {
      return ISC_R_NOSPACE;
    }
    memmove(region.base, addr6, 16);
    isc_buffer_add(target, 16);
    return ISC_R_SUCCESS;

  case 3:
    buffer_fromregion(&buffer, &token.value.as_region);
    if (origin == NULL) {
      origin = dns_rootname;
    }
    return dns_name_wirefromtext(&buffer, origin, options, target);
  default:
    UNREACHABLE();
  }
}

static isc_result_t
totext_amtrelay(ARGS_TOTEXT) {
  isc_region_t region;
  dns_name_t name;
  char buf[sizeof("0 255 ")];
  unsigned char precedence;
  unsigned char discovery;
  unsigned char gateway;

  UNUSED(tctx);

  REQUIRE(rdata->type == dns_rdatatype_amtrelay);
  REQUIRE(rdata->length >= 2);

  if ((rdata->data[1] & 0x7f) > 3U) {
    return ISC_R_NOTIMPLEMENTED;
  }

  /*
   * Precedence.
   */
  dns_rdata_toregion(rdata, &region);
  precedence = uint8_fromregion(&region);
  isc_region_consume(&region, 1);
  snprintf(buf, sizeof(buf), "%u ", precedence);
  RETERR(str_totext(buf, target));

  /*
   * Discovery and Gateway type.
   */
  gateway = uint8_fromregion(&region);
  discovery = gateway >> 7;
  gateway &= 0x7f;
  isc_region_consume(&region, 1);
  snprintf(buf, sizeof(buf), "%u %u ", discovery, gateway);
  RETERR(str_totext(buf, target));

  /*
   * Gateway.
   */
  switch (gateway) {
  case 0:
    return str_totext(".", target);

  case 1:
    return inet_totext(AF_INET, tctx->flags, &region, target);

  case 2:
    return inet_totext(AF_INET6, tctx->flags, &region, target);

  case 3:
    dns_name_init(&name);
    dns_name_fromregion(&name, &region);
    return dns_name_totext(&name, 0, target);

  default:
    UNREACHABLE();
  }
  return ISC_R_SUCCESS;
}

static isc_result_t
fromwire_amtrelay(ARGS_FROMWIRE) {
  dns_name_t name;
  isc_region_t region;

  REQUIRE(type == dns_rdatatype_amtrelay);

  UNUSED(type);
  UNUSED(rdclass);

  dctx = dns_decompress_setpermitted(dctx, false);

  isc_buffer_activeregion(source, &region);
  if (region.length < 2) {
    return ISC_R_UNEXPECTEDEND;
  }

  switch (region.base[1] & 0x7f) {
  case 0:
    if (region.length != 2) {
      return DNS_R_FORMERR;
    }
    isc_buffer_forward(source, region.length);
    return mem_tobuffer(target, region.base, region.length);

  case 1:
    if (region.length != 6) {
      return DNS_R_FORMERR;
    }
    isc_buffer_forward(source, region.length);
    return mem_tobuffer(target, region.base, region.length);

  case 2:
    if (region.length != 18) {
      return DNS_R_FORMERR;
    }
    isc_buffer_forward(source, region.length);
    return mem_tobuffer(target, region.base, region.length);

  case 3:
    RETERR(mem_tobuffer(target, region.base, 2));
    isc_buffer_forward(source, 2);
    dns_name_init(&name);
    return dns_name_fromwire(&name, source, dctx, target);

  default:
    isc_buffer_forward(source, region.length);
    return mem_tobuffer(target, region.base, region.length);
  }
}

static isc_result_t
towire_amtrelay(ARGS_TOWIRE) {
  isc_region_t region;

  REQUIRE(rdata->type == dns_rdatatype_amtrelay);
  REQUIRE(rdata->length != 0);

  UNUSED(cctx);

  dns_rdata_toregion(rdata, &region);
  return mem_tobuffer(target, region.base, region.length);
}

static int
compare_amtrelay(ARGS_COMPARE) {
  isc_region_t region1;
  isc_region_t region2;

  REQUIRE(rdata1->type == rdata2->type);
  REQUIRE(rdata1->rdclass == rdata2->rdclass);
  REQUIRE(rdata1->type == dns_rdatatype_amtrelay);
  REQUIRE(rdata1->length >= 2);
  REQUIRE(rdata2->length >= 2);

  dns_rdata_toregion(rdata1, &region1);
  dns_rdata_toregion(rdata2, &region2);

  return isc_region_compare(&region1, &region2);
}

static isc_result_t
fromstruct_amtrelay(ARGS_FROMSTRUCT) {
  dns_rdata_amtrelay_t *amtrelay = source;
  isc_region_t region;
  uint32_t n;

  REQUIRE(type == dns_rdatatype_amtrelay);
  REQUIRE(amtrelay != NULL);
  REQUIRE(amtrelay->common.rdtype == type);
  REQUIRE(amtrelay->common.rdclass == rdclass);

  UNUSED(type);
  UNUSED(rdclass);

  RETERR(uint8_tobuffer(amtrelay->precedence, target));
  n = (amtrelay->discovery ? 0x80 : 0) | amtrelay->gateway_type;
  RETERR(uint8_tobuffer(n, target));

  switch (amtrelay->gateway_type) {
  case 0:
    return ISC_R_SUCCESS;

  case 1:
    n = ntohl(amtrelay->in_addr.s_addr);
    return uint32_tobuffer(n, target);

  case 2:
    return mem_tobuffer(target, amtrelay->in6_addr.s6_addr, 16);
    break;

  case 3:
    dns_name_toregion(&amtrelay->gateway, &region);
    return isc_buffer_copyregion(target, &region);
    break;

  default:
    return mem_tobuffer(target, amtrelay->data, amtrelay->length);
  }
}

static isc_result_t
tostruct_amtrelay(ARGS_TOSTRUCT) {
  isc_region_t region;
  dns_rdata_amtrelay_t *amtrelay = target;
  dns_name_t name;
  uint32_t n;

  REQUIRE(rdata->type == dns_rdatatype_amtrelay);
  REQUIRE(amtrelay != NULL);
  REQUIRE(rdata->length >= 2);

  DNS_RDATACOMMON_INIT(amtrelay, rdata->type, rdata->rdclass);

  dns_name_init(&amtrelay->gateway);
  amtrelay->data = NULL;

  dns_name_init(&name);
  dns_rdata_toregion(rdata, &region);

  amtrelay->precedence = uint8_fromregion(&region);
  isc_region_consume(&region, 1);

  amtrelay->gateway_type = uint8_fromregion(&region);
  amtrelay->discovery = (amtrelay->gateway_type & 0x80) != 0;
  amtrelay->gateway_type &= 0x7f;
  isc_region_consume(&region, 1);

  switch (amtrelay->gateway_type) {
  case 0:
    break;

  case 1:
    n = uint32_fromregion(&region);
    amtrelay->in_addr.s_addr = htonl(n);
    isc_region_consume(&region, 4);
    break;

  case 2:
    memmove(amtrelay->in6_addr.s6_addr, region.base, 16);
    isc_region_consume(&region, 16);
    break;

  case 3:
    dns_name_fromregion(&name, &region);
    name_duporclone(&name, mctx, &amtrelay->gateway);
    isc_region_consume(&region, name_length(&name));
    break;

  default:
    if (region.length != 0) {
      amtrelay->data = mem_maybedup(mctx, region.base,
                  region.length);
    }
    amtrelay->length = region.length;
  }
  amtrelay->mctx = mctx;
  return ISC_R_SUCCESS;
}

static void
freestruct_amtrelay(ARGS_FREESTRUCT) {
  dns_rdata_amtrelay_t *amtrelay = source;

  REQUIRE(amtrelay != NULL);
  REQUIRE(amtrelay->common.rdtype == dns_rdatatype_amtrelay);

  if (amtrelay->mctx == NULL) {
    return;
  }

  if (amtrelay->gateway_type == 3) {
    dns_name_free(&amtrelay->gateway, amtrelay->mctx);
  }

  if (amtrelay->data != NULL) {
    isc_mem_free(amtrelay->mctx, amtrelay->data);
  }

  amtrelay->mctx = NULL;
}

static isc_result_t
additionaldata_amtrelay(ARGS_ADDLDATA) {
  REQUIRE(rdata->type == dns_rdatatype_amtrelay);

  UNUSED(rdata);
  UNUSED(owner);
  UNUSED(add);
  UNUSED(arg);

  return ISC_R_SUCCESS;
}

static isc_result_t
digest_amtrelay(ARGS_DIGEST) {
  isc_region_t region;

  REQUIRE(rdata->type == dns_rdatatype_amtrelay);

  dns_rdata_toregion(rdata, &region);
  return (digest)(arg, &region);
}

static bool
checkowner_amtrelay(ARGS_CHECKOWNER) {
  REQUIRE(type == dns_rdatatype_amtrelay);

  UNUSED(name);
  UNUSED(type);
  UNUSED(rdclass);
  UNUSED(wildcard);

  return true;
}

static bool
checknames_amtrelay(ARGS_CHECKNAMES) {
  REQUIRE(rdata->type == dns_rdatatype_amtrelay);

  UNUSED(rdata);
  UNUSED(owner);
  UNUSED(bad);

  return true;
}

static int
casecompare_amtrelay(ARGS_COMPARE) {
  isc_region_t region1;
  isc_region_t region2;
  dns_name_t name1;
  dns_name_t name2;

  REQUIRE(rdata1->type == rdata2->type);
  REQUIRE(rdata1->rdclass == rdata2->rdclass);
  REQUIRE(rdata1->type == dns_rdatatype_amtrelay);
  REQUIRE(rdata1->length >= 2);
  REQUIRE(rdata2->length >= 2);

  dns_rdata_toregion(rdata1, &region1);
  dns_rdata_toregion(rdata2, &region2);

  if (memcmp(region1.base, region2.base, 2) != 0 ||
      (region1.base[1] & 0x7f) != 3)
  {
    return isc_region_compare(&region1, &region2);
  }

  dns_name_init(&name1);
  dns_name_init(&name2);

  isc_region_consume(&region1, 2);
  isc_region_consume(&region2, 2);

  dns_name_fromregion(&name1, &region1);
  dns_name_fromregion(&name2, &region2);

  return dns_name_rdatacompare(&name1, &name2);
}

#endif /* RDATA_GENERIC_AMTRELAY_260_C */

Coverage Report

Created: 2025-12-14 06:31

Line	Count	Source
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_AMTRELAY_260_C
15		#define RDATA_GENERIC_AMTRELAY_260_C
16
17		#include <string.h>
18
19		#include <isc/net.h>
20
21	15.9k	#define RRTYPE_AMTRELAY_ATTRIBUTES (0)
22
23		static isc_result_t
24	409	fromtext_amtrelay(ARGS_FROMTEXT) {
25	409	isc_token_t token;
26	409	isc_buffer_t buffer;
27	409	unsigned int discovery;
28	409	unsigned int gateway;
29	409	struct in_addr addr;
30	409	unsigned char addr6[16];
31	409	isc_region_t region;
32
33	409	REQUIRE(type == dns_rdatatype_amtrelay);
34
35	409	UNUSED(type);
36	409	UNUSED(rdclass);
37	409	UNUSED(callbacks);
38
39		/*
40		* Precedence.
41		*/
42	409	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
43	409	false));
44	403	if (token.value.as_ulong > 0xffU) {
45	45	RETTOK(ISC_R_RANGE);
46	45	}
47	358	RETERR(uint8_tobuffer(token.value.as_ulong, target));
48
49		/*
50		* Discovery.
51		*/
52	358	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
53	358	false));
54	340	if (token.value.as_ulong > 1U) {
55	45	RETTOK(ISC_R_RANGE);
56	45	}
57	295	discovery = token.value.as_ulong;
58
59		/*
60		* Gateway type.
61		*/
62	295	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number,
63	295	false));
64	292	if (token.value.as_ulong > 0x7fU) {
65	14	RETTOK(ISC_R_RANGE);
66	14	}
67	278	RETERR(uint8_tobuffer(token.value.as_ulong \| (discovery << 7), target));
68	278	gateway = token.value.as_ulong;
69
70		/*
71		* Gateway (must exist).
72		*/
73	278	RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
74	278	false));
75
76	276	if (gateway > 3) {
77	3	return ISC_R_NOTIMPLEMENTED;
78	3	}
79
80	273	switch (gateway) {
81	20	case 0:
82	20	if (strcmp(DNS_AS_STR(token), ".") != 0) {
83	3	RETTOK(DNS_R_SYNTAX);
84	3	}
85	17	return ISC_R_SUCCESS;
86	6	case 1:
87	6	if (inet_pton(AF_INET, DNS_AS_STR(token), &addr) != 1) {
88	2	RETTOK(DNS_R_BADDOTTEDQUAD);
89	2	}
90	4	isc_buffer_availableregion(target, &region);
91	4	if (region.length < 4) {
92	0	return ISC_R_NOSPACE;
93	0	}
94	4	memmove(region.base, &addr, 4);
95	4	isc_buffer_add(target, 4);
96	4	return ISC_R_SUCCESS;
97
98	5	case 2:
99	5	if (inet_pton(AF_INET6, DNS_AS_STR(token), addr6) != 1) {
100	2	RETTOK(DNS_R_BADAAAA);
101	2	}
102	3	isc_buffer_availableregion(target, &region);
103	3	if (region.length < 16) {
104	0	return ISC_R_NOSPACE;
105	0	}
106	3	memmove(region.base, addr6, 16);
107	3	isc_buffer_add(target, 16);
108	3	return ISC_R_SUCCESS;
109
110	242	case 3:
111	242	buffer_fromregion(&buffer, &token.value.as_region);
112	242	if (origin == NULL) {
113	1	origin = dns_rootname;
114	1	}
115	242	return dns_name_wirefromtext(&buffer, origin, options, target);
116	0	default:
117	0	UNREACHABLE();
118	273	}
119	273	}
120
121		static isc_result_t
122	3.20k	totext_amtrelay(ARGS_TOTEXT) {
123	3.20k	isc_region_t region;
124	3.20k	dns_name_t name;
125	3.20k	char buf[sizeof("0 255 ")];
126	3.20k	unsigned char precedence;
127	3.20k	unsigned char discovery;
128	3.20k	unsigned char gateway;
129
130	3.20k	UNUSED(tctx);
131
132	3.20k	REQUIRE(rdata->type == dns_rdatatype_amtrelay);
133	3.20k	REQUIRE(rdata->length >= 2);
134
135	3.20k	if ((rdata->data[1] & 0x7f) > 3U) {
136	1.67k	return ISC_R_NOTIMPLEMENTED;
137	1.67k	}
138
139		/*
140		* Precedence.
141		*/
142	1.53k	dns_rdata_toregion(rdata, &region);
143	1.53k	precedence = uint8_fromregion(&region);
144	1.53k	isc_region_consume(&region, 1);
145	1.53k	snprintf(buf, sizeof(buf), "%u ", precedence);
146	1.53k	RETERR(str_totext(buf, target));
147
148		/*
149		* Discovery and Gateway type.
150		*/
151	1.53k	gateway = uint8_fromregion(&region);
152	1.53k	discovery = gateway >> 7;
153	1.53k	gateway &= 0x7f;
154	1.53k	isc_region_consume(&region, 1);
155	1.53k	snprintf(buf, sizeof(buf), "%u %u ", discovery, gateway);
156	1.53k	RETERR(str_totext(buf, target));
157
158		/*
159		* Gateway.
160		*/
161	1.53k	switch (gateway) {
162	535	case 0:
163	535	return str_totext(".", target);
164
165	459	case 1:
166	459	return inet_totext(AF_INET, tctx->flags, &region, target);
167
168	242	case 2:
169	242	return inet_totext(AF_INET6, tctx->flags, &region, target);
170
171	296	case 3:
172	296	dns_name_init(&name);
173	296	dns_name_fromregion(&name, &region);
174	296	return dns_name_totext(&name, 0, target);
175
176	0	default:
177	0	UNREACHABLE();
178	1.53k	}
179	0	return ISC_R_SUCCESS;
180	1.53k	}
181
182		static isc_result_t
183	5.25k	fromwire_amtrelay(ARGS_FROMWIRE) {
184	5.25k	dns_name_t name;
185	5.25k	isc_region_t region;
186
187	5.25k	REQUIRE(type == dns_rdatatype_amtrelay);
188
189	5.25k	UNUSED(type);
190	5.25k	UNUSED(rdclass);
191
192	5.25k	dctx = dns_decompress_setpermitted(dctx, false);
193
194	5.25k	isc_buffer_activeregion(source, &region);
195	5.25k	if (region.length < 2) {
196	9	return ISC_R_UNEXPECTEDEND;
197	9	}
198
199	5.25k	switch (region.base[1] & 0x7f) {
200	1.14k	case 0:
201	1.14k	if (region.length != 2) {
202	6	return DNS_R_FORMERR;
203	6	}
204	1.14k	isc_buffer_forward(source, region.length);
205	1.14k	return mem_tobuffer(target, region.base, region.length);
206
207	535	case 1:
208	535	if (region.length != 6) {
209	8	return DNS_R_FORMERR;
210	8	}
211	527	isc_buffer_forward(source, region.length);
212	527	return mem_tobuffer(target, region.base, region.length);
213
214	463	case 2:
215	463	if (region.length != 18) {
216	22	return DNS_R_FORMERR;
217	22	}
218	441	isc_buffer_forward(source, region.length);
219	441	return mem_tobuffer(target, region.base, region.length);
220
221	716	case 3:
222	716	RETERR(mem_tobuffer(target, region.base, 2));
223	521	isc_buffer_forward(source, 2);
224	521	dns_name_init(&name);
225	521	return dns_name_fromwire(&name, source, dctx, target);
226
227	2.39k	default:
228	2.39k	isc_buffer_forward(source, region.length);
229	2.39k	return mem_tobuffer(target, region.base, region.length);
230	5.25k	}
231	5.25k	}
232
233		static isc_result_t
234	1.65k	towire_amtrelay(ARGS_TOWIRE) {
235	1.65k	isc_region_t region;
236
237	1.65k	REQUIRE(rdata->type == dns_rdatatype_amtrelay);
238	1.65k	REQUIRE(rdata->length != 0);
239
240	1.65k	UNUSED(cctx);
241
242	1.65k	dns_rdata_toregion(rdata, &region);
243	1.65k	return mem_tobuffer(target, region.base, region.length);
244	1.65k	}
245
246		static int
247	1.11k	compare_amtrelay(ARGS_COMPARE) {
248	1.11k	isc_region_t region1;
249	1.11k	isc_region_t region2;
250
251	1.11k	REQUIRE(rdata1->type == rdata2->type);
252	1.11k	REQUIRE(rdata1->rdclass == rdata2->rdclass);
253	1.11k	REQUIRE(rdata1->type == dns_rdatatype_amtrelay);
254	1.11k	REQUIRE(rdata1->length >= 2);
255	1.11k	REQUIRE(rdata2->length >= 2);
256
257	1.11k	dns_rdata_toregion(rdata1, &region1);
258	1.11k	dns_rdata_toregion(rdata2, &region2);
259
260	1.11k	return isc_region_compare(&region1, &region2);
261	1.11k	}
262
263		static isc_result_t
264	0	fromstruct_amtrelay(ARGS_FROMSTRUCT) {
265	0	dns_rdata_amtrelay_t *amtrelay = source;
266	0	isc_region_t region;
267	0	uint32_t n;
268
269	0	REQUIRE(type == dns_rdatatype_amtrelay);
270	0	REQUIRE(amtrelay != NULL);
271	0	REQUIRE(amtrelay->common.rdtype == type);
272	0	REQUIRE(amtrelay->common.rdclass == rdclass);
273
274	0	UNUSED(type);
275	0	UNUSED(rdclass);
276
277	0	RETERR(uint8_tobuffer(amtrelay->precedence, target));
278	0	n = (amtrelay->discovery ? 0x80 : 0) \| amtrelay->gateway_type;
279	0	RETERR(uint8_tobuffer(n, target));
280
281	0	switch (amtrelay->gateway_type) {
282	0	case 0:
283	0	return ISC_R_SUCCESS;
284
285	0	case 1:
286	0	n = ntohl(amtrelay->in_addr.s_addr);
287	0	return uint32_tobuffer(n, target);
288
289	0	case 2:
290	0	return mem_tobuffer(target, amtrelay->in6_addr.s6_addr, 16);
291	0	break;
292
293	0	case 3:
294	0	dns_name_toregion(&amtrelay->gateway, &region);
295	0	return isc_buffer_copyregion(target, &region);
296	0	break;
297
298	0	default:
299	0	return mem_tobuffer(target, amtrelay->data, amtrelay->length);
300	0	}
301	0	}
302
303		static isc_result_t
304	0	tostruct_amtrelay(ARGS_TOSTRUCT) {
305	0	isc_region_t region;
306	0	dns_rdata_amtrelay_t *amtrelay = target;
307	0	dns_name_t name;
308	0	uint32_t n;
309
310	0	REQUIRE(rdata->type == dns_rdatatype_amtrelay);
311	0	REQUIRE(amtrelay != NULL);
312	0	REQUIRE(rdata->length >= 2);
313
314	0	DNS_RDATACOMMON_INIT(amtrelay, rdata->type, rdata->rdclass);
315
316	0	dns_name_init(&amtrelay->gateway);
317	0	amtrelay->data = NULL;
318
319	0	dns_name_init(&name);
320	0	dns_rdata_toregion(rdata, &region);
321
322	0	amtrelay->precedence = uint8_fromregion(&region);
323	0	isc_region_consume(&region, 1);
324
325	0	amtrelay->gateway_type = uint8_fromregion(&region);
326	0	amtrelay->discovery = (amtrelay->gateway_type & 0x80) != 0;
327	0	amtrelay->gateway_type &= 0x7f;
328	0	isc_region_consume(&region, 1);
329
330	0	switch (amtrelay->gateway_type) {
331	0	case 0:
332	0	break;
333
334	0	case 1:
335	0	n = uint32_fromregion(&region);
336	0	amtrelay->in_addr.s_addr = htonl(n);
337	0	isc_region_consume(&region, 4);
338	0	break;
339
340	0	case 2:
341	0	memmove(amtrelay->in6_addr.s6_addr, region.base, 16);
342	0	isc_region_consume(&region, 16);
343	0	break;
344
345	0	case 3:
346	0	dns_name_fromregion(&name, &region);
347	0	name_duporclone(&name, mctx, &amtrelay->gateway);
348	0	isc_region_consume(&region, name_length(&name));
349	0	break;
350
351	0	default:
352	0	if (region.length != 0) {
353	0	amtrelay->data = mem_maybedup(mctx, region.base,
354	0	region.length);
355	0	}
356	0	amtrelay->length = region.length;
357	0	}
358	0	amtrelay->mctx = mctx;
359	0	return ISC_R_SUCCESS;
360	0	}
361
362		static void
363	0	freestruct_amtrelay(ARGS_FREESTRUCT) {
364	0	dns_rdata_amtrelay_t *amtrelay = source;
365
366	0	REQUIRE(amtrelay != NULL);
367	0	REQUIRE(amtrelay->common.rdtype == dns_rdatatype_amtrelay);
368
369	0	if (amtrelay->mctx == NULL) {
370	0	return;
371	0	}
372
373	0	if (amtrelay->gateway_type == 3) {
374	0	dns_name_free(&amtrelay->gateway, amtrelay->mctx);
375	0	}
376
377	0	if (amtrelay->data != NULL) {
378	0	isc_mem_free(amtrelay->mctx, amtrelay->data);
379	0	}
380
381	0	amtrelay->mctx = NULL;
382	0	}
383
384		static isc_result_t
385	0	additionaldata_amtrelay(ARGS_ADDLDATA) {
386	0	REQUIRE(rdata->type == dns_rdatatype_amtrelay);
387
388	0	UNUSED(rdata);
389	0	UNUSED(owner);
390	0	UNUSED(add);
391	0	UNUSED(arg);
392
393	0	return ISC_R_SUCCESS;
394	0	}
395
396		static isc_result_t
397	0	digest_amtrelay(ARGS_DIGEST) {
398	0	isc_region_t region;
399
400	0	REQUIRE(rdata->type == dns_rdatatype_amtrelay);
401
402	0	dns_rdata_toregion(rdata, &region);
403	0	return (digest)(arg, &region);
404	0	}
405
406		static bool
407	0	checkowner_amtrelay(ARGS_CHECKOWNER) {
408	0	REQUIRE(type == dns_rdatatype_amtrelay);
409
410	0	UNUSED(name);
411	0	UNUSED(type);
412	0	UNUSED(rdclass);
413	0	UNUSED(wildcard);
414
415	0	return true;
416	0	}
417
418		static bool
419	0	checknames_amtrelay(ARGS_CHECKNAMES) {
420	0	REQUIRE(rdata->type == dns_rdatatype_amtrelay);
421
422	0	UNUSED(rdata);
423	0	UNUSED(owner);
424	0	UNUSED(bad);
425
426	0	return true;
427	0	}
428
429		static int
430	0	casecompare_amtrelay(ARGS_COMPARE) {
431	0	isc_region_t region1;
432	0	isc_region_t region2;
433	0	dns_name_t name1;
434	0	dns_name_t name2;
435
436	0	REQUIRE(rdata1->type == rdata2->type);
437	0	REQUIRE(rdata1->rdclass == rdata2->rdclass);
438	0	REQUIRE(rdata1->type == dns_rdatatype_amtrelay);
439	0	REQUIRE(rdata1->length >= 2);
440	0	REQUIRE(rdata2->length >= 2);
441
442	0	dns_rdata_toregion(rdata1, &region1);
443	0	dns_rdata_toregion(rdata2, &region2);
444
445	0	if (memcmp(region1.base, region2.base, 2) != 0 \|\|
446	0	(region1.base[1] & 0x7f) != 3)
447	0	{
448	0	return isc_region_compare(&region1, &region2);
449	0	}
450
451	0	dns_name_init(&name1);
452	0	dns_name_init(&name2);
453
454	0	isc_region_consume(&region1, 2);
455	0	isc_region_consume(&region2, 2);
456
457	0	dns_name_fromregion(&name1, &region1);
458	0	dns_name_fromregion(&name2, &region2);
459
460	0	return dns_name_rdatacompare(&name1, &name2);
461	0	}
462
463		#endif /* RDATA_GENERIC_AMTRELAY_260_C */