/*
 * 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;
}