1 /*
2 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
3 *
4 * This Source Code Form is subject to the terms of the Mozilla Public
5 * License, v. 2.0. If a copy of the MPL was not distributed with this
6 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 *
8 * See the COPYRIGHT file distributed with this work for additional
9 * information regarding copyright ownership.
10 */
11
12 /*! \file */
13
14 #include <isc/magic.h>
15 #include <isc/mem.h>
16 #include <isc/rwlock.h>
17 #include <isc/util.h>
18
19 #include <dns/forward.h>
20 #include <dns/rbt.h>
21 #include <dns/result.h>
22 #include <dns/types.h>
23
24 struct dns_fwdtable {
25 /* Unlocked. */
26 unsigned int magic;
27 isc_mem_t *mctx;
28 isc_rwlock_t rwlock;
29 /* Locked by lock. */
30 dns_rbt_t *table;
31 };
32
33 #define FWDTABLEMAGIC ISC_MAGIC('F', 'w', 'd', 'T')
34 #define VALID_FWDTABLE(ft) ISC_MAGIC_VALID(ft, FWDTABLEMAGIC)
35
36 static void
37 auto_detach(void *, void *);
38
39 isc_result_t
dns_fwdtable_create(isc_mem_t * mctx,dns_fwdtable_t ** fwdtablep)40 dns_fwdtable_create(isc_mem_t *mctx, dns_fwdtable_t **fwdtablep) {
41 dns_fwdtable_t *fwdtable;
42 isc_result_t result;
43
44 REQUIRE(fwdtablep != NULL && *fwdtablep == NULL);
45
46 fwdtable = isc_mem_get(mctx, sizeof(dns_fwdtable_t));
47
48 fwdtable->table = NULL;
49 result = dns_rbt_create(mctx, auto_detach, fwdtable, &fwdtable->table);
50 if (result != ISC_R_SUCCESS) {
51 goto cleanup_fwdtable;
52 }
53
54 result = isc_rwlock_init(&fwdtable->rwlock, 0, 0);
55 if (result != ISC_R_SUCCESS) {
56 goto cleanup_rbt;
57 }
58
59 fwdtable->mctx = NULL;
60 isc_mem_attach(mctx, &fwdtable->mctx);
61 fwdtable->magic = FWDTABLEMAGIC;
62 *fwdtablep = fwdtable;
63
64 return (ISC_R_SUCCESS);
65
66 cleanup_rbt:
67 dns_rbt_destroy(&fwdtable->table);
68
69 cleanup_fwdtable:
70 isc_mem_put(mctx, fwdtable, sizeof(dns_fwdtable_t));
71
72 return (result);
73 }
74
75 isc_result_t
dns_fwdtable_addfwd(dns_fwdtable_t * fwdtable,const dns_name_t * name,dns_forwarderlist_t * fwdrs,dns_fwdpolicy_t fwdpolicy)76 dns_fwdtable_addfwd(dns_fwdtable_t *fwdtable, const dns_name_t *name,
77 dns_forwarderlist_t *fwdrs, dns_fwdpolicy_t fwdpolicy) {
78 isc_result_t result;
79 dns_forwarders_t *forwarders;
80 dns_forwarder_t *fwd, *nfwd;
81
82 REQUIRE(VALID_FWDTABLE(fwdtable));
83
84 forwarders = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarders_t));
85
86 ISC_LIST_INIT(forwarders->fwdrs);
87 for (fwd = ISC_LIST_HEAD(*fwdrs); fwd != NULL;
88 fwd = ISC_LIST_NEXT(fwd, link)) {
89 nfwd = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarder_t));
90 *nfwd = *fwd;
91 ISC_LINK_INIT(nfwd, link);
92 ISC_LIST_APPEND(forwarders->fwdrs, nfwd, link);
93 }
94 forwarders->fwdpolicy = fwdpolicy;
95
96 RWLOCK(&fwdtable->rwlock, isc_rwlocktype_write);
97 result = dns_rbt_addname(fwdtable->table, name, forwarders);
98 RWUNLOCK(&fwdtable->rwlock, isc_rwlocktype_write);
99
100 if (result != ISC_R_SUCCESS) {
101 goto cleanup;
102 }
103
104 return (ISC_R_SUCCESS);
105
106 cleanup:
107 while (!ISC_LIST_EMPTY(forwarders->fwdrs)) {
108 fwd = ISC_LIST_HEAD(forwarders->fwdrs);
109 ISC_LIST_UNLINK(forwarders->fwdrs, fwd, link);
110 isc_mem_put(fwdtable->mctx, fwd, sizeof(isc_sockaddr_t));
111 }
112 isc_mem_put(fwdtable->mctx, forwarders, sizeof(dns_forwarders_t));
113 return (result);
114 }
115
116 isc_result_t
dns_fwdtable_add(dns_fwdtable_t * fwdtable,const dns_name_t * name,isc_sockaddrlist_t * addrs,dns_fwdpolicy_t fwdpolicy)117 dns_fwdtable_add(dns_fwdtable_t *fwdtable, const dns_name_t *name,
118 isc_sockaddrlist_t *addrs, dns_fwdpolicy_t fwdpolicy) {
119 isc_result_t result;
120 dns_forwarders_t *forwarders;
121 dns_forwarder_t *fwd;
122 isc_sockaddr_t *sa;
123
124 REQUIRE(VALID_FWDTABLE(fwdtable));
125
126 forwarders = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarders_t));
127
128 ISC_LIST_INIT(forwarders->fwdrs);
129 for (sa = ISC_LIST_HEAD(*addrs); sa != NULL;
130 sa = ISC_LIST_NEXT(sa, link)) {
131 fwd = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarder_t));
132 fwd->addr = *sa;
133 fwd->dscp = -1;
134 ISC_LINK_INIT(fwd, link);
135 ISC_LIST_APPEND(forwarders->fwdrs, fwd, link);
136 }
137 forwarders->fwdpolicy = fwdpolicy;
138
139 RWLOCK(&fwdtable->rwlock, isc_rwlocktype_write);
140 result = dns_rbt_addname(fwdtable->table, name, forwarders);
141 RWUNLOCK(&fwdtable->rwlock, isc_rwlocktype_write);
142
143 if (result != ISC_R_SUCCESS) {
144 goto cleanup;
145 }
146
147 return (ISC_R_SUCCESS);
148
149 cleanup:
150 while (!ISC_LIST_EMPTY(forwarders->fwdrs)) {
151 fwd = ISC_LIST_HEAD(forwarders->fwdrs);
152 ISC_LIST_UNLINK(forwarders->fwdrs, fwd, link);
153 isc_mem_put(fwdtable->mctx, fwd, sizeof(dns_forwarder_t));
154 }
155 isc_mem_put(fwdtable->mctx, forwarders, sizeof(dns_forwarders_t));
156 return (result);
157 }
158
159 isc_result_t
dns_fwdtable_delete(dns_fwdtable_t * fwdtable,const dns_name_t * name)160 dns_fwdtable_delete(dns_fwdtable_t *fwdtable, const dns_name_t *name) {
161 isc_result_t result;
162
163 REQUIRE(VALID_FWDTABLE(fwdtable));
164
165 RWLOCK(&fwdtable->rwlock, isc_rwlocktype_write);
166 result = dns_rbt_deletename(fwdtable->table, name, false);
167 RWUNLOCK(&fwdtable->rwlock, isc_rwlocktype_write);
168
169 if (result == DNS_R_PARTIALMATCH) {
170 result = ISC_R_NOTFOUND;
171 }
172
173 return (result);
174 }
175
176 isc_result_t
dns_fwdtable_find(dns_fwdtable_t * fwdtable,const dns_name_t * name,dns_name_t * foundname,dns_forwarders_t ** forwardersp)177 dns_fwdtable_find(dns_fwdtable_t *fwdtable, const dns_name_t *name,
178 dns_name_t *foundname, dns_forwarders_t **forwardersp) {
179 isc_result_t result;
180
181 REQUIRE(VALID_FWDTABLE(fwdtable));
182
183 RWLOCK(&fwdtable->rwlock, isc_rwlocktype_read);
184
185 result = dns_rbt_findname(fwdtable->table, name, 0, foundname,
186 (void **)forwardersp);
187 if (result == DNS_R_PARTIALMATCH) {
188 result = ISC_R_SUCCESS;
189 }
190
191 RWUNLOCK(&fwdtable->rwlock, isc_rwlocktype_read);
192
193 return (result);
194 }
195
196 void
dns_fwdtable_destroy(dns_fwdtable_t ** fwdtablep)197 dns_fwdtable_destroy(dns_fwdtable_t **fwdtablep) {
198 dns_fwdtable_t *fwdtable;
199
200 REQUIRE(fwdtablep != NULL && VALID_FWDTABLE(*fwdtablep));
201
202 fwdtable = *fwdtablep;
203 *fwdtablep = NULL;
204
205 dns_rbt_destroy(&fwdtable->table);
206 isc_rwlock_destroy(&fwdtable->rwlock);
207 fwdtable->magic = 0;
208
209 isc_mem_putanddetach(&fwdtable->mctx, fwdtable, sizeof(dns_fwdtable_t));
210 }
211
212 /***
213 *** Private
214 ***/
215
216 static void
auto_detach(void * data,void * arg)217 auto_detach(void *data, void *arg) {
218 dns_forwarders_t *forwarders = data;
219 dns_fwdtable_t *fwdtable = arg;
220 dns_forwarder_t *fwd;
221
222 UNUSED(arg);
223
224 while (!ISC_LIST_EMPTY(forwarders->fwdrs)) {
225 fwd = ISC_LIST_HEAD(forwarders->fwdrs);
226 ISC_LIST_UNLINK(forwarders->fwdrs, fwd, link);
227 isc_mem_put(fwdtable->mctx, fwd, sizeof(dns_forwarder_t));
228 }
229 isc_mem_put(fwdtable->mctx, forwarders, sizeof(dns_forwarders_t));
230 }
231