Logo Search packages:      
Sourcecode: unbound version File versions  Download package

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 REGENTS 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 assist in dealing with a mesh of
 * query states. This mesh is supposed to be thread-specific.
 * It consists of query states (per qname, qtype, qclass) and connections
 * between query states and the super and subquery states, and replies to
 * send back to clients.
 */

#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 mesh_state;
struct mesh_reply;
struct mesh_cb;
struct query_info;
struct reply_info;
struct outbound_entry;
struct timehist;

/**
 * Maximum number of mesh state activations. Any more is likely an
 * infinite loop in the module. It is then terminated.
 */
00066 #define MESH_MAX_ACTIVATION 1000

/** 
 * Mesh of query states
 */
00071 struct mesh_area {
      /** active module stack */
00073       struct module_stack mods;
      /** environment for new states */
00075       struct module_env* env;

      /** set of runnable queries (mesh_state.run_node) */
00078       rbtree_t run;
      /** rbtree of all current queries (mesh_state.node)*/
00080       rbtree_t all;

      /** count of the total number of mesh_reply entries */
00083       size_t num_reply_addrs;
      /** count of the number of mesh_states that have mesh_replies 
       * Because a state can send results to multiple reply addresses,
       * this number must be equal or lower than num_reply_addrs. */
00087       size_t num_reply_states;
      /** number of mesh_states that have no mesh_replies, and also
       * an empty set of super-states, thus are 'toplevel' or detached
       * internal opportunistic queries */
00091       size_t num_detached_states;

      /** number of replies sent */
00094       size_t replies_sent;
      /** sum of waiting times for the replies */
00096       struct timeval replies_sum_wait;
      /** histogram of time values */
00098       struct timehist* histogram;
};

/**
 * A mesh query state
 * Unique per qname, qtype, qclass (from the qstate).
 * And RD / CD flag; in case a client turns it off.
 * And priming queries are different from ordinary queries (because of hints).
 *
 * The entire structure is allocated in a region, this region is the qstate
 * region. All parts (rbtree nodes etc) are also allocated in the region.
 */
00110 struct mesh_state {
      /** node in mesh_area all tree, key is this struct. Must be first. */
00112       rbnode_t node;
      /** node in mesh_area runnable tree, key is this struct */
00114       rbnode_t run_node;
      /** the query state. Note that the qinfo and query_flags 
       * may not change. */
00117       struct module_qstate s;
      /** the list of replies to clients for the results */
00119       struct mesh_reply* reply_list;
      /** the list of callbacks for the results */
00121       struct mesh_cb* cb_list;
      /** set of superstates (that want this state's result) 
       * contains struct mesh_state_ref* */
00124       rbtree_t super_set;
      /** set of substates (that this state needs to continue)
       * contains struct mesh_state_ref* */
00127       rbtree_t sub_set;
      /** number of activations for the mesh state */
00129       size_t num_activated;
};

/**
 * Rbtree reference to a mesh_state.
 * Used in super_set and sub_set. 
 */
00136 struct mesh_state_ref {
      /** node in rbtree for set, key is this structure */
00138       rbnode_t node;
      /** the mesh state */
00140       struct mesh_state* s;
};

/**
 * Reply to a client
 */
00146 struct mesh_reply {
      /** next in reply list */
00148       struct mesh_reply* next;
      /** the query reply destination, packet buffer and where to send. */
00150       struct comm_reply query_reply;
      /** edns data from query */
00152       struct edns_data edns;
      /** the time when request was entered */
00154       struct timeval start_time;
      /** id of query, in network byteorder. */
00156       uint16_t qid;
      /** flags of query, for reply flags */
00158       uint16_t qflags;
      /** qname from this query. len same as mesh qinfo. */
00160       uint8_t* qname;
};

/** 
 * Mesh result callback func.
 * called as func(cb_arg, rcode, buffer_with_reply, security);
 * */
00167 typedef void (*mesh_cb_func_t)(void*, int, ldns_buffer*, enum sec_status);

/**
 * Callback to result routine
 */
00172 struct mesh_cb {
      /** next in list */
00174       struct mesh_cb* next;
      /** edns data from query */
00176       struct edns_data edns;
      /** id of query, in network byteorder. */
00178       uint16_t qid;
      /** flags of query, for reply flags */
00180       uint16_t qflags;
      /** buffer for reply */
00182       ldns_buffer* buf;

      /** callback routine for results. if rcode != 0 buf has message.
       * called as cb(cb_arg, rcode, buf);
       */
00187       mesh_cb_func_t cb;
      /** user arg for callback */
00189       void* cb_arg;
};

/* ------------------- Functions for worker -------------------- */

/**
 * Allocate mesh, to empty.
 * @param stack: module stack to activate, copied (as readonly reference).
 * @param env: environment for new queries.
 * @return mesh: the new mesh or NULL on error.
 */
