module.h

Go to the documentation of this file.

/*
 * util/module.h - DNS handling 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.
 */
 
#ifndef UTIL_MODULE_H
#define UTIL_MODULE_H
#include "util/storage/lruhash.h"
#include "util/data/msgreply.h"
#include "util/data/msgparse.h"
struct sldns_buffer;
struct alloc_cache;
struct rrset_cache;
struct key_cache;
struct config_file;
struct slabhash;
struct query_info;
struct edns_data;
struct regional;
struct worker;
struct comm_base;
struct auth_zones;
struct outside_network;
struct module_qstate;
struct ub_randstate;
struct mesh_area;
struct mesh_state;
struct val_anchors;
struct val_neg_cache;
struct iter_forwards;
struct iter_hints;
struct respip_set;
struct respip_client_info;
struct respip_addr_info;
 
#define MAX_MODULE 16
 
#define MAX_KNOWN_EDNS_OPTS 256
 
enum inplace_cb_list_type {
    /* Inplace callbacks for when a resolved reply is ready to be sent to the
     * front.*/
    inplace_cb_reply = 0,
    /* Inplace callbacks for when a reply is given from the cache. */
    inplace_cb_reply_cache,
    /* Inplace callbacks for when a reply is given with local data
     * (or Chaos reply). */
    inplace_cb_reply_local,
    /* Inplace callbacks for when the reply is servfail. */
    inplace_cb_reply_servfail,
    /* Inplace callbacks for when a query is ready to be sent to the back.*/
    inplace_cb_query,
    /* Inplace callback for when a reply is received from the back. */
    inplace_cb_query_response,
    /* Inplace callback for when EDNS is parsed on a reply received from the
     * back. */
    inplace_cb_edns_back_parsed,
    /* Total number of types. Used for array initialization.
     * Should always be last. */
    inplace_cb_types_total
};
 
 
struct edns_known_option {
    uint16_t opt_code;
    int bypass_cache_stage;
    int no_aggregation;
};
 
struct inplace_cb {
    struct inplace_cb* next;
    void* cb;
    void* cb_arg;
    int id;
};
 
typedef int inplace_cb_reply_func_type(struct query_info* qinfo,
    struct module_qstate* qstate, struct reply_info* rep, int rcode,
    struct edns_data* edns, struct edns_option** opt_list_out, 
    struct regional* region, int id, void* callback);
 
typedef int inplace_cb_query_func_type(struct query_info* qinfo, uint16_t flags,
    struct module_qstate* qstate, struct sockaddr_storage* addr,
    socklen_t addrlen, uint8_t* zone, size_t zonelen, struct regional* region,
    int id, void* callback);
 
typedef int inplace_cb_edns_back_parsed_func_type(struct module_qstate* qstate, 
    int id, void* cb_args);
 
typedef int inplace_cb_query_response_func_type(struct module_qstate* qstate,
    struct dns_msg* response, int id, void* cb_args);
 
struct module_env {
    /* --- data --- */
    struct config_file* cfg;
    struct slabhash* msg_cache;
    struct rrset_cache* rrset_cache;
    struct infra_cache* infra_cache;
    struct key_cache* key_cache;
 
    /* --- services --- */
    struct outbound_entry* (*send_query)(struct query_info* qinfo,
        uint16_t flags, int dnssec, int want_dnssec, int nocaps,
        struct sockaddr_storage* addr, socklen_t addrlen,
        uint8_t* zone, size_t zonelen, int ssl_upstream,
        char* tls_auth_name, struct module_qstate* q);
 
    void (*detach_subs)(struct module_qstate* qstate);
 
    int (*attach_sub)(struct module_qstate* qstate, 
        struct query_info* qinfo, uint16_t qflags, int prime, 
        int valrec, struct module_qstate** newq);
 
    int (*add_sub)(struct module_qstate* qstate, 
        struct query_info* qinfo, uint16_t qflags, int prime, 
        int valrec, struct module_qstate** newq,
        struct mesh_state** sub);
 
    void (*kill_sub)(struct module_qstate* newq);
 
    int (*detect_cycle)(struct module_qstate* qstate, 
        struct query_info* qinfo, uint16_t flags, int prime,
        int valrec);
 
