a85b5759f3
These files were pulled from the 1.6.3 release tarball. This new version builds against OpenSSL version 1.1 which will be the default in the new Debian Stable which is due to be released RealSoonNow (tm).
459 lines
13 KiB
C
459 lines
13 KiB
C
/*
|
|
* testcode/replay.h - store and use a replay of events for the DNS resolver.
|
|
*
|
|
* 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
|
|
* Store and use a replay of events for the DNS resolver.
|
|
* Used to test known scenarios to get known outcomes.
|
|
*
|
|
* <pre>
|
|
* File format for replay files.
|
|
*
|
|
* ; unbound.conf options.
|
|
* ; ...
|
|
* ; additional commandline options to pass to unbound
|
|
* COMMANDLINE cmdline_option
|
|
* ; autotrust key file contents, also adds auto-trust-anchor-file: "x" to cfg
|
|
* AUTOTRUST_FILE id
|
|
* ; contents of that file
|
|
* AUTOTRUST_END
|
|
* CONFIG_END
|
|
* ; comment line.
|
|
* SCENARIO_BEGIN name_of_scenario
|
|
* RANGE_BEGIN start_time end_time
|
|
* ; give ip of the virtual server, it matches any ip if not present.
|
|
* ADDRESS ip_address
|
|
* match_entries
|
|
* RANGE_END
|
|
* ; more RANGE items.
|
|
* ; go to the next moment
|
|
* STEP time_step event_type [ADDRESS ip_address]
|
|
* ; event_type can be:
|
|
* o NOTHING - nothing
|
|
* o QUERY - followed by entry
|
|
* o CHECK_ANSWER - followed by entry
|
|
* o CHECK_OUT_QUERY - followed by entry (if copy-id it is also reply).
|
|
* o REPLY - followed by entry
|
|
* o TIMEOUT
|
|
* o TIME_PASSES ELAPSE [seconds] - increase 'now' time counter, can be
|
|
* a floating point number.
|
|
* TIME_PASSES EVAL [macro] - expanded for seconds to move time.
|
|
* o TRAFFIC - like CHECK_ANSWER, causes traffic to flow.
|
|
* actually the traffic flows before this step is taken.
|
|
* the step waits for traffic to stop.
|
|
* o CHECK_AUTOTRUST [id] - followed by FILE_BEGIN [to match] FILE_END.
|
|
* The file contents is macro expanded before match.
|
|
* o INFRA_RTT [ip] [dp] [rtt] - update infra cache entry with rtt.
|
|
* o ERROR
|
|
* ; following entry starts on the next line, ENTRY_BEGIN.
|
|
* ; more STEP items
|
|
* SCENARIO_END
|
|
*
|
|
* Calculations, a macro-like system: ${$myvar + 3600}
|
|
* STEP 10 ASSIGN myvar = 3600
|
|
* ; ASSIGN event. '=' is syntactic sugar here. 3600 is some expression.
|
|
* ${..} is macro expanded from its expression. Text substitution.
|
|
* o $var replaced with its value. var is identifier [azAZ09_]*
|
|
* o number is that number.
|
|
* o ${variables and arithmetic }
|
|
* o +, -, / and *. Note, evaluated left-to-right. Use ${} for brackets.
|
|
* So again, no precedence rules, so 2+3*4 == ${2+3}*4 = 20.
|
|
* Do 2+${3*4} to get 24.
|
|
* o ${function params}
|
|
* o ${time} is the current time for the simulated unbound.
|
|
* o ${ctime value} is the text ctime(value), Fri 3 Aug 2009, ...
|
|
* o ${timeout} is the time until next timeout in comm_timer list.
|
|
* o ${range lower value upper} checks if lower<=value<=upper
|
|
* returns value if check succeeds.
|
|
*
|
|
* ; Example file
|
|
* SCENARIO_BEGIN Example scenario
|
|
* RANGE_BEGIN 0 100
|
|
* ENTRY_BEGIN
|
|
* ; precoded answers to queries.
|
|
* ENTRY_END
|
|
* END_RANGE
|
|
* STEP 0 QUERY
|
|
* ENTRY_BEGIN
|
|
* ; query
|
|
* ENTRY_END
|
|
* ; a query is sent out to the network by resolver.
|
|
* ; precoded answer from range is returned.
|
|
* ; algorithm will do precoded answers from RANGE immediately, except if
|
|
* ; the next step specifically checks for that OUT_QUERY.
|
|
* ; or if none of the precoded answers match.
|
|
* STEP 1 CHECK_ANSWER
|
|
* ENTRY_BEGIN
|
|
* ; what the reply should look like
|
|
* ENTRY_END
|
|
* ; successful termination. (if the answer was OK).
|
|
* ; also, all answers must have been checked with CHECK_ANSWER.
|
|
* ; and, no more pending out_queries (that have not been checked).
|
|
* SCENARIO_END
|
|
*
|
|
* </pre>
|
|
*/
|
|
|
|
#ifndef TESTCODE_REPLAY_H
|
|
#define TESTCODE_REPLAY_H
|
|
#include "util/netevent.h"
|
|
#include "testcode/testpkts.h"
|
|
#include "util/rbtree.h"
|
|
struct replay_answer;
|
|
struct replay_moment;
|
|
struct replay_range;
|
|
struct fake_pending;
|
|
struct fake_timer;
|
|
struct replay_var;
|
|
struct infra_cache;
|
|
struct sldns_buffer;
|
|
|
|
/**
|
|
* A replay scenario.
|
|
*/
|
|
struct replay_scenario {
|
|
/** name of replay scenario. malloced string. */
|
|
char* title;
|
|
|
|
/** The list of replay moments. Linked list. Time increases in list. */
|
|
struct replay_moment* mom_first;
|
|
/** The last element in list of replay moments. */
|
|
struct replay_moment* mom_last;
|
|
|
|
/**
|
|
* List of matching answers. This is to ease replay scenario
|
|
* creation. It lists queries (to the network) and what answer
|
|
* should be returned. The matching answers are valid for a range
|
|
* of time steps.
|
|
* So: timestep, parts of query, destination --> answer.
|
|
*/
|
|
struct replay_range* range_list;
|
|
};
|
|
|
|
/**
|
|
* A replay moment.
|
|
* Basically, it consists of events to a fake select() call.
|
|
* This is a recording of an event that happens.
|
|
* And if output is presented, what is done with that.
|
|
*/
|
|
struct replay_moment {
|
|
/**
|
|
* The replay time step number. Starts at 0, time is incremented
|
|
* every time the fake select() is run.
|
|
*/
|
|
int time_step;
|
|
/** Next replay moment in list of replay moments. */
|
|
struct replay_moment* mom_next;
|
|
|
|
/** what happens this moment? */
|
|
enum replay_event_type {
|
|
/** nothing happens, as if this event is not there. */
|
|
repevt_nothing,
|
|
/** incoming query */
|
|
repevt_front_query,
|
|
/** test fails if reply to query does not match */
|
|
repevt_front_reply,
|
|
/** timeout */
|
|
repevt_timeout,
|
|
/** time passes */
|
|
repevt_time_passes,
|
|
/** reply arrives from the network */
|
|
repevt_back_reply,
|
|
/** test fails if query to the network does not match */
|
|
repevt_back_query,
|
|
/** check autotrust key file */
|
|
repevt_autotrust_check,
|
|
/** an error happens to outbound query */
|
|
repevt_error,
|
|
/** assignment to a variable */
|
|
repevt_assign,
|
|
/** store infra rtt cache entry: addr and string (int) */
|
|
repevt_infra_rtt,
|
|
/** cause traffic to flow */
|
|
repevt_traffic
|
|
}
|
|
/** variable with what is to happen this moment */
|
|
evt_type;
|
|
|
|
/** The sent packet must match this. Incoming events, the data. */
|
|
struct entry* match;
|
|
|
|
/** the amount of time that passes */
|
|
struct timeval elapse;
|
|
|
|
/** address that must be matched, or packet remote host address. */
|
|
struct sockaddr_storage addr;
|
|
/** length of addr, if 0, then any address will do */
|
|
socklen_t addrlen;
|
|
|
|
/** macro name, for assign. */
|
|
char* variable;
|
|
/** string argument, for assign. */
|
|
char* string;
|
|
|
|
/** the autotrust file id to check */
|
|
char* autotrust_id;
|
|
/** file contents to match, one string per line */
|
|
struct config_strlist* file_content;
|
|
};
|
|
|
|
/**
|
|
* Range of timesteps, and canned replies to matching queries.
|
|
*/
|
|
struct replay_range {
|
|
/** time range when this is valid. Including start and end step. */
|
|
int start_step;
|
|
/** end step of time range. */
|
|
int end_step;
|
|
/** address of where this range is served. */
|
|
struct sockaddr_storage addr;
|
|
/** length of addr, if 0, then any address will do */
|
|
socklen_t addrlen;
|
|
|
|
/** Matching list */
|
|
struct entry* match;
|
|
|
|
/** next in list of time ranges. */
|
|
struct replay_range* next_range;
|
|
};
|
|
|
|
/**
|
|
* Replay storage of runtime information.
|
|
*/
|
|
struct replay_runtime {
|
|
/**
|
|
* The scenario
|
|
*/
|
|
struct replay_scenario* scenario;
|
|
/**
|
|
* Current moment.
|
|
*/
|
|
struct replay_moment* now;
|
|
|
|
/**
|
|
* List of pending queries in order they were sent out. First
|
|
* one has been sent out most recently. Last one in list is oldest.
|
|
*/
|
|
struct fake_pending* pending_list;
|
|
|
|
/**
|
|
* List of answers to queries from clients. These need to be checked.
|
|
*/
|
|
struct replay_answer* answer_list;
|
|
|
|
/** last element in answer list. */
|
|
struct replay_answer* answer_last;
|
|
|
|
/** list of fake timer callbacks that are pending */
|
|
struct fake_timer* timer_list;
|
|
|
|
/** callback to call for incoming queries */
|
|
comm_point_callback_type* callback_query;
|
|
/** user argument for incoming query callback */
|
|
void *cb_arg;
|
|
|
|
/** ref the infra cache (was passed to outside_network_create) */
|
|
struct infra_cache* infra;
|
|
|
|
/** the current time in seconds */
|
|
time_t now_secs;
|
|
/** the current time in microseconds */
|
|
struct timeval now_tv;
|
|
|
|
/** signal handler callback */
|
|
void (*sig_cb)(int, void*);
|
|
/** signal handler user arg */
|
|
void *sig_cb_arg;
|
|
/** time to exit cleanly */
|
|
int exit_cleanly;
|
|
|
|
/** size of buffers */
|
|
size_t bufsize;
|
|
|
|
/**
|
|
* Tree of macro values. Of type replay_var
|
|
*/
|
|
rbtree_type* vars;
|
|
};
|
|
|
|
/**
|
|
* Pending queries to network, fake replay version.
|
|
*/
|
|
struct fake_pending {
|
|
/** what is important only that we remember the query, copied here. */
|
|
struct sldns_buffer* buffer;
|
|
/** and to what address this is sent to. */
|
|
struct sockaddr_storage addr;
|
|
/** len of addr */
|
|
socklen_t addrlen;
|
|
/** zone name, uncompressed wire format (as used when sent) */
|
|
uint8_t* zone;
|
|
/** length of zone name */
|
|
size_t zonelen;
|
|
/** qtype */
|
|
int qtype;
|
|
/** The callback function to call when answer arrives (or timeout) */
|
|
comm_point_callback_type* callback;
|
|
/** callback user argument */
|
|
void* cb_arg;
|
|
/** original timeout in seconds from 'then' */
|
|
int timeout;
|
|
|
|
/** next in pending list */
|
|
struct fake_pending* next;
|
|
/** the buffer parsed into a sldns_pkt */
|
|
uint8_t* pkt;
|
|
size_t pkt_len;
|
|
/** by what transport was the query sent out */
|
|
enum transport_type transport;
|
|
/** if this is a serviced query */
|
|
int serviced;
|
|
/** the runtime structure this is part of */
|
|
struct replay_runtime* runtime;
|
|
};
|
|
|
|
/**
|
|
* An answer that is pending to happen.
|
|
*/
|
|
struct replay_answer {
|
|
/** Next in list */
|
|
struct replay_answer* next;
|
|
/** reply information */
|
|
struct comm_reply repinfo;
|
|
/** the answer preparsed as ldns pkt */
|
|
uint8_t* pkt;
|
|
size_t pkt_len;
|
|
};
|
|
|
|
/**
|
|
* Timers with callbacks, fake replay version.
|
|
*/
|
|
struct fake_timer {
|
|
/** next in list */
|
|
struct fake_timer* next;
|
|
/** the runtime structure this is part of */
|
|
struct replay_runtime* runtime;
|
|
/** the callback to call */
|
|
void (*cb)(void*);
|
|
/** the callback user argument */
|
|
void* cb_arg;
|
|
/** if timer is enabled */
|
|
int enabled;
|
|
/** when the timer expires */
|
|
struct timeval tv;
|
|
};
|
|
|
|
/**
|
|
* Replay macro variable. And its value.
|
|
*/
|
|
struct replay_var {
|
|
/** rbtree node. Key is this structure. Sorted by name. */
|
|
rbnode_type node;
|
|
/** the variable name */
|
|
char* name;
|
|
/** the variable value */
|
|
char* value;
|
|
};
|
|
|
|
/**
|
|
* Read a replay scenario from the file.
|
|
* @param in: file to read from.
|
|
* @param name: name to print in errors.
|
|
* @param lineno: incremented for every line read.
|
|
* @return: Scenario. NULL if no scenario read.
|
|
*/
|
|
struct replay_scenario* replay_scenario_read(FILE* in, const char* name,
|
|
int* lineno);
|
|
|
|
/**
|
|
* Delete scenario.
|
|
* @param scen: to delete.
|
|
*/
|
|
void replay_scenario_delete(struct replay_scenario* scen);
|
|
|
|
/** compare two replay_vars */
|
|
int replay_var_compare(const void* a, const void* b);
|
|
|
|
/** get oldest enabled fake timer */
|
|
struct fake_timer* replay_get_oldest_timer(struct replay_runtime* runtime);
|
|
|
|
/**
|
|
* Create variable storage
|
|
* @return new or NULL on failure.
|
|
*/
|
|
rbtree_type* macro_store_create(void);
|
|
|
|
/**
|
|
* Delete variable storage
|
|
* @param store: the macro storage to free up.
|
|
*/
|
|
void macro_store_delete(rbtree_type* store);
|
|
|
|
/**
|
|
* Apply macro substitution to string.
|
|
* @param store: variable store.
|
|
* @param runtime: the runtime to look up values as needed.
|
|
* @param text: string to work on.
|
|
* @return newly malloced string with result.
|
|
*/
|
|
char* macro_process(rbtree_type* store, struct replay_runtime* runtime,
|
|
char* text);
|
|
|
|
/**
|
|
* Look up a macro value. Like calling ${$name}.
|
|
* @param store: variable store
|
|
* @param name: macro name
|
|
* @return newly malloced string with result or strdup("") if not found.
|
|
* or NULL on malloc failure.
|
|
*/
|
|
char* macro_lookup(rbtree_type* store, char* name);
|
|
|
|
/**
|
|
* Set macro value.
|
|
* @param store: variable store
|
|
* @param name: macro name
|
|
* @param value: text to set it to. Not expanded.
|
|
* @return false on failure.
|
|
*/
|
|
int macro_assign(rbtree_type* store, char* name, char* value);
|
|
|
|
/** Print macro variables stored as debug info */
|
|
void macro_print_debug(rbtree_type* store);
|
|
|
|
/** testbounds self test */
|
|
void testbound_selftest(void);
|
|
|
|
#endif /* TESTCODE_REPLAY_H */
|