This file contains functions to assist in dealing with a mesh of query states. More...
#include "config.h"#include "services/mesh.h"#include "services/outbound_list.h"#include "services/cache/dns.h"#include "services/cache/rrset.h"#include "util/log.h"#include "util/net_help.h"#include "util/module.h"#include "util/regional.h"#include "util/data/msgencode.h"#include "util/timehist.h"#include "util/fptr_wlist.h"#include "util/alloc.h"#include "util/config_file.h"#include "util/edns.h"#include "sldns/sbuffer.h"#include "sldns/wire2str.h"#include "services/localzone.h"#include "util/data/dname.h"#include "respip/respip.h"#include "services/listen_dnsport.h"#include "util/timeval_func.h"Functions | |
| static int | client_info_compare (const struct respip_client_info *ci_a, const struct respip_client_info *ci_b) |
| Compare two response-ip client info entries for the purpose of mesh state compare. More... | |
| int | mesh_state_compare (const void *ap, const void *bp) |
| compare two mesh_states | |
| int | mesh_state_ref_compare (const void *ap, const void *bp) |
| compare two mesh references | |
| struct mesh_area * | mesh_create (struct module_stack *stack, struct module_env *env) |
| Allocate mesh, to empty. More... | |
| static void | mesh_delete_helper (rbnode_type *n) |
| help mesh delete delete mesh states | |
| void | mesh_delete (struct mesh_area *mesh) |
| Delete mesh, and all query states and replies in it. More... | |
| void | mesh_delete_all (struct mesh_area *mesh) |
| Delete all mesh states from the mesh. More... | |
| int | mesh_make_new_space (struct mesh_area *mesh, sldns_buffer *qbuf) |
| Make space for another recursion state for a reply in the mesh. More... | |
| struct dns_msg * | mesh_serve_expired_lookup (struct module_qstate *qstate, struct query_info *lookup_qinfo) |
| Try to get a (expired) cached answer. More... | |
| static int | mesh_serve_expired_init (struct mesh_state *mstate, int timeout) |
| Init the serve expired data structure. | |
| 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 rpz_passthru) |
| New query incoming from clients. More... | |
| int | mesh_new_callback (struct mesh_area *mesh, struct query_info *qinfo, uint16_t qflags, struct edns_data *edns, sldns_buffer *buf, uint16_t qid, mesh_cb_func_type cb, void *cb_arg, int rpz_passthru) |
| New query with callback. More... | |
| static void | mesh_schedule_prefetch (struct mesh_area *mesh, struct query_info *qinfo, uint16_t qflags, time_t leeway, int run, int rpz_passthru) |
| void | mesh_new_prefetch (struct mesh_area *mesh, struct query_info *qinfo, uint16_t qflags, time_t leeway, int rpz_passthru, struct sockaddr_storage *addr, struct edns_option *opt_list) |
| New prefetch message. More... | |
| void | mesh_report_reply (struct mesh_area *mesh, struct outbound_entry *e, struct comm_reply *reply, int what) |
| Handle new event from the wire. More... | |
| 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) |
| Create and initialize a new mesh state and its query state Does not put the mesh state into rbtrees and so on. More... | |
| void | mesh_state_make_unique (struct mesh_state *mstate) |
| Make a mesh state unique. More... | |
| void | mesh_state_cleanup (struct mesh_state *mstate) |
| Cleanup a mesh state and its query state. More... | |
| void | mesh_state_delete (struct module_qstate *qstate) |
| Delete mesh state, cleanup and also rbtrees and so on. More... | |
| static int | find_in_subsub (struct mesh_state *m, struct mesh_state *tofind, size_t *c) |
| helper recursive rbtree find routine | |
| static int | mesh_detect_cycle_found (struct module_qstate *qstate, struct mesh_state *dep_m) |
| find cycle for already looked up mesh_state | |
| void | mesh_detach_subs (struct module_qstate *qstate) |
| Detach-subqueries. More... | |
| 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) |
| Add detached query. More... | |
| int | mesh_attach_sub (struct module_qstate *qstate, struct query_info *qinfo, uint16_t qflags, int prime, int valrec, struct module_qstate **newq) |
| Attach subquery. More... | |
| int | mesh_state_attachment (struct mesh_state *super, struct mesh_state *sub) |
| Setup attachment super/sub relation between super and sub mesh state. More... | |
| static void | mesh_do_callback (struct mesh_state *m, int rcode, struct reply_info *rep, struct mesh_cb *r, struct timeval *start_time) |
| callback results to mesh cb entry More... | |
| static int | mesh_is_rpz_respip_tcponly_action (struct mesh_state const *m) |
| static int | mesh_is_udp (struct mesh_reply const *r) |
| static void | mesh_find_and_attach_ede_and_reason (struct mesh_state *m, struct reply_info *rep, struct mesh_reply *r) |
| static void | mesh_send_reply (struct mesh_state *m, int rcode, struct reply_info *rep, struct mesh_reply *r, struct sldns_buffer *r_buffer, struct mesh_reply *prev, struct sldns_buffer *prev_buffer) |
| Send reply to mesh reply entry. More... | |
| void | mesh_query_done (struct mesh_state *mstate) |
| Query state is done, send messages to reply entries. More... | |
| void | mesh_walk_supers (struct mesh_area *mesh, struct mesh_state *mstate) |
| Call inform_super for the super query states that are interested in the results from this query state. More... | |
| 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) |
| Find a mesh state in the mesh area. More... | |
| int | mesh_state_add_cb (struct mesh_state *s, struct edns_data *edns, sldns_buffer *buf, mesh_cb_func_type cb, void *cb_arg, uint16_t qid, uint16_t qflags) |
| Create new callback structure and attach it to a mesh state. More... | |
| 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) |
| Create new reply structure and attach it to a mesh state. More... | |
| static void | mesh_copy_qinfo (struct mesh_state *mstate, struct query_info **qinfop, uint16_t *qflags) |
| static int | mesh_continue (struct mesh_area *mesh, struct mesh_state *mstate, enum module_ext_state s, enum module_ev *ev) |
| Continue processing the mesh state at another module. More... | |
| void | mesh_run (struct mesh_area *mesh, struct mesh_state *mstate, enum module_ev ev, struct outbound_entry *e) |
| Run the mesh. More... | |
| void | mesh_log_list (struct mesh_area *mesh) |
| Print all the states in the mesh to the log. More... | |
| void | mesh_stats (struct mesh_area *mesh, const char *str) |
| Print some stats about the mesh to the log. More... | |
| void | mesh_stats_clear (struct mesh_area *mesh) |
| Clear the stats that the mesh keeps (number of queries serviced) More... | |
| size_t | mesh_get_mem (struct mesh_area *mesh) |
| Calculate memory size in use by mesh and all queries inside it. More... | |
| int | mesh_detect_cycle (struct module_qstate *qstate, struct query_info *qinfo, uint16_t flags, int prime, int valrec) |
| Find cycle; see if the given mesh is in the targets sub, or sub-sub, ... More... | |
| void | mesh_list_insert (struct mesh_state *m, struct mesh_state **fp, struct mesh_state **lp) |
| Insert mesh state into a double linked list. More... | |
| void | mesh_list_remove (struct mesh_state *m, struct mesh_state **fp, struct mesh_state **lp) |
| Remove mesh state from a double linked list. More... | |
| void | mesh_state_remove_reply (struct mesh_area *mesh, struct mesh_state *m, struct comm_point *cp) |
| Remove mesh reply entry from the reply entry list. More... | |
| static int | apply_respip_action (struct module_qstate *qstate, const struct query_info *qinfo, struct respip_client_info *cinfo, struct respip_action_info *actinfo, struct reply_info *rep, struct ub_packed_rrset_key **alias_rrset, struct reply_info **encode_repp, struct auth_zones *az) |
| void | mesh_serve_expired_callback (void *arg) |
| Callback for when the serve expired client timer has run out. More... | |
| int | mesh_jostle_exceeded (struct mesh_area *mesh) |
| See if the mesh has space for more queries. More... | |
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.
|
static |
Compare two response-ip client info entries for the purpose of mesh state compare.
It returns 0 if ci_a and ci_b are considered equal; otherwise 1 or -1 (they mean 'ci_a is larger/smaller than ci_b', respectively, but in practice it should be only used to mean they are different). We cannot share the mesh state for two queries if different response-ip actions can apply in the end, even if those queries are otherwise identical. For this purpose we compare tag lists and tag action lists; they should be identical to share the same state. For tag data, we don't look into the data content, as it can be expensive; unless tag data are not defined for both or they point to the exact same data in memory (i.e., they come from the same ACL entry), we consider these data different. Likewise, if the client info is associated with views, we don't look into the views. They are considered different unless they are exactly the same even if the views only differ in the names.
Referenced by mesh_state_compare().
| struct mesh_area* mesh_create | ( | struct module_stack * | stack, |
| struct module_env * | env | ||
| ) |
Allocate mesh, to empty.
| stack | module stack to activate, copied (as readonly reference). |
| env | environment for new queries. |
References mesh_area::all, mesh_area::ans_cachedb, mesh_area::ans_expired, module_env::cfg, mesh_area::env, mesh_area::histogram, mesh_area::jostle_max, config_file::jostle_time, log_err(), mesh_area::max_forever_states, mesh_area::max_reply_states, mesh_state_compare(), mesh_area::mods, config_file::msg_buffer_size, mesh_area::num_detached_states, mesh_area::num_forever_states, config_file::num_queries_per_thread, mesh_area::num_reply_addrs, mesh_area::num_reply_states, mesh_area::qbuf_bak, rbtree_init(), mesh_area::run, sldns_buffer_new(), mesh_area::stats_dropped, mesh_area::stats_jostled, and timehist_setup().
| void mesh_delete | ( | struct mesh_area * | mesh | ) |
Delete mesh, and all query states and replies in it.
| mesh | the mesh to delete. |
References mesh_area::all, rbtree_type::count, mesh_area::histogram, mesh_delete_helper(), mesh_area::qbuf_bak, rbtree_type::root, sldns_buffer_free(), and timehist_delete().
Referenced by libworker_delete_env(), and worker_delete().
| void mesh_delete_all | ( | struct mesh_area * | mesh | ) |
Delete all mesh states from the mesh.
| mesh | the mesh area to clear |
References mesh_area::all, rbtree_type::count, mesh_area::forever_first, mesh_area::forever_last, mesh_area::jostle_first, mesh_area::jostle_last, mesh_delete_helper(), mesh_state_compare(), mesh_area::num_detached_states, mesh_area::num_forever_states, mesh_area::num_reply_addrs, mesh_area::num_reply_states, rbtree_init(), rbtree_type::root, mesh_area::run, and mesh_area::stats_dropped.
Referenced by do_flush_requestlist(), and do_forward().
| int mesh_make_new_space | ( | struct mesh_area * | mesh, |
| struct sldns_buffer * | qbuf | ||
| ) |
Make space for another recursion state for a reply in the mesh.
| mesh | mesh area |
| qbuf | query buffer to save if recursion is invoked to make space. This buffer is necessary, because the following sequence in calls can result in an overwrite of the incoming query: delete_other_mesh_query - iter_clean - serviced_delete - waiting udp query is sent - on error callback - callback sends SERVFAIL reply over the same network channel, and shared UDP buffer is overwritten. You can pass NULL if there is no buffer that must be backed up. |
References rbtree_type::count, mesh_area::env, mesh_area::jostle_first, mesh_area::jostle_max, log_nametypeclass(), mesh_area::max_reply_states, module_env::now_tv, mesh_area::num_reply_states, mesh_area::qbuf_bak, query_info::qclass, module_qstate::qinfo, query_info::qname, query_info::qtype, mesh_state::reply_list, module_qstate::return_msg, module_qstate::return_rcode, mesh_state::s, sldns_buffer_copy(), mesh_reply::start_time, mesh_state::super_set, timeval_smaller(), timeval_subtract(), VERB_ALGO, and verbose().
Referenced by mesh_new_client().
| struct dns_msg* mesh_serve_expired_lookup | ( | struct module_qstate * | qstate, |
| struct query_info * | lookup_qinfo | ||
| ) |
Try to get a (expired) cached answer.
This needs to behave like the worker's answer_from_cache() in order to have the same behavior as when replying from cache.
| qstate | the module qstate. |
| lookup_qinfo | the query info to look for in the cache. |
References BIT_CD, module_env::cfg, lruhash_entry::data, module_qstate::env, config_file::ignore_cd, msgreply_entry::key, lruhash_entry::key, lruhash_entry::lock, module_env::msg_cache, module_env::need_to_validate, module_env::now, module_qstate::query_flags, query_info_hash(), module_qstate::region, dns_msg::rep, reply_all_rrsets_secure(), module_env::scratch, sec_status_bogus, sec_status_secure, sec_status_secure_sentinel_fail, sec_status_unchecked, reply_info::security, config_file::serve_expired, slabhash_lookup(), tomsg(), VERB_ALGO, and verbose().
Referenced by fptr_whitelist_serve_expired_lookup(), and mesh_serve_expired_init().
| 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 | rpz_passthru | ||
| ) |
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.
| mesh | the mesh. |
| qinfo | query from client. |
| cinfo | additional information associated with the query client. 'cinfo' itself is ephemeral but data pointed to by its members can be assumed to be valid and unchanged until the query processing is completed. |
| qflags | flags from client query. |
| edns | edns data from client query. |
| rep | where to reply to. |
| qid | query id to reply with. |
| rpz_passthru | if true, the rpz passthru was previously found and further rpz processing is stopped. |
References BIT_CD, BIT_RD, comm_point::buffer, comm_reply::c, module_env::cfg, comm_point_drop_reply(), mesh_area::env, inplace_cb_reply_servfail_call(), log_err(), mesh_area::max_reply_states, mesh_area_find(), mesh_make_new_space(), mesh_state_create(), mesh_area::num_reply_addrs, edns_data::opt_list_in, mesh_state::s, config_file::serve_expired, config_file::serve_expired_client_timeout, tcp_req_info::spool_buffer, mesh_area::stats_dropped, comm_point::tcp_req_info, mesh_state::unique, unique_mesh_state(), VERB_ALGO, and verbose().
| 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, | ||
| int | rpz_passthru | ||
| ) |
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.
| mesh | the mesh. |
| qinfo | query from client. |
| qflags | flags from client query. |
| edns | edns data from client query. |
| buf | buffer for reply contents. |
| qid | query id to reply with. |
| cb | callback function. |
| cb_arg | callback user arg. |
| rpz_passthru | if true, the rpz passthru was previously found and further rpz processing is stopped. |
References mesh_area::all, BIT_CD, BIT_RD, mesh_state::cb_list, module_env::cfg, rbtree_type::count, edns_opt_copy_region(), module_qstate::edns_opts_front_in, mesh_area::env, log_assert, mesh_area_find(), mesh_run(), mesh_serve_expired_init(), mesh_state_add_cb(), mesh_state_create(), mesh_state_delete(), mesh_state_make_unique(), module_event_new, mesh_state::node, mesh_area::num_detached_states, mesh_area::num_reply_addrs, mesh_area::num_reply_states, edns_data::opt_list_in, rbtree_insert(), module_qstate::region, mesh_state::reply_list, module_qstate::rpz_passthru, mesh_state::s, config_file::serve_expired, config_file::serve_expired_client_timeout, mesh_state::super_set, mesh_state::unique, and unique_mesh_state().
Referenced by handle_newq(), xfr_probe_lookup_host(), and xfr_transfer_lookup_host().
| void mesh_new_prefetch | ( | struct mesh_area * | mesh, |
| struct query_info * | qinfo, | ||
| uint16_t | qflags, | ||
| time_t | leeway, | ||
| int | rpz_passthru, | ||
| struct sockaddr_storage * | addr, | ||
| struct edns_option * | opt_list | ||
| ) |
New prefetch message.
Create new query state if needed. Will run the mesh area queries to process if a new query state is created.
| mesh | the mesh. |
| qinfo | query from client. |
| qflags | flags from client query. |
| leeway | TTL leeway what to expire earlier for this update. |
| rpz_passthru | if true, the rpz passthru was previously found and further rpz processing is stopped. |
| addr | sockaddr_storage for the client; to be used with subnet. |
| opt_list | edns opt_list from the client; to be used when subnet is enabled. |
Referenced by reply_and_prefetch().
| void mesh_report_reply | ( | struct mesh_area * | mesh, |
| struct outbound_entry * | e, | ||
| struct comm_reply * | reply, | ||
| int | what | ||
| ) |
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.
| mesh | the query mesh. |
| e | outbound entry, with query state to run and reply pointer. |
| reply | the comm point reply info. |
| what | NETEVENT_* error code (if not 0, what is wrong, TIMEOUT). |
References module_qstate::mesh_info, mesh_run(), module_event_capsfail, module_event_noreply, module_event_reply, NETEVENT_CAPSFAIL, NETEVENT_NOERROR, outbound_entry::qstate, and module_qstate::reply.
Referenced by libworker_handle_service_reply(), and worker_handle_service_reply().
| 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 | ||
| ) |
Create and initialize a new mesh state and its query state Does not put the mesh state into rbtrees and so on.
| env | module environment to set. |
| qinfo | query info that the mesh is for. |
| cinfo | control info for the query client (can be NULL). |
| qflags | flags for query (RD / CD flag). |
| prime | if true, it is a priming query, set is_priming on mesh state. |
| valrec | if true, it is a validation recursion query, and sets is_valrec on the mesh state. |
References module_env::alloc, alloc_reg_obtain(), alloc_reg_release(), BIT_CD, BIT_RD, module_qstate::client_info, module_qstate::curmod, module_qstate::is_priming, module_qstate::is_valrec, rbnode_type::key, query_info::local_alias, mesh_state_ref_compare(), mesh_state::node, mesh_state::num_activated, query_info::qclass, module_qstate::qinfo, query_info::qname, query_info::qname_len, query_info::qtype, module_qstate::query_flags, rbtree_init(), RBTREE_NULL, module_qstate::region, regional_alloc(), regional_alloc_init(), mesh_state::replies_sent, module_qstate::reply, mesh_state::reply_list, module_qstate::return_msg, module_qstate::return_rcode, mesh_state::run_node, mesh_state::s, mesh_state::sub_set, mesh_state::super_set, and mesh_state::unique.
Referenced by mesh_add_sub(), mesh_new_callback(), and mesh_new_client().
| void mesh_state_make_unique | ( | struct mesh_state * | mstate | ) |
Make a mesh state unique.
A unique mesh state uses it's unique member to point to itself.
| mstate | mesh state to check. |
References mesh_state::unique.
Referenced by mesh_new_callback().
| void mesh_state_cleanup | ( | struct mesh_state * | mstate | ) |
Cleanup a mesh state and its query state.
Does not do rbtree or reference cleanup.
| mstate | mesh state to cleanup. Its pointer may no longer be used afterwards. Cleanup rbtrees before calling this function. |
References mesh_cb::cb, mesh_state::cb_list, comm_point_drop_reply(), comm_timer_delete(), module_qstate::env, fptr_ok, fptr_whitelist_mesh_cb(), log_assert, module_env::mesh, mesh_reply::next, mesh_area::num_reply_addrs, mesh_reply::query_reply, mesh_state::replies_sent, mesh_state::reply_list, mesh_state::s, and module_qstate::serve_expired_data.
Referenced by mesh_state_delete().
| void mesh_state_delete | ( | struct module_qstate * | qstate | ) |
Delete mesh state, cleanup and also rbtrees and so on.
Will detach from all super/subnodes.
| qstate | to remove. |
References mesh_area::all, mesh_state::cb_list, rbtree_type::count, module_qstate::env, mesh_area::forever_first, mesh_area::forever_last, mesh_area::jostle_first, mesh_area::jostle_last, rbnode_type::key, log_assert, module_env::mesh, mesh_detach_subs(), module_qstate::mesh_info, mesh_list_remove(), mesh_state_cleanup(), mesh_state_ref::node, mesh_area::num_detached_states, mesh_area::num_forever_states, mesh_area::num_reply_states, rbtree_delete(), RBTREE_FOR, mesh_state::reply_list, mesh_area::run, mesh_state::s, mesh_state_ref::s, mesh_state::sub_set, and mesh_state::super_set.
Referenced by fptr_whitelist_modenv_kill_sub(), mesh_delete_helper(), and mesh_new_callback().
| void mesh_detach_subs | ( | struct module_qstate * | qstate | ) |
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.
| qstate | used to find mesh state. |
References mesh_area::all, mesh_state::cb_list, rbtree_type::count, module_qstate::env, log_assert, lookup(), module_env::mesh, module_qstate::mesh_info, mesh_state_ref_compare(), mesh_area::num_detached_states, mesh_area::num_reply_states, rbtree_delete(), RBTREE_FOR, rbtree_init(), mesh_state::reply_list, mesh_state_ref::s, mesh_state::sub_set, and mesh_state::super_set.
Referenced by fptr_whitelist_modenv_detach_subs(), and mesh_state_delete().
| 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 | ||
| ) |
Add detached query.
Creates it if it does not exist already. Does not make super/sub references. Performs a cycle detection - for double check - and fails if there is one. 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. o added subquery, created if it did not exist already.
| qstate | the state to find mesh state, and that wants to receive the results from the new subquery. |
| qinfo | what to query for (copied). |
| qflags | what flags to use (RD / CD flag or not). |
| prime | if it is a (stub) priming query. |
| valrec | if it is a validation recursion query (lookup of key, DS). |
| newq | If the new subquery needs initialisation, it is returned, otherwise NULL is returned. |
| sub | The added mesh state, created if it did not exist already. |
References mesh_area::all, module_qstate::env, log_assert, log_err(), module_env::mesh, mesh_area_find(), mesh_detect_cycle_found(), mesh_state_create(), mesh_area::num_detached_states, rbtree_insert(), mesh_area::run, VERB_ALGO, and verbose().
Referenced by fptr_whitelist_modenv_add_sub(), and mesh_attach_sub().
| int mesh_attach_sub | ( | struct module_qstate * | qstate, |
| struct query_info * | qinfo, | ||
| uint16_t | qflags, | ||
| int | prime, | ||
| int | valrec, | ||
| struct module_qstate ** | newq | ||
| ) |
Attach subquery.
Creates it if it does not exist already. Keeps sub and super references correct. Performs a cycle detection - for double check - and fails if there is one. Also fails if the sub-sub-references become too large. 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.
| qstate | the state to find mesh state, and that wants to receive the results from the new subquery. |
| qinfo | what to query for (copied). |
| qflags | what flags to use (RD / CD flag or not). |
| prime | if it is a (stub) priming query. |
| valrec | if it is a validation recursion query (lookup of key, DS). |
| newq | If the new subquery needs initialisation, it is returned, otherwise NULL is returned. |
References mesh_state::cb_list, rbtree_type::count, module_qstate::env, log_assert, module_env::mesh, mesh_add_sub(), module_qstate::mesh_info, mesh_state_attachment(), mesh_area::num_detached_states, mesh_state::reply_list, and mesh_state::super_set.
Referenced by fptr_whitelist_modenv_attach_sub().
| int mesh_state_attachment | ( | struct mesh_state * | super, |
| struct mesh_state * | sub | ||
| ) |
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.
| super | super state. |
| sub | sub state. |
References rbnode_type::key, log_assert, log_err(), mesh_state_ref::node, rbtree_insert(), module_qstate::region, regional_alloc(), mesh_state::s, mesh_state_ref::s, mesh_state::sub_set, and mesh_state::super_set.
Referenced by mesh_attach_sub().
|
static |
callback results to mesh cb entry
| m | mesh state to send it for. |
| rcode | if not 0, error code. |
| rep | reply to send (or NULL if rcode is set). |
| r | callback entry |
| start_time | the time to pass to callback functions, it is 0 or a value from one of the packets if the mesh state had packets. |
References mesh_state::s, sec_status_secure, reply_info::security, and module_qstate::was_ratelimited.
|
static |
Send reply to mesh reply entry.
| m | mesh state to send it for. |
| rcode | if not 0, error code. |
| rep | reply to send (or NULL if rcode is set). |
| r | reply entry |
| r_buffer | buffer to use for reply entry. |
| prev | previous reply, already has its answer encoded in buffer. |
| prev_buffer | buffer for previous reply. |
References mesh_state::reply_list.
| void mesh_query_done | ( | struct mesh_state * | mstate | ) |
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.
| 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. |
References comm_timer_delete(), dns_msg::rep, module_qstate::return_msg, module_qstate::return_rcode, mesh_state::s, and module_qstate::serve_expired_data.
| void mesh_walk_supers | ( | struct mesh_area * | mesh, |
| 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, it calls the current module for the super with the inform_super event.
| mesh | mesh area to add newly runnable modules to. |
| mstate | the state that has results, used to find mesh state. |
References copy_state_to_super(), module_qstate::curmod, fptr_ok, fptr_whitelist_mod_inform_super(), module_func_block::inform_super, module_stack::mod, mesh_area::mods, RBTREE_FOR, rbtree_insert(), mesh_area::run, mesh_state::run_node, mesh_state::s, mesh_state_ref::s, and mesh_state::super_set.
| 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 | ||
| ) |
Find a mesh state in the mesh area.
Pass relevant flags.
| mesh | the mesh area to look in. |
| cinfo | if non-NULL client specific info that may affect IP-based actions that apply to the query result. |
| qinfo | what query |
| qflags | if RD / CD bit is set or not. |
| prime | if it is a priming query. |
| valrec | if it is a validation-recursion query. |
References mesh_area::all, module_qstate::client_info, module_qstate::is_priming, module_qstate::is_valrec, rbnode_type::key, mesh_state::node, module_qstate::qinfo, module_qstate::query_flags, rbtree_search(), mesh_state::s, and mesh_state::unique.
Referenced by mesh_add_sub(), mesh_detect_cycle(), mesh_new_callback(), and mesh_new_client().
| 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 | ||
| ) |
Create new callback structure and attach it to a mesh state.
Does not update stat items in mesh area.
| s | the mesh state. |
| edns | edns data for reply (bufsize). |
| buf | buffer for reply |
| cb | callback to call with results. |
| cb_arg | callback user arg. |
| qid | ID of reply. |
| qflags | original query flags. |
References mesh_cb::buf, mesh_cb::cb, mesh_cb::cb_arg, mesh_state::cb_list, mesh_cb::edns, edns_opt_copy_region(), fptr_whitelist_mesh_cb(), log_assert, mesh_cb::next, edns_data::opt_list_in, edns_data::opt_list_inplace_cb_out, edns_data::opt_list_out, mesh_cb::qflags, mesh_cb::qid, module_qstate::region, regional_alloc(), and mesh_state::s.
Referenced by mesh_new_callback().
| 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 | ||
| ) |
Create new reply structure and attach it to a mesh state.
Does not update stat items in mesh area.
| s | the mesh state. |
| edns | edns data for reply (bufsize). |
| rep | comm point reply info. |
| qid | ID of reply. |
| qflags | original query flags. |
| qinfo | original query info. |
References comm_reply::c, packed_rrset_data::count, lruhash_entry::data, packed_rrset_key::dname, packed_rrset_key::dname_len, mesh_reply::edns, edns_opt_copy_region(), ub_packed_rrset_key::entry, module_qstate::env, mesh_reply::h2_stream, comm_point::h2_stream, LDNS_RR_TYPE_CNAME, mesh_reply::local_alias, query_info::local_alias, log_assert, local_rrset::next, mesh_reply::next, module_env::now_tv, edns_data::opt_list_in, edns_data::opt_list_inplace_cb_out, edns_data::opt_list_out, mesh_reply::qflags, mesh_reply::qid, module_qstate::qinfo, mesh_reply::qname, query_info::qname, query_info::qname_len, mesh_reply::query_reply, module_qstate::region, regional_alloc(), regional_alloc_init(), regional_alloc_zero(), mesh_state::reply_list, ub_packed_rrset_key::rk, packed_rrset_data::rr_data, packed_rrset_data::rr_len, packed_rrset_data::rr_ttl, local_rrset::rrset, rrset_insert_rr(), mesh_state::s, mesh_reply::start_time, packed_rrset_key::type, and comm_point::use_h2.
|
static |
Continue processing the mesh state at another module.
Handles module to modules transfer of control. Handles module finished.
| mesh | the mesh area. |
| mstate | currently active mesh state. Deleted if finished, calls _done and _supers to send replies to clients and inform other mesh states. This in turn may create additional runnable mesh states. |
| s | state at which the current module exited. |
| ev | the event sent to the module. returned is the event to send to the next module. |
References module_func_block::clear, rbtree_type::count, module_qstate::curmod, fptr_ok, fptr_whitelist_mod_clear(), log_err(), log_query_info(), MESH_MAX_ACTIVATION, module_qstate::minfo, module_stack::mod, mesh_area::mods, module_error, module_event_pass, module_restart_next, module_wait_module, module_wait_subquery, module_func_block::name, NO_VERBOSE, module_stack::num, mesh_state::num_activated, module_qstate::qinfo, module_qstate::return_rcode, mesh_state::s, mesh_state::sub_set, and VERB_QUERY.
Referenced by mesh_run().
| void mesh_run | ( | struct mesh_area * | mesh, |
| struct mesh_state * | mstate, | ||
| enum module_ev | ev, | ||
| struct outbound_entry * | e | ||
| ) |
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.
| mesh | mesh area. |
| mstate | first mesh state to run. |
| ev | event the mstate. Others get event_pass. |
| e | if a reply, its outbound entry. |
References rbtree_type::count, module_qstate::curmod, module_qstate::env, module_qstate::ext_state, fptr_ok, fptr_whitelist_mod_operate(), rbnode_type::key, mesh_continue(), mesh_log_list(), mesh_stats(), module_stack::mod, mesh_area::mods, module_event_pass, module_func_block::name, module_func_block::operate, rbtree_delete(), regional_free_all(), module_qstate::reply, rbtree_type::root, mesh_area::run, mesh_state::s, module_env::scratch, strextstate(), VERB_ALGO, verbose(), and verbosity.
Referenced by mesh_new_callback(), mesh_report_reply(), and validate_suspend_timer_cb().
| void mesh_log_list | ( | struct mesh_area * | mesh | ) |
Print all the states in the mesh to the log.
| mesh | the mesh to print all states of. |
References mesh_area::all, BIT_CD, BIT_RD, mesh_state::cb_list, rbtree_type::count, module_qstate::curmod, module_qstate::is_priming, module_qstate::is_valrec, log_query_info(), module_qstate::qinfo, module_qstate::query_flags, RBTREE_FOR, mesh_state::reply_list, mesh_state::s, mesh_state::sub_set, mesh_state::super_set, and VERB_ALGO.
Referenced by mesh_run().
| void mesh_stats | ( | struct mesh_area * | mesh, |
| const char * | str | ||
| ) |
Print some stats about the mesh to the log.
| mesh | the mesh to print it for. |
| str | descriptive string to go with it. |
Referenced by mesh_run(), worker_delete(), and worker_stat_timer_cb().
| void mesh_stats_clear | ( | struct mesh_area * | mesh | ) |
Clear the stats that the mesh keeps (number of queries serviced)
| mesh | the mesh |
References mesh_area::ans_bogus, mesh_area::ans_cachedb, mesh_area::ans_expired, mesh_area::ans_nodata, mesh_area::ans_rcode, mesh_area::ans_secure, mesh_area::histogram, mesh_area::replies_sent, mesh_area::replies_sum_wait, mesh_area::rpz_action, mesh_area::stats_dropped, mesh_area::stats_jostled, timehist_clear(), UB_STATS_RCODE_NUM, and UB_STATS_RPZ_ACTION_NUM.
Referenced by worker_stats_clear().
| size_t mesh_get_mem | ( | struct mesh_area * | mesh | ) |
Calculate memory size in use by mesh and all queries inside it.
| mesh | the mesh to examine. |
References mesh_area::histogram, timehist::num, and mesh_state::s.
| int mesh_detect_cycle | ( | struct module_qstate * | qstate, |
| struct query_info * | qinfo, | ||
| uint16_t | flags, | ||
| int | prime, | ||
| int | valrec | ||
| ) |
Find cycle; see if the given mesh is in the targets sub, or sub-sub, ...
trees. If the sub-sub structure is too large, it returns 'a cycle'=2.
| qstate | given mesh querystate. |
| qinfo | query info for dependency. |
| flags | query flags of dependency. |
| prime | if dependency is a priming query or not. |
| valrec | if it is a validation recursion query (lookup of key, DS). |
References module_qstate::env, module_env::mesh, mesh_area_find(), and mesh_detect_cycle_found().
Referenced by fptr_whitelist_modenv_detect_cycle().
| void mesh_list_insert | ( | struct mesh_state * | m, |
| struct mesh_state ** | fp, | ||
| struct mesh_state ** | lp | ||
| ) |
Insert mesh state into a double linked list.
Inserted at end.
| m | mesh state. |
| fp | pointer to the first-elem-pointer of the list. |
| lp | pointer to the last-elem-pointer of the list. |
References mesh_state::next, and mesh_state::prev.
| void mesh_list_remove | ( | struct mesh_state * | m, |
| struct mesh_state ** | fp, | ||
| struct mesh_state ** | lp | ||
| ) |
Remove mesh state from a double linked list.
Remove from any position.
| m | mesh state. |
| fp | pointer to the first-elem-pointer of the list. |
| lp | pointer to the last-elem-pointer of the list. |
References mesh_state::next, and mesh_state::prev.
Referenced by mesh_state_delete().
| void mesh_state_remove_reply | ( | struct mesh_area * | mesh, |
| struct mesh_state * | m, | ||
| struct comm_point * | cp | ||
| ) |
Remove mesh reply entry from the reply entry list.
Searches for the comm_point pointer.
| mesh | to update the counters. |
| m | the mesh state. |
| cp | the comm_point to remove from the list. |
References comm_reply::c, mesh_state::cb_list, rbtree_type::count, log_assert, mesh_reply::next, mesh_area::num_detached_states, mesh_area::num_reply_addrs, mesh_area::num_reply_states, mesh_reply::query_reply, mesh_state::reply_list, and mesh_state::super_set.
Referenced by tcp_req_info_clear().
| void mesh_serve_expired_callback | ( | void * | arg | ) |
Callback for when the serve expired client timer has run out.
Tries to find an expired answer in the cache and reply that to the client.
| arg | the argument passed to the callback. |
References apply_respip_action(), module_env::auth_zones, BIT_CD, module_env::cfg, comm_reply::client_addr, comm_reply::client_addrlen, module_qstate::client_info, comm_timer_delete(), config_file::ede, config_file::ede_serve_expired, mesh_reply::edns, edns_opt_list_append_ede(), edns_data::edns_present, module_qstate::env, fptr_ok, fptr_whitelist_serve_expired_lookup(), get_cname_target(), config_file::ignore_cd, module_qstate::is_drop, mesh_reply::local_alias, log_dns_msg(), log_err(), module_env::mesh, module_env::need_to_validate, mesh_reply::next, module_qstate::no_cache_lookup, edns_data::opt_list_out, query_info::qclass, module_qstate::qinfo, mesh_reply::qname, query_info::qname, query_info::qname_len, query_info::qtype, module_qstate::query_flags, mesh_reply::query_reply, module_qstate::region, dns_msg::rep, mesh_state::reply_list, respip_inform_print(), respip_merge_cname(), respip_none, mesh_state::s, module_qstate::serve_expired_data, mesh_reply::start_time, mesh_area::use_response_ip, mesh_area::use_rpz, VERB_ALGO, verbose(), and verbosity.
Referenced by fptr_whitelist_comm_timer(), and mesh_serve_expired_init().
| int mesh_jostle_exceeded | ( | struct mesh_area * | mesh | ) |
See if the mesh has space for more queries.
You can allocate queries anyway, but this checks for the allocated space.
| mesh | mesh area. |
References mesh_area::all, rbtree_type::count, and mesh_area::max_reply_states.
Referenced by query_for_targets().