/*
* 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_t* 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_t* 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_t* 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_t 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_t* macro_store_create(void);
/**
* Delete variable storage
* @param store: the macro storage to free up.
*/
void macro_store_delete(rbtree_t* 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_t* 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_t* 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_t* store, char* name, char* value);
/** Print macro variables stored as debug info */
void macro_print_debug(rbtree_t* store);
/** testbounds self test */
void testbound_selftest(void);
#endif /* TESTCODE_REPLAY_H */
