/*
 * util/module.c - module interface
 *
 * Copyright (c) 2007, 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
 * Implementation of module.h.
 */

#include "config.h"
#include "util/module.h"
#include "sldns/wire2str.h"
#include "util/config_file.h"
#include "util/regional.h"
#include "util/data/dname.h"
#include "util/net_help.h"

const char* 
strextstate(enum module_ext_state s)
{
        switch(s) {
        case module_state_initial: return "module_state_initial";
        case module_wait_reply: return "module_wait_reply";
        case module_wait_module: return "module_wait_module";
        case module_restart_next: return "module_restart_next";
        case module_wait_subquery: return "module_wait_subquery";
        case module_error: return "module_error";
        case module_finished: return "module_finished";
        }
        return "bad_extstate_value";
}

const char* 
strmodulevent(enum module_ev e)
{
        switch(e) {
        case module_event_new: return "module_event_new";
        case module_event_pass: return "module_event_pass";
        case module_event_reply: return "module_event_reply";
        case module_event_noreply: return "module_event_noreply";
        case module_event_capsfail: return "module_event_capsfail";
        case module_event_moddone: return "module_event_moddone";
        case module_event_error: return "module_event_error";
        }
        return "bad_event_value";
}

void errinf(struct module_qstate* qstate, const char* str)
{
        errinf_ede(qstate, str, LDNS_EDE_NONE);
}

void errinf_ede(struct module_qstate* qstate,
        const char* str, sldns_ede_code reason_bogus)
{
        struct errinf_strlist* p;
        if(!str || (qstate->env->cfg->val_log_level < 2 &&
                !qstate->env->cfg->log_servfail)) {
                return;
        }
        p = (struct errinf_strlist*)regional_alloc(qstate->region, sizeof(*p));
        if(!p) {
                log_err("malloc failure in validator-error-info string");
                return;
        }
        p->next = NULL;
        p->str = regional_strdup(qstate->region, str);
        p->reason_bogus = reason_bogus;
        if(!p->str) {
                log_err("malloc failure in validator-error-info string");
                return;
        }
        /* add at end */
        if(qstate->errinf) {
                struct errinf_strlist* q = qstate->errinf;
                while(q->next)
                        q = q->next;
                q->next = p;
        } else  qstate->errinf = p;
}

void errinf_origin(struct module_qstate* qstate, struct sock_list *origin)
{
        struct sock_list* p;
        if(qstate->env->cfg->val_log_level < 2 && !qstate->env->cfg->log_servfail)
                return;
        for(p=origin; p; p=p->next) {
                char buf[256];
                if(p == origin)
                        snprintf(buf, sizeof(buf), "from ");
                else    snprintf(buf, sizeof(buf), "and ");
                if(p->len == 0)
                        snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), 
                                "cache");
                else 
                        addr_to_str(&p->addr, p->len, buf+strlen(buf),
                                sizeof(buf)-strlen(buf));
                errinf(qstate, buf);
        }
}

char* errinf_to_str_bogus(struct module_qstate* qstate, struct regional* region)
{
        char buf[20480];
        char* p = buf;
        size_t left = sizeof(buf);
        struct errinf_strlist* s;
        char dname[LDNS_MAX_DOMAINLEN];
        char t[16], c[16];
        sldns_wire2str_type_buf(qstate->qinfo.qtype, t, sizeof(t));
        sldns_wire2str_class_buf(qstate->qinfo.qclass, c, sizeof(c));
        dname_str(qstate->qinfo.qname, dname);
        snprintf(p, left, "validation failure <%s %s %s>:", dname, t, c);
        left -= strlen(p); p += strlen(p);
        if(!qstate->errinf)
                snprintf(p, left, " misc failure");
        else for(s=qstate->errinf; s; s=s->next) {
                snprintf(p, left, " %s", s->str);
                left -= strlen(p); p += strlen(p);
        }
        if(region)
                p = regional_strdup(region, buf);
        else
                p = strdup(buf);
        if(!p)
                log_err("malloc failure in errinf_to_str");
        return p;
}

