mesh.h

Go to the documentation of this file.

/*
 * services/mesh.h - deal with mesh of query states and handle events for that.
 *
 * 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 SERVICES_MESH_H
#define SERVICES_MESH_H
 
#include "util/rbtree.h"
#include "util/netevent.h"
#include "util/data/msgparse.h"
#include "util/module.h"
#include "services/modstack.h"
struct sldns_buffer;
struct mesh_state;
struct mesh_reply;
struct mesh_cb;
struct query_info;
struct reply_info;
struct outbound_entry;
struct timehist;
struct respip_client_info;

#define MESH_MAX_ACTIVATION 3000

#define MESH_MAX_SUBSUB 1024

struct mesh_area {
    struct module_stack mods;
    struct module_env* env;

    rbtree_type run;
    rbtree_type all;

    size_t num_reply_addrs;
    size_t num_reply_states;
    size_t num_detached_states;
    size_t num_forever_states;

    size_t max_reply_states;
    size_t max_forever_states;

    size_t stats_jostled;
    size_t stats_dropped;
    size_t replies_sent;
    struct timeval replies_sum_wait;
    struct timehist* histogram;
    size_t ans_secure;
    size_t ans_bogus;
    size_t ans_rcode[16];
    size_t ans_nodata;

    struct sldns_buffer* qbuf_bak;

    struct mesh_state* forever_first;
    struct mesh_state* forever_last;

    struct mesh_state* jostle_first;
    struct mesh_state* jostle_last;
    struct timeval jostle_max;
};

struct mesh_state {
    rbnode_type node;
    rbnode_type run_node;
    struct module_qstate s;
    struct mesh_reply* reply_list;
    struct mesh_cb* cb_list;
    rbtree_type super_set;
    rbtree_type sub_set;
    size_t num_activated;

    struct mesh_state* prev;
    struct mesh_state* next;
    enum mesh_list_select { mesh_no_list, mesh_forever_list, 
        mesh_jostle_list } list_select;
    struct mesh_state* unique;

    uint8_t replies_sent;
};

struct mesh_state_ref {
    rbnode_type node;
    struct mesh_state* s;
};

struct mesh_reply {
    struct mesh_reply* next;
    struct comm_reply query_reply;
    struct edns_data edns;
    struct timeval start_time;
    uint16_t qid;
    uint16_t qflags;
    uint8_t* qname;
    struct local_rrset* local_alias;
};

typedef void (*mesh_cb_func_type)(void*, int, struct sldns_buffer*, enum sec_status, 
    char*);

struct mesh_cb {
    struct mesh_cb* next;
    struct edns_data edns;
    uint16_t qid;
    uint16_t qflags;
    struct sldns_buffer* buf;

    mesh_cb_func_type cb;
    void* cb_arg;
};
 
/* ------------------- Functions for worker -------------------- */

struct mesh_area* mesh_create(struct module_stack* stack, 
    struct module_env* env);

void mesh_delete(struct mesh_area* mesh);

void mesh_new_client(struct mesh_area* mesh, struct query_info* qinfo,
    struct respip_client_info* cinfo, uint16_t qflags,
    struct edns_data* edns, struct comm_reply* rep, uint16_t qid);

int mesh_new_callback(struct mesh_area* mesh, struct query_info* qinfo,
    uint16_t qflags, struct edns_data* edns, struct sldns_buffer* buf, 
    uint16_t qid, mesh_cb_func_type cb, void* cb_arg);

void mesh_new_prefetch(struct mesh_area* mesh, struct query_info* qinfo,
    uint16_t qflags, time_t leeway);

void mesh_report_reply(struct mesh_area* mesh, struct outbound_entry* e,
    struct comm_reply* reply, int what);
 
/* ------------------- Functions for module environment --------------- */

void mesh_detach_subs(struct module_qstate* qstate);

int mesh_attach_sub(struct module_qstate* qstate, struct query_info* qinfo,
    uint16_t qflags, int prime, int valrec, struct module_qstate** newq);

int mesh_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 mesh_query_done(struct mesh_state* mstate);

void mesh_walk_supers(struct mesh_area* mesh, struct mesh_state* mstate);

void mesh_state_delete(struct module_qstate* qstate);
 
/* ------------------- Functions for mesh -------------------- */

struct mesh_state* mesh_state_create(struct module_env* env,
    struct query_info* qinfo, struct respip_client_info* cinfo,
    uint16_t qflags, int prime, int valrec);

int mesh_state_is_unique(struct mesh_state* mstate);

void mesh_state_make_unique(struct mesh_state* mstate);

void mesh_state_cleanup(struct mesh_state* mstate);

void mesh_delete_all(struct mesh_area* mesh);

struct mesh_state* mesh_area_find(struct mesh_area* mesh,
    struct respip_client_info* cinfo, struct query_info* qinfo,
    uint16_t qflags, int prime, int valrec);

int mesh_state_attachment(struct mesh_state* super, struct mesh_state* sub);

int mesh_state_add_reply(struct mesh_state* s, struct edns_data* edns,
    struct comm_reply* rep, uint16_t qid, uint16_t qflags,
    const struct query_info* qinfo);

int mesh_state_add_cb(struct mesh_state* s, struct edns_data* edns,
        struct sldns_buffer* buf, mesh_cb_func_type cb, void* cb_arg,
    uint16_t qid, uint16_t qflags);

void mesh_run(struct mesh_area* mesh, struct mesh_state* mstate, 
    enum module_ev ev, struct outbound_entry* e);

void mesh_stats(struct mesh_area* mesh, const char* str);

void mesh_stats_clear(struct mesh_area* mesh);

void mesh_log_list(struct mesh_area* mesh);

size_t mesh_get_mem(struct mesh_area* mesh);

int mesh_detect_cycle(struct module_qstate* qstate, struct query_info* qinfo,
    uint16_t flags, int prime, int valrec);

int mesh_state_compare(const void* ap, const void* bp);

int mesh_state_ref_compare(const void* ap, const void* bp);

int mesh_make_new_space(struct mesh_area* mesh, struct sldns_buffer* qbuf);

void mesh_list_insert(struct mesh_state* m, struct mesh_state** fp,
    struct mesh_state** lp);

void mesh_list_remove(struct mesh_state* m, struct mesh_state** fp,
    struct mesh_state** lp);
 
#endif /* SERVICES_MESH_H */