    struct regional* scratch;
    struct sldns_buffer* scratch_buffer;
    struct worker* worker;
    struct comm_base* worker_base;
    struct outside_network* outnet;
    struct mesh_area* mesh;
    struct alloc_cache* alloc;
    struct ub_randstate* rnd;
    time_t* now;
    struct timeval* now_tv;
    int need_to_validate;
    struct val_anchors* anchors;
    struct val_neg_cache* neg_cache;
    struct comm_timer* probe_timer;
    struct auth_zones* auth_zones;
    struct iter_forwards* fwds;
    struct iter_hints* hints;
    void* modinfo[MAX_MODULE];
 
    /* Shared linked list of inplace callback functions */
    struct inplace_cb* inplace_cb_lists[inplace_cb_types_total];
 
    struct edns_known_option* edns_known_options;
    /* Number of known edns options */
    size_t edns_known_options_num;
 
    /* Make every mesh state unique, do not aggregate mesh states. */
    int unique_mesh;
};
 
enum module_ext_state {
    module_state_initial = 0,
    module_wait_reply,
    module_wait_module,
    module_restart_next,
    module_wait_subquery,
    module_error,
    module_finished
};
 
enum module_ev {
    module_event_new = 0,
    module_event_pass,
    module_event_reply,
    module_event_noreply,
    module_event_capsfail,
    module_event_moddone,
    module_event_error
};
 
struct sock_list {
    struct sock_list* next;
    socklen_t len;
    struct sockaddr_storage addr;
};
 
struct respip_action_info;
 
struct module_qstate {
    struct query_info qinfo;
    uint16_t query_flags;
    int is_priming;
    int is_valrec;
 
    struct comm_reply* reply;
    struct dns_msg* return_msg;
    int return_rcode;
    struct sock_list* reply_origin;
    struct sock_list* blacklist;
    struct regional* region;
    struct config_strlist* errinf;
 
    int curmod;
    enum module_ext_state ext_state[MAX_MODULE];
    void* minfo[MAX_MODULE];
    struct module_env* env;
    struct mesh_state* mesh_info;
    time_t prefetch_leeway;
 
    struct edns_option* edns_opts_front_in;
    struct edns_option* edns_opts_back_out;
    struct edns_option* edns_opts_back_in;
    struct edns_option* edns_opts_front_out;
    int no_cache_lookup;
    int no_cache_store;
    int need_refetch;
 
    struct respip_client_info* client_info;
 
    struct respip_action_info* respip_action_info;
 
    int is_drop;
};
 
struct module_func_block {
    const char* name;
 
    int (*init)(struct module_env* env, int id);
 
    void (*deinit)(struct module_env* env, int id);
 
    void (*operate)(struct module_qstate* qstate, enum module_ev event, 
        int id, struct outbound_entry* outbound);
 
    void (*inform_super)(struct module_qstate* qstate, int id,
        struct module_qstate* super);
 
    void (*clear)(struct module_qstate* qstate, int id);
 
    size_t (*get_mem)(struct module_env* env, int id);
};
 
const char* strextstate(enum module_ext_state s);
 
const char* strmodulevent(enum module_ev e);
 
int edns_known_options_init(struct module_env* env);
 
void edns_known_options_delete(struct module_env* env);
 
int edns_register_option(uint16_t opt_code, int bypass_cache_stage,
    int no_aggregation, struct module_env* env);
 
int
inplace_cb_register(void* cb, enum inplace_cb_list_type type, void* cbarg,
    struct module_env* env, int id);
 
void
inplace_cb_delete(struct module_env* env, enum inplace_cb_list_type type,
    int id);
 
void inplace_cb_lists_delete(struct module_env* env);
 
struct edns_known_option* edns_option_is_known(uint16_t opt_code,
    struct module_env* env);
 
int edns_bypass_cache_stage(struct edns_option* list,
    struct module_env* env);
 
int unique_mesh_state(struct edns_option* list, struct module_env* env);
 
void log_edns_known_options(enum verbosity_value level,
    struct module_env* env);
 
#endif /* UTIL_MODULE_H */