/* Try to find the latest (most specific) dnssec failure */
sldns_ede_code errinf_to_reason_bogus(struct module_qstate* qstate)
{
        struct errinf_strlist* s;
        sldns_ede_code ede = LDNS_EDE_NONE;
        for(s=qstate->errinf; s; s=s->next) {
                if(s->reason_bogus == LDNS_EDE_NONE) continue;
                if(ede != LDNS_EDE_NONE
                        && ede != LDNS_EDE_DNSSEC_BOGUS
                        && s->reason_bogus == LDNS_EDE_DNSSEC_BOGUS) continue;
                ede = s->reason_bogus;
        }
        return ede;
}

char* errinf_to_str_servfail(struct module_qstate* qstate)
{
        char buf[20480];
        char* p = buf;
        size_t left = sizeof(buf);
        struct errinf_strlist* s;
        char dname[LDNS_MAX_DOMAINLEN];
        char t[16], c[16];
        sldns_wire2str_type_buf(qstate->qinfo.qtype, t, sizeof(t));
        sldns_wire2str_class_buf(qstate->qinfo.qclass, c, sizeof(c));
        dname_str(qstate->qinfo.qname, dname);
        snprintf(p, left, "SERVFAIL <%s %s %s>:", dname, t, c);
        left -= strlen(p); p += strlen(p);
        if(!qstate->errinf)
                snprintf(p, left, " misc failure");
        else for(s=qstate->errinf; s; s=s->next) {
                snprintf(p, left, " %s", s->str);
                left -= strlen(p); p += strlen(p);
        }
        p = regional_strdup(qstate->region, buf);
        if(!p)
                log_err("malloc failure in errinf_to_str");
        return p;
}

char* errinf_to_str_misc(struct module_qstate* qstate)
{
        char buf[20480];
        char* p = buf;
        size_t left = sizeof(buf);
        struct errinf_strlist* s;
        if(!qstate->errinf)
                snprintf(p, left, "misc failure");
        else for(s=qstate->errinf; s; s=s->next) {
                snprintf(p, left, "%s%s", (s==qstate->errinf?"":" "), s->str);
                left -= strlen(p); p += strlen(p);
        }
        p = regional_strdup(qstate->region, buf);
        if(!p)
                log_err("malloc failure in errinf_to_str");
        return p;
}

void errinf_rrset(struct module_qstate* qstate, struct ub_packed_rrset_key *rr)
{
        char buf[1024];
        char dname[LDNS_MAX_DOMAINLEN];
        char t[16], c[16];
        if((qstate->env->cfg->val_log_level < 2 && !qstate->env->cfg->log_servfail) || !rr)
                return;
        sldns_wire2str_type_buf(ntohs(rr->rk.type), t, sizeof(t));
        sldns_wire2str_class_buf(ntohs(rr->rk.rrset_class), c, sizeof(c));
        dname_str(rr->rk.dname, dname);
        snprintf(buf, sizeof(buf), "for <%s %s %s>", dname, t, c);
        errinf(qstate, buf);
}

void errinf_dname(struct module_qstate* qstate, const char* str, uint8_t* dname)
{
        char b[1024];
        char buf[LDNS_MAX_DOMAINLEN];
        if((qstate->env->cfg->val_log_level < 2 && !qstate->env->cfg->log_servfail) || !str || !dname)
                return;
        dname_str(dname, buf);
        snprintf(b, sizeof(b), "%s %s", str, buf);
        errinf(qstate, b);
}

int
edns_known_options_init(struct module_env* env)
{
        env->edns_known_options_num = 0;
        env->edns_known_options = (struct edns_known_option*)calloc(
                MAX_KNOWN_EDNS_OPTS, sizeof(struct edns_known_option));
        if(!env->edns_known_options) return 0;
        return 1;
}

void
edns_known_options_delete(struct module_env* env)
{
        free(env->edns_known_options);
        env->edns_known_options = NULL;
        env->edns_known_options_num = 0;
}

int
edns_register_option(uint16_t opt_code, int bypass_cache_stage,
        int no_aggregation, struct module_env* env)
{
        size_t i;
        if(env->worker) {
                log_err("invalid edns registration: "
                        "trying to register option after module init phase");
                return 0;
        }

        /**
         * Checking if we are full first is faster but it does not provide
         * the option to change the flags when the array is full.
         * It only impacts unbound initialization, leave it for now.
         */
        /* Check if the option is already registered. */
        for(i=0; i<env->edns_known_options_num; i++)
                if(env->edns_known_options[i].opt_code == opt_code)
                        break;
        /* If it is not yet registered check if we have space to add a new one. */
        if(i == env->edns_known_options_num) {
                if(env->edns_known_options_num >= MAX_KNOWN_EDNS_OPTS) {
                        log_err("invalid edns registration: maximum options reached");
                        return 0;
                }
                env->edns_known_options_num++;
        }
        env->edns_known_options[i].opt_code = opt_code;
        env->edns_known_options[i].bypass_cache_stage = bypass_cache_stage;
        env->edns_known_options[i].no_aggregation = no_aggregation;
        return 1;
}