struct mesh_area* mesh_create(struct module_stack* stack, 
      struct module_env* env);

/**
 * Delete mesh, and all query states and replies in it.
 * @param mesh: the mesh to delete.
 */
void mesh_delete(struct mesh_area* mesh);

/**
 * New query incoming from clients. Create new query state if needed, and
 * add mesh_reply to it. Returns error to client on malloc failures.
 * Will run the mesh area queries to process if a new query state is created.
 *
 * @param mesh: the mesh.
 * @param qinfo: query from client.
 * @param qflags: flags from client query.
 * @param edns: edns data from client query.
 * @param rep: where to reply to.
 * @param qid: query id to reply with.
 */
void mesh_new_client(struct mesh_area* mesh, struct query_info* qinfo,
      uint16_t qflags, struct edns_data* edns, struct comm_reply* rep, 
      uint16_t qid);

/**
 * New query with callback. Create new query state if needed, and
 * add mesh_cb to it. 
 * Will run the mesh area queries to process if a new query state is created.
 *
 * @param mesh: the mesh.
 * @param qinfo: query from client.
 * @param qflags: flags from client query.
 * @param edns: edns data from client query.
 * @param buf: buffer for reply contents.
 * @param qid: query id to reply with.
 * @param cb: callback function.
 * @param cb_arg: callback user arg.
 * @return 0 on error.
 */
int mesh_new_callback(struct mesh_area* mesh, struct query_info* qinfo,
      uint16_t qflags, struct edns_data* edns, ldns_buffer* buf, 
      uint16_t qid, mesh_cb_func_t cb, void* cb_arg);

/**
 * Handle new event from the wire. A serviced query has returned.
 * The query state will be made runnable, and the mesh_area will process
 * query states until processing is complete.
 *
 * @param mesh: the query mesh.
 * @param e: outbound entry, with query state to run and reply pointer.
 * @param is_ok: if true, reply is OK, otherwise a timeout happened.
 * @param reply: the comm point reply info.
 */
void mesh_report_reply(struct mesh_area* mesh, struct outbound_entry* e,
      int is_ok, struct comm_reply* reply);

/* ------------------- Functions for module environment --------------- */

/**
 * Detach-subqueries.
 * Remove all sub-query references from this query state.
 * Keeps super-references of those sub-queries correct.
 * Updates stat items in mesh_area structure.
 * @param qstate: used to find mesh state.
 */
void mesh_detach_subs(struct module_qstate* qstate);

/**
 * Attach subquery.
 * Creates it if it does not exist already.
 * Keeps sub and super references correct.
 * Updates stat items in mesh_area structure.
 * Pass if it is priming query or not.
 * return:
 *    o if error (malloc) happened.
 *    o need to initialise the new state (module init; it is a new state).
 *      so that the next run of the query with this module is successful.
 *    o no init needed, attachment successful.
 *
 * @param qstate: the state to find mesh state, and that wants to receive
 *    the results from the new subquery.
 * @param qinfo: what to query for (copied).
 * @param qflags: what flags to use (RD / CD flag or not).
 * @param prime: if it is a (stub) priming query.
 * @param newq: If the new subquery needs initialisation, it is returned,
 *    otherwise NULL is returned.
 * @return: false on error, true if success (and init may be needed).
 */
int mesh_attach_sub(struct module_qstate* qstate, struct query_info* qinfo,
      uint16_t qflags, int prime, struct module_qstate** newq);

/**
 * Query state is done, send messages to reply entries.
 * Encode messages using reply entry values and the querystate (with original
 * qinfo), using given reply_info.
 * Pass errcode != 0 if an error reply is needed.
 * If no reply entries, nothing is done.
 * Must be called before a module can module_finished or return module_error.
 * The module must handle the super query states itself as well.
 *
 * @param mstate: mesh state that is done. return_rcode and return_msg
 *    are used for replies.
 *    return_rcode: if not 0 (NOERROR) an error is sent back (and 
 *          return_msg is ignored).
 *    return_msg: reply to encode and send back to clients.
 */
void mesh_query_done(struct mesh_state* mstate);

/**
 * Call inform_super for the super query states that are interested in the 
 * results from this query state. These can then be changed for error 
 * or results.
 * Called when a module is module_finished or returns module_error.
 * The super query states become runnable with event module_event_pass.
 *
 * @param mesh: mesh area to add newly runnable modules to.
 * @param mstate: the state that has results, used to find mesh state.
 */
void mesh_walk_supers(struct mesh_area* mesh, struct mesh_state* mstate);

/**
 * Delete mesh state, cleanup and also rbtrees and so on.
 * Will detach from all super/subnodes.
 * @param qstate: to remove.
 */
void mesh_state_delete(struct module_qstate* qstate);

/* ------------------- Functions for mesh -------------------- */

