1 /*
2 * services/view.c - named views containing local zones authority service.
3 *
4 * Copyright (c) 2016, NLnet Labs. All rights reserved.
5 *
6 * This software is open source.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
14 *
15 * Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 *
19 * Neither the name of the NLNET LABS nor the names of its contributors may
20 * be used to endorse or promote products derived from this software without
21 * specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 */
35
36 /**
37 * \file
38 *
39 * This file contains functions to enable named views that can hold local zone
40 * authority service.
41 */
42 #include "config.h"
43 #include "services/view.h"
44 #include "services/localzone.h"
45 #include "util/config_file.h"
46 #include "respip/respip.h"
47
48 int
view_cmp(const void * v1,const void * v2)49 view_cmp(const void* v1, const void* v2)
50 {
51 struct view* a = (struct view*)v1;
52 struct view* b = (struct view*)v2;
53
54 return strcmp(a->name, b->name);
55 }
56
57 struct views*
views_create(void)58 views_create(void)
59 {
60 struct views* v = (struct views*)calloc(1,
61 sizeof(*v));
62 if(!v)
63 return NULL;
64 rbtree_init(&v->vtree, &view_cmp);
65 lock_rw_init(&v->lock);
66 lock_protect(&v->lock, &v->vtree, sizeof(v->vtree));
67 return v;
68 }
69
70 void
view_delete(struct view * v)71 view_delete(struct view* v)
72 {
73 if(!v)
74 return;
75 lock_rw_destroy(&v->lock);
76 local_zones_delete(v->local_zones);
77 respip_set_delete(v->respip_set);
78 free(v->name);
79 free(v);
80 }
81
82 static void
delviewnode(rbnode_type * n,void * ATTR_UNUSED (arg))83 delviewnode(rbnode_type* n, void* ATTR_UNUSED(arg))
84 {
85 struct view* v = (struct view*)n;
86 view_delete(v);
87 }
88
89 void
views_delete(struct views * v)90 views_delete(struct views* v)
91 {
92 if(!v)
93 return;
94 lock_rw_destroy(&v->lock);
95 traverse_postorder(&v->vtree, delviewnode, NULL);
96 free(v);
97 }
98
99 /** create a new view */
100 static struct view*
view_create(char * name)101 view_create(char* name)
102 {
103 struct view* v = (struct view*)calloc(1, sizeof(*v));
104 if(!v)
105 return NULL;
106 v->node.key = v;
107 if(!(v->name = strdup(name))) {
108 free(v);
109 return NULL;
110 }
111 lock_rw_init(&v->lock);
112 lock_protect(&v->lock, &v->name, sizeof(*v)-sizeof(rbnode_type));
113 return v;
114 }
115
116 /** enter a new view returns with WRlock */
117 static struct view*
views_enter_view_name(struct views * vs,char * name)118 views_enter_view_name(struct views* vs, char* name)
119 {
120 struct view* v = view_create(name);
121 if(!v) {
122 log_err("out of memory");
123 return NULL;
124 }
125
126 /* add to rbtree */
127 lock_rw_wrlock(&vs->lock);
128 lock_rw_wrlock(&v->lock);
129 if(!rbtree_insert(&vs->vtree, &v->node)) {
130 log_warn("duplicate view: %s", name);
131 lock_rw_unlock(&v->lock);
132 view_delete(v);
133 lock_rw_unlock(&vs->lock);
134 return NULL;
135 }
136 lock_rw_unlock(&vs->lock);
137 return v;
138 }
139
140 int
views_apply_cfg(struct views * vs,struct config_file * cfg)141 views_apply_cfg(struct views* vs, struct config_file* cfg)
142 {
143 struct config_view* cv;
144 struct view* v;
145 struct config_file lz_cfg;
146 /* Check existence of name in first view (last in config). Rest of
147 * views are already checked when parsing config. */
148 if(cfg->views && !cfg->views->name) {
149 log_err("view without a name");
150 return 0;
151 }
152 for(cv = cfg->views; cv; cv = cv->next) {
153 /* create and enter view */
154 if(!(v = views_enter_view_name(vs, cv->name)))
155 return 0;
156 v->isfirst = cv->isfirst;
157 if(cv->local_zones || cv->local_data) {
158 if(!(v->local_zones = local_zones_create())){
159 lock_rw_unlock(&v->lock);
160 return 0;
161 }
162 memset(&lz_cfg, 0, sizeof(lz_cfg));
163 lz_cfg.local_zones = cv->local_zones;
164 lz_cfg.local_data = cv->local_data;
165 lz_cfg.local_zones_nodefault =
166 cv->local_zones_nodefault;
167 if(v->isfirst) {
168 /* Do not add defaults to view-specific
169 * local-zone when global local zone will be
170 * used. */
171 struct config_strlist* nd;
172 lz_cfg.local_zones_disable_default = 1;
173 /* Add nodefault zones to list of zones to add,
174 * so they will be used as if they are
175 * configured as type transparent */
176 for(nd = cv->local_zones_nodefault; nd;
177 nd = nd->next) {
178 char* nd_str, *nd_type;
179 nd_str = strdup(nd->str);
180 if(!nd_str) {
181 log_err("out of memory");
182 lock_rw_unlock(&v->lock);
183 return 0;
184 }
185 nd_type = strdup("nodefault");
186 if(!nd_type) {
187 log_err("out of memory");
188 free(nd_str);
189 lock_rw_unlock(&v->lock);
190 return 0;
191 }
192 if(!cfg_str2list_insert(
193 &lz_cfg.local_zones, nd_str,
194 nd_type)) {
195 log_err("failed to insert "
196 "default zones into "
197 "local-zone list");
198 lock_rw_unlock(&v->lock);
199 return 0;
200 }
201 }
202 }
203 if(!local_zones_apply_cfg(v->local_zones, &lz_cfg)){
204 lock_rw_unlock(&v->lock);
205 return 0;
206 }
207 /* local_zones, local_zones_nodefault and local_data
208 * are free'd from config_view by local_zones_apply_cfg.
209 * Set pointers to NULL. */
210 cv->local_zones = NULL;
211 cv->local_data = NULL;
212 cv->local_zones_nodefault = NULL;
213 }
214 lock_rw_unlock(&v->lock);
215 }
216 return 1;
217 }
218
219 /** find a view by name */
220 struct view*
views_find_view(struct views * vs,const char * name,int write)221 views_find_view(struct views* vs, const char* name, int write)
222 {
223 struct view* v;
224 struct view key;
225 key.node.key = &v;
226 key.name = (char *)name;
227 lock_rw_rdlock(&vs->lock);
228 if(!(v = (struct view*)rbtree_search(&vs->vtree, &key.node))) {
229 lock_rw_unlock(&vs->lock);
230 return 0;
231 }
232 if(write) {
233 lock_rw_wrlock(&v->lock);
234 } else {
235 lock_rw_rdlock(&v->lock);
236 }
237 lock_rw_unlock(&vs->lock);
238 return v;
239 }
240
views_print(struct views * v)241 void views_print(struct views* v)
242 {
243 /* TODO implement print */
244 (void)v;
245 }
246
views_get_mem(struct views * vs)247 size_t views_get_mem(struct views* vs)
248 {
249 struct view* v;
250 size_t m;
251 if(!vs) return 0;
252 m = sizeof(struct views);
253 lock_rw_rdlock(&vs->lock);
254 RBTREE_FOR(v, struct view*, &vs->vtree) {
255 m += view_get_mem(v);
256 }
257 lock_rw_unlock(&vs->lock);
258 return m;
259 }
260
view_get_mem(struct view * v)261 size_t view_get_mem(struct view* v)
262 {
263 size_t m = sizeof(*v);
264 lock_rw_rdlock(&v->lock);
265 m += getmem_str(v->name);
266 m += local_zones_get_mem(v->local_zones);
267 m += respip_set_get_mem(v->respip_set);
268 lock_rw_unlock(&v->lock);
269 return m;
270 }
271
views_swap_tree(struct views * vs,struct views * data)272 void views_swap_tree(struct views* vs, struct views* data)
273 {
274 rbnode_type* oldroot = vs->vtree.root;
275 size_t oldcount = vs->vtree.count;
276 vs->vtree.root = data->vtree.root;
277 vs->vtree.count = data->vtree.count;
278 data->vtree.root = oldroot;
279 data->vtree.count = oldcount;
280 }
281