int
inplace_cb_register(void* cb, enum inplace_cb_list_type type, void* cbarg,
        struct module_env* env, int id)
{
        struct inplace_cb* callback;
        struct inplace_cb** prevp;
        if(env->worker) {
                log_err("invalid edns callback registration: "
                        "trying to register callback after module init phase");
                return 0;
        }

        callback = (struct inplace_cb*)calloc(1, sizeof(*callback));
        if(callback == NULL) {
                log_err("out of memory during edns callback registration.");
                return 0;
        }
        callback->id = id;
        callback->next = NULL;
        callback->cb = cb;
        callback->cb_arg = cbarg;
        
        prevp = (struct inplace_cb**) &env->inplace_cb_lists[type];
        /* append at end of list */
        while(*prevp != NULL)
                prevp = &((*prevp)->next);
        *prevp = callback;
        return 1;
}

void
inplace_cb_delete(struct module_env* env, enum inplace_cb_list_type type,
        int id)
{
        struct inplace_cb* temp = env->inplace_cb_lists[type];
        struct inplace_cb* prev = NULL;

        while(temp) {
                if(temp->id == id) {
                        if(!prev) {
                                env->inplace_cb_lists[type] = temp->next;
                                free(temp);
                                temp = env->inplace_cb_lists[type];
                        }
                        else {
                                prev->next = temp->next;
                                free(temp);
                                temp = prev->next;
                        }
                }
                else {
                        prev = temp;
                        temp = temp->next;
                }
        }
}

struct edns_known_option*
edns_option_is_known(uint16_t opt_code, struct module_env* env)
{
        size_t i;
        for(i=0; i<env->edns_known_options_num; i++)
                if(env->edns_known_options[i].opt_code == opt_code)
                        return env->edns_known_options + i;
        return NULL;
}

int
edns_bypass_cache_stage(struct edns_option* list, struct module_env* env)
{
        size_t i;
        for(; list; list=list->next)
                for(i=0; i<env->edns_known_options_num; i++)
                        if(env->edns_known_options[i].opt_code == list->opt_code &&
                                env->edns_known_options[i].bypass_cache_stage == 1)
                                        return 1;
        return 0;
}

int
unique_mesh_state(struct edns_option* list, struct module_env* env)
{
        size_t i;
        if(env->unique_mesh)
                return 1;
        for(; list; list=list->next)
                for(i=0; i<env->edns_known_options_num; i++)
                        if(env->edns_known_options[i].opt_code == list->opt_code &&
                                env->edns_known_options[i].no_aggregation == 1)
                                        return 1;
        return 0;
}

void
log_edns_known_options(enum verbosity_value level, struct module_env* env)
{
        size_t i;
        char str[32], *s;
        size_t slen;
        if(env->edns_known_options_num > 0 && verbosity >= level) {
                verbose(level, "EDNS known options:");
                verbose(level, "  Code:    Bypass_cache_stage: Aggregate_mesh:");
                for(i=0; i<env->edns_known_options_num; i++) {
                        s = str;
                        slen = sizeof(str);
                        (void)sldns_wire2str_edns_option_code_print(&s, &slen,
                                env->edns_known_options[i].opt_code);
                        verbose(level, "  %-8.8s %-19s %-15s", str,
                                env->edns_known_options[i].bypass_cache_stage?"YES":"NO",
                                env->edns_known_options[i].no_aggregation?"NO":"YES");
                }
        }
}

void
copy_state_to_super(struct module_qstate* qstate, int ATTR_UNUSED(id),
        struct module_qstate* super)
{
        /* Overwrite super's was_ratelimited only when it was not set */
        if(!super->was_ratelimited) {
                super->was_ratelimited = qstate->was_ratelimited;
        }
}