contrib/unbound/services/view.c

   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
  47 int
  48 view_cmp(const void* v1, const void* v2)
  49 {
  50         struct view* a = (struct view*)v1;
  51         struct view* b = (struct view*)v2;
  52
  53         return strcmp(a->name, b->name);
  54 }
  55
  56 struct views*
  57 views_create(void)
  58 {
  59         struct views* v = (struct views*)calloc(1,
  60                 sizeof(*v));
  61         if(!v)
  62                 return NULL;
  63         rbtree_init(&v->vtree, &view_cmp);
  64         lock_rw_init(&v->lock);
  65         lock_protect(&v->lock, &v->vtree, sizeof(v->vtree));
  66         return v;
  67 }
  68
  69 /** This prototype is defined in in respip.h, but we want to avoid
  70   * unnecessary dependencies */
  71 void respip_set_delete(struct respip_set *set);
  72
  73 void
  74 view_delete(struct view* v)
  75 {
  76         if(!v)
  77                 return;
  78         lock_rw_destroy(&v->lock);
  79         local_zones_delete(v->local_zones);
  80         respip_set_delete(v->respip_set);
  81         free(v->name);
  82         free(v);
  83 }
  84
  85 static void
  86 delviewnode(rbnode_type* n, void* ATTR_UNUSED(arg))
  87 {
  88         struct view* v = (struct view*)n;
  89         view_delete(v);
  90 }
  91
  92 void
  93 views_delete(struct views* v)
  94 {
  95         if(!v)
  96                 return;
  97         lock_rw_destroy(&v->lock);
  98         traverse_postorder(&v->vtree, delviewnode, NULL);
  99         free(v);
 100 }
 101
 102 /** create a new view */
 103 static struct view*
 104 view_create(char* name)
 105 {
 106         struct view* v = (struct view*)calloc(1, sizeof(*v));
 107         if(!v)
 108                 return NULL;
 109         v->node.key = v;
 110         if(!(v->name = strdup(name))) {
 111                 free(v);
 112                 return NULL;
 113         }
 114         lock_rw_init(&v->lock);
 115         lock_protect(&v->lock, &v->name, sizeof(*v)-sizeof(rbnode_type));
 116         return v;
 117 }
 118
 119 /** enter a new view returns with WRlock */
 120 static struct view*
 121 views_enter_view_name(struct views* vs, char* name)
 122 {
 123         struct view* v = view_create(name);
 124         if(!v) {
 125                 log_err("out of memory");
 126                 return NULL;
 127         }
 128
 129         /* add to rbtree */
 130         lock_rw_wrlock(&vs->lock);
 131         lock_rw_wrlock(&v->lock);
 132         if(!rbtree_insert(&vs->vtree, &v->node)) {
 133                 log_warn("duplicate view: %s", name);
 134                 lock_rw_unlock(&v->lock);
 135                 view_delete(v);
 136                 lock_rw_unlock(&vs->lock);
 137                 return NULL;
 138         }
 139         lock_rw_unlock(&vs->lock);
 140         return v;
 141 }
 142
 143 int
 144 views_apply_cfg(struct views* vs, struct config_file* cfg)
 145 {
 146         struct config_view* cv;
 147         struct view* v;
 148         struct config_file lz_cfg;
 149         /* Check existence of name in first view (last in config). Rest of
 150          * views are already checked when parsing config. */
 151         if(cfg->views && !cfg->views->name) {
 152                 log_err("view without a name");
 153                 return 0;
 154         }
 155         for(cv = cfg->views; cv; cv = cv->next) {
 156                 /* create and enter view */
 157                 if(!(v = views_enter_view_name(vs, cv->name)))
 158                         return 0;
 159                 v->isfirst = cv->isfirst;
 160                 if(cv->local_zones || cv->local_data) {
 161                         if(!(v->local_zones = local_zones_create())){
 162                                 lock_rw_unlock(&v->lock);
 163                                 return 0;
 164                         }
 165                         memset(&lz_cfg, 0, sizeof(lz_cfg));
 166                         lz_cfg.local_zones = cv->local_zones;
 167                         lz_cfg.local_data = cv->local_data;
 168                         lz_cfg.local_zones_nodefault =
 169                                 cv->local_zones_nodefault;
 170                         if(!local_zones_apply_cfg(v->local_zones, &lz_cfg)){
 171                                 lock_rw_unlock(&v->lock);
 172                                 return 0;
 173                         }
 174                         /* local_zones, local_zones_nodefault and local_data
 175                          * are free'd from config_view by local_zones_apply_cfg.
 176                          * Set pointers to NULL. */
 177                         cv->local_zones = NULL;
 178                         cv->local_data = NULL;
 179                         cv->local_zones_nodefault = NULL;
 180                 }
 181                 lock_rw_unlock(&v->lock);
 182         }
 183         return 1;
 184 }
 185
 186 /** find a view by name */
 187 struct view*
 188 views_find_view(struct views* vs, const char* name, int write)
 189 {
 190         struct view* v;
 191         struct view key;
 192         key.node.key = &v;
 193         key.name = (char *)name;
 194         lock_rw_rdlock(&vs->lock);
 195         if(!(v = (struct view*)rbtree_search(&vs->vtree, &key.node))) {
 196                 lock_rw_unlock(&vs->lock);
 197                 return 0;
 198         }
 199         if(write) {
 200                 lock_rw_wrlock(&v->lock);
 201         } else {
 202                 lock_rw_rdlock(&v->lock);
 203         }
 204         lock_rw_unlock(&vs->lock);
 205         return v;
 206 }
 207
 208 void views_print(struct views* v)
 209 {
 210         /* TODO implement print */
 211         (void)v;
 212 }