1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
* REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/* $Id: soa.c,v 1.3 2019/12/17 01:46:32 sthen Exp $ */
/*! \file */
#include <config.h>
#include <string.h>
#include <isc/buffer.h>
#include <isc/util.h>
#include <dns/rdata.h>
#include <dns/rdatastruct.h>
#include <dns/soa.h>
static inline isc_uint32_t
decode_uint32(unsigned char *p) {
return ((p[0] << 24) +
(p[1] << 16) +
(p[2] << 8) +
(p[3] << 0));
}
static inline void
encode_uint32(isc_uint32_t val, unsigned char *p) {
p[0] = (isc_uint8_t)(val >> 24);
p[1] = (isc_uint8_t)(val >> 16);
p[2] = (isc_uint8_t)(val >> 8);
p[3] = (isc_uint8_t)(val >> 0);
}
static isc_uint32_t
soa_get(dns_rdata_t *rdata, int offset) {
INSIST(rdata->type == dns_rdatatype_soa);
/*
* Locate the field within the SOA RDATA based
* on its position relative to the end of the data.
*
* This is a bit of a kludge, but the alternative approach of
* using dns_rdata_tostruct() and dns_rdata_fromstruct() would
* involve a lot of unnecessary work (like building domain
* names and allocating temporary memory) when all we really
* want to do is to get 32 bits of fixed-sized data.
*/
INSIST(rdata->length >= 20);
INSIST(offset >= 0 && offset <= 16);
return (decode_uint32(rdata->data + rdata->length - 20 + offset));
}
isc_result_t
dns_soa_buildrdata(dns_name_t *origin, dns_name_t *contact,
dns_rdataclass_t rdclass,
isc_uint32_t serial, isc_uint32_t refresh,
isc_uint32_t retry, isc_uint32_t expire,
isc_uint32_t minimum, unsigned char *buffer,
dns_rdata_t *rdata) {
dns_rdata_soa_t soa;
isc_buffer_t rdatabuf;
REQUIRE(origin != NULL);
REQUIRE(contact != NULL);
memset(buffer, 0, DNS_SOA_BUFFERSIZE);
isc_buffer_init(&rdatabuf, buffer, DNS_SOA_BUFFERSIZE);
soa.common.rdtype = dns_rdatatype_soa;
soa.common.rdclass = rdclass;
soa.mctx = NULL;
soa.serial = serial;
soa.refresh = refresh;
soa.retry = retry;
soa.expire = expire;
soa.minimum = minimum;
dns_name_init(&soa.origin, NULL);
dns_name_clone(origin, &soa.origin);
dns_name_init(&soa.contact, NULL);
dns_name_clone(contact, &soa.contact);
return (dns_rdata_fromstruct(rdata, rdclass, dns_rdatatype_soa,
&soa, &rdatabuf));
}
isc_uint32_t
dns_soa_getserial(dns_rdata_t *rdata) {
return soa_get(rdata, 0);
}
isc_uint32_t
dns_soa_getrefresh(dns_rdata_t *rdata) {
return soa_get(rdata, 4);
}
isc_uint32_t
dns_soa_getretry(dns_rdata_t *rdata) {
return soa_get(rdata, 8);
}
isc_uint32_t
dns_soa_getexpire(dns_rdata_t *rdata) {
return soa_get(rdata, 12);
}
isc_uint32_t
dns_soa_getminimum(dns_rdata_t *rdata) {
return soa_get(rdata, 16);
}
static void
soa_set(dns_rdata_t *rdata, isc_uint32_t val, int offset) {
INSIST(rdata->type == dns_rdatatype_soa);
INSIST(rdata->length >= 20);
INSIST(offset >= 0 && offset <= 16);
encode_uint32(val, rdata->data + rdata->length - 20 + offset);
}
void
dns_soa_setserial(isc_uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 0);
}
void
dns_soa_setrefresh(isc_uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 4);
}
void
dns_soa_setretry(isc_uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 8);
}
void
dns_soa_setexpire(isc_uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 12);
}
void
dns_soa_setminimum(isc_uint32_t val, dns_rdata_t *rdata) {
soa_set(rdata, val, 16);
}
|
