/*

 * services/view.c - named views containing local zones authority service.

 *

 * Copyright (c) 2016, NLnet Labs. All rights reserved.

 *

 * This software is open source.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 

 * Redistributions of source code must retain the above copyright notice,

 * this list of conditions and the following disclaimer.

 * 

 * Redistributions in binary form must reproduce the above copyright notice,

 * this list of conditions and the following disclaimer in the documentation

 * and/or other materials provided with the distribution.

 * 

 * Neither the name of the NLNET LABS nor the names of its contributors may

 * be used to endorse or promote products derived from this software without

 * specific prior written permission.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/**

 * \file

 *

 * This file contains functions to enable named views that can hold local zone

 * authority service.

 */

#include "config.h"

#include "services/view.h"

#include "services/localzone.h"

#include "util/config_file.h"

#include "respip/respip.h"

int 

view_cmp(const void* v1, const void* v2)

{

  struct view* a = (struct view*)v1;

  struct view* b = (struct view*)v2;

  return strcmp(a->name, b->name);

}

struct views* 

views_create(void)

{

  struct views* v = (struct views*)calloc(1, 

    sizeof(*v));

  if(!v)

    return NULL;

  rbtree_init(&v->vtree, &view_cmp);

  lock_rw_init(&v->lock);

  lock_protect(&v->lock, &v->vtree, sizeof(v->vtree));

  return v;

}

void 

view_delete(struct view* v)

{

  if(!v)

    return;

  lock_rw_destroy(&v->lock);

  local_zones_delete(v->local_zones);

  respip_set_delete(v->respip_set);

  free(v->name);

  free(v);

}

static void

delviewnode(rbnode_type* n, void* ATTR_UNUSED(arg))

{

  struct view* v = (struct view*)n;

  view_delete(v);

}

void 

views_delete(struct views* v)

{

  if(!v)

    return;

  lock_rw_destroy(&v->lock);

  traverse_postorder(&v->vtree, delviewnode, NULL);

  free(v);

}

/** create a new view */

static struct view*

view_create(char* name)

{

  struct view* v = (struct view*)calloc(1, sizeof(*v));

  if(!v)

    return NULL;

  v->node.key = v;

  if(!(v->name = strdup(name))) {

    free(v);

    return NULL;

  }

  lock_rw_init(&v->lock);

  lock_protect(&v->lock, &v->name, sizeof(*v)-sizeof(rbnode_type));

  return v;

}

/** enter a new view returns with WRlock */

static struct view*

views_enter_view_name(struct views* vs, char* name)

{

  struct view* v = view_create(name);

  if(!v) {

    log_err("out of memory");

    return NULL;

  }

  /* add to rbtree */

  lock_rw_wrlock(&vs->lock);

  lock_rw_wrlock(&v->lock);

  if(!rbtree_insert(&vs->vtree, &v->node)) {

    log_warn("duplicate view: %s", name);

    lock_rw_unlock(&v->lock);

    view_delete(v);

    lock_rw_unlock(&vs->lock);

    return NULL;

  }

  lock_rw_unlock(&vs->lock);

  return v;

}

int 

views_apply_cfg(struct views* vs, struct config_file* cfg)

{

  struct config_view* cv;

  struct view* v;

  struct config_file lz_cfg;

  /* Check existence of name in first view (last in config). Rest of

   * views are already checked when parsing config. */

  if(cfg->views && !cfg->views->name) {

    log_err("view without a name");

    return 0;

  }

  for(cv = cfg->views; cv; cv = cv->next) {

    /* create and enter view */

    if(!(v = views_enter_view_name(vs, cv->name)))

      return 0;

    v->isfirst = cv->isfirst;

    if(cv->local_zones || cv->local_data) {

      if(!(v->local_zones = local_zones_create())){

        lock_rw_unlock(&v->lock);

        return 0;

      }

      memset(&lz_cfg, 0, sizeof(lz_cfg));

      lz_cfg.local_zones = cv->local_zones;

      lz_cfg.local_data = cv->local_data;

      lz_cfg.local_zones_nodefault =

        cv->local_zones_nodefault;

      if(v->isfirst) {

        /* Do not add defaults to view-specific

         * local-zone when global local zone will be

         * used. */

        struct config_strlist* nd;

        lz_cfg.local_zones_disable_default = 1;

        /* Add nodefault zones to list of zones to add,

         * so they will be used as if they are

         * configured as type transparent */

        for(nd = cv->local_zones_nodefault; nd;

          nd = nd->next) {

          char* nd_str, *nd_type;

          nd_str = strdup(nd->str);

          if(!nd_str) {

            log_err("out of memory");

            lock_rw_unlock(&v->lock);

            return 0;

          }

          nd_type = strdup("nodefault");

          if(!nd_type) {

            log_err("out of memory");

            free(nd_str);

            lock_rw_unlock(&v->lock);

            return 0;

          }

          if(!cfg_str2list_insert(

            &lz_cfg.local_zones, nd_str,

            nd_type)) {

            log_err("failed to insert "

              "default zones into "

              "local-zone list");

            lock_rw_unlock(&v->lock);

            return 0;

          }

        }

      }

      if(!local_zones_apply_cfg(v->local_zones, &lz_cfg)){

        lock_rw_unlock(&v->lock);

        return 0;

      }

      /* local_zones, local_zones_nodefault and local_data 

       * are free'd from config_view by local_zones_apply_cfg.

       * Set pointers to NULL. */

      cv->local_zones = NULL;

      cv->local_data = NULL;

      cv->local_zones_nodefault = NULL;

    }

    lock_rw_unlock(&v->lock);

  }

  return 1;

}

/** find a view by name */

struct view*

views_find_view(struct views* vs, const char* name, int write)

{

  struct view* v;

  struct view key;

  key.node.key = &v;

  key.name = (char *)name;

  lock_rw_rdlock(&vs->lock);

  if(!(v = (struct view*)rbtree_search(&vs->vtree, &key.node))) {

    lock_rw_unlock(&vs->lock);

    return 0;

  }

  if(write) {

    lock_rw_wrlock(&v->lock);

  } else {

    lock_rw_rdlock(&v->lock);

  }

  lock_rw_unlock(&vs->lock);

  return v;

}

void views_print(struct views* v)

{

  /* TODO implement print */

  (void)v;

}

size_t views_get_mem(struct views* vs)

{

  struct view* v;

  size_t m;

  if(!vs) return 0;

  m = sizeof(struct views);

  lock_rw_rdlock(&vs->lock);

  RBTREE_FOR(v, struct view*, &vs->vtree) {

    m += view_get_mem(v);

  }

  lock_rw_unlock(&vs->lock);

  return m;

}

size_t view_get_mem(struct view* v)

{

  size_t m = sizeof(*v);

  lock_rw_rdlock(&v->lock);

  m += getmem_str(v->name);

  m += local_zones_get_mem(v->local_zones);

  m += respip_set_get_mem(v->respip_set);

  lock_rw_unlock(&v->lock);

  return m;

}

void views_swap_tree(struct views* vs, struct views* data)

{

  rbnode_type* oldroot = vs->vtree.root;

  size_t oldcount = vs->vtree.count;

  vs->vtree.root = data->vtree.root;

  vs->vtree.count = data->vtree.count;

  data->vtree.root = oldroot;

  data->vtree.count = oldcount;

}