/**
 * Create and initialize a new mesh state and its query state
 * Does not put the mesh state into rbtrees and so on.
 * @param env: module environment to set.
 * @param qinfo: query info that the mesh is for.
 * @param qflags: flags for query (RD / CD flag).
 * @param prime: if true, it is a priming query, set is_priming on mesh state.
 * @return: new mesh state or NULL on allocation error.
 */
struct mesh_state* mesh_state_create(struct module_env* env, 
      struct query_info* qinfo, uint16_t qflags, int prime);

/**
 * Cleanup a mesh state and its query state. Does not do rbtree or 
 * reference cleanup.
 * @param mstate: mesh state to cleanup. Its pointer may no longer be used
 *    afterwards. Cleanup rbtrees before calling this function.
 */
void mesh_state_cleanup(struct mesh_state* mstate);

/**
 * Find a mesh state in the mesh area. Pass relevant flags.
 *
 * @param mesh: the mesh area to look in.
 * @param qinfo: what query
 * @param qflags: if RD / CD bit is set or not.
 * @param prime: if it is a priming query.
 * @return: mesh state or NULL if not found.
 */
struct mesh_state* mesh_area_find(struct mesh_area* mesh, 
      struct query_info* qinfo, uint16_t qflags, int prime);

/**
 * Setup attachment super/sub relation between super and sub mesh state.
 * The relation must not be present when calling the function.
 * Does not update stat items in mesh_area.
 * @param super: super state.
 * @param sub: sub state.
 * @return: 0 on alloc error.
 */
int mesh_state_attachment(struct mesh_state* super, struct mesh_state* sub);

/**
 * Create new reply structure and attach it to a mesh state.
 * Does not update stat items in mesh area.
 * @param s: the mesh state.
 * @param edns: edns data for reply (bufsize).
 * @param rep: comm point reply info.
 * @param qid: ID of reply.
 * @param qflags: original query flags.
 * @param qname: original query name.
 * @return: 0 on alloc error.
 */
int mesh_state_add_reply(struct mesh_state* s, struct edns_data* edns, 
      struct comm_reply* rep, uint16_t qid, uint16_t qflags, uint8_t* qname);

/**
 * Create new callback structure and attach it to a mesh state.
 * Does not update stat items in mesh area.
 * @param s: the mesh state.
 * @param edns: edns data for reply (bufsize).
 * @param buf: buffer for reply
 * @param cb: callback to call with results.
 * @param cb_arg: callback user arg.
 * @param qid: ID of reply.
 * @param qflags: original query flags.
 * @return: 0 on alloc error.
 */
int mesh_state_add_cb(struct mesh_state* s, struct edns_data* edns,
        ldns_buffer* buf, mesh_cb_func_t cb, void* cb_arg, uint16_t qid, 
      uint16_t qflags);

/**
 * Run the mesh. Run all runnable mesh states. Which can create new
 * runnable mesh states. Until completion. Automatically called by
 * mesh_report_reply and mesh_new_client as needed.
 * @param mesh: mesh area.
 * @param mstate: first mesh state to run.
 * @param ev: event the mstate. Others get event_pass.
 * @param e: if a reply, its outbound entry.
 */
void mesh_run(struct mesh_area* mesh, struct mesh_state* mstate, 
      enum module_ev ev, struct outbound_entry* e);

/**
 * Print some stats about the mesh to the log.
 * @param mesh: the mesh to print it for.
 * @param str: descriptive string to go with it.
 */
void mesh_stats(struct mesh_area* mesh, const char* str);

/**
 * Clear the stats that the mesh keeps (number of queries serviced)
 * @param mesh: the mesh
 */
void mesh_stats_clear(struct mesh_area* mesh);

/**
 * Print all the states in the mesh to the log.
 * @param mesh: the mesh to print all states of.
 */
void mesh_log_list(struct mesh_area* mesh);

/**
 * Calculate memory size in use by mesh and all queries inside it.
 * @param mesh: the mesh to examine.
 * @return size in bytes.
 */
size_t mesh_get_mem(struct mesh_area* mesh);

/**
 * Find cycle; see if the given mesh is in the targets sub, or sub-sub, ...
 * trees.
 * @param qstate: given mesh querystate.
 * @param qinfo: query info for dependency.
 * @param flags: query flags of dependency.
 * @param prime: if dependency is a priming query or not.
 * @return true if the name,type,class exists and the given qstate mesh exists
 *    as a dependency of that name. Thus if qstate becomes dependent on
 *    name,type,class then a cycle is created.
 */
int mesh_detect_cycle(struct module_qstate* qstate, struct query_info* qinfo,
      uint16_t flags, int prime);

/** compare two mesh_states */
int mesh_state_compare(const void* ap, const void* bp);

/** compare two mesh references */
int mesh_state_ref_compare(const void* ap, const void* bp);

#endif /* SERVICES_MESH_H */

Generated by  Doxygen 1.6.0   Back to index