Store and use a replay of events for the DNS resolver. More...

#include "config.h"
#include <math.h>
#include <ctype.h>
#include <time.h>
#include "util/log.h"
#include "util/net_help.h"
#include "util/config_file.h"
#include "testcode/replay.h"
#include "testcode/testpkts.h"
#include "testcode/fake_event.h"
#include "sldns/str2wire.h"
#include "util/timeval_func.h"

Macros
#define	MAX_LINE_LEN 10240
	max length of lines in file

#define	tb_assert(x)

Functions
static char *	macro_expand (rbtree_type store, struct replay_runtime runtime, char **text)
	Expand a macro. More...

static int	parse_keyword (char *line, const char keyword)
	parse keyword in string. More...

static void	replay_moment_delete (struct replay_moment *mom)
	delete moment

static void	replay_range_delete (struct replay_range *rng)
	delete range

void	strip_end_white (char *p)
	strip whitespace from end of string

static struct replay_range *	replay_range_read (char remain, FILE in, const char name, struct sldns_file_parse_state pstate, char *line)
	Read a range from file. More...

static void	read_file_content (FILE in, int lineno, struct replay_moment *mom)
	Read FILE match content.

static void	read_assign_step (char remain, struct replay_moment mom)
	read assign step info

static struct replay_moment *	replay_moment_read (char remain, FILE in, const char name, struct sldns_file_parse_state pstate)
	Read a replay moment 'STEP' from file. More...

static struct replay_scenario *	make_scenario (char *line)
	makes scenario with title on rest of line

struct replay_scenario *	replay_scenario_read (FILE in, const char name, int *lineno)
	Read a replay scenario from the file. More...

void	replay_scenario_delete (struct replay_scenario *scen)
	Delete scenario. More...

static struct fake_timer *	first_timer (struct replay_runtime *runtime)
	fetch oldest timer in list that is enabled

struct fake_timer *	replay_get_oldest_timer (struct replay_runtime *runtime)
	get oldest enabled fake timer

int	replay_var_compare (const void a, const void b)
	compare two replay_vars

rbtree_type *	macro_store_create (void)
	Create variable storage. More...

static void	del_macro (rbnode_type x, void ATTR_UNUSED(arg))
	helper function to delete macro values

void	macro_store_delete (rbtree_type *store)
	Delete variable storage. More...

static size_t	macro_length (char *text)
	return length of macro

static int	do_buf_insert (char buf, size_t remain, char after, char *inserted)
	insert new stuff at start of buffer

static char *	do_macro_recursion (rbtree_type store, struct replay_runtime runtime, char *at, size_t remain)
	do macro recursion

static struct replay_var *	macro_getvar (rbtree_type store, char name)
	get var from store

static char *	do_macro_variable (rbtree_type store, char buf, size_t remain)
	do macro variable

static char *	do_macro_ctime (char *arg)
	do ctime macro on argument

static double	perform_arith (double x, char op, double y, double *res)
	perform arithmetic operator

static char *	do_macro_arith (char orig, size_t remain, char *arithstart)
	do macro arithmetic on two numbers and operand

static char *	do_macro_range (char *buf)
	Do range macro on expanded buffer.

char *	macro_process (rbtree_type store, struct replay_runtime runtime, char *text)
	Apply macro substitution to string. More...

char *	macro_lookup (rbtree_type store, char name)
	Look up a macro value. More...

void	macro_print_debug (rbtree_type *store)
	Print macro variables stored as debug info.

int	macro_assign (rbtree_type store, char name, char *value)
	Set macro value. More...

void	testbound_selftest (void)
	testbounds self test

Detailed Description

Store and use a replay of events for the DNS resolver.

Used to test known scenarios to get known outcomes.

Macro Definition Documentation

◆ tb_assert

#define tb_assert ( x )

Value:

        do { if(!(x)) fatal_exit("%s:%d: %s: assertion %s failed", \
                __FILE__, __LINE__, __func__, #x); \
                num_asserts++; \
        } while(0);

Function Documentation

◆ macro_expand()

static char * macro_expand	(	rbtree_type *	store,
		struct replay_runtime *	runtime,
		char **	text
	)

static

Expand a macro.

Parameters

store	value storage
runtime	replay runtime for other stuff.
text	the macro text, after the ${, Updated to after the } when done (successfully).

Returns: expanded text, malloced. NULL on failure.

References do_macro_arith(), do_macro_ctime(), do_macro_range(), do_macro_recursion(), do_macro_variable(), first_timer(), macro_length(), replay_runtime::now_secs, fake_timer::runtime, and fake_timer::tv.

Referenced by do_macro_recursion(), and macro_process().

◆ parse_keyword()

static int parse_keyword	(	char **	line,
		const char *	keyword
	)

static

parse keyword in string.

Parameters

line	if found, the line is advanced to after the keyword.
keyword	string.

Returns: : true if found, false if not.

Referenced by replay_moment_read(), replay_range_read(), and replay_scenario_read().

◆ replay_range_read()

static struct replay_range* replay_range_read	(	char *	remain,
		FILE *	in,
		const char *	name,
		struct sldns_file_parse_state *	pstate,
		char *	line
	)

static

Read a range from file.

Parameters

remain	Rest of line (after RANGE keyword).
in	file to read from.
name	name to print in errors.
pstate	read state structure with with lineno : incremented as lines are read. ttl, origin, prev for readentry.
line	line buffer.

Returns: : range object to add to list, or NULL on error.

References replay_range::addr, replay_range::addrlen, replay_range::end_step, extstrtoaddr(), sldns_file_parse_state::lineno, log_err(), MAX_LINE_LEN, parse_keyword(), read_entry(), replay_range::start_step, and strip_end_white().

◆ replay_moment_read()

static struct replay_moment* replay_moment_read	(	char *	remain,
		FILE *	in,
		const char *	name,
		struct sldns_file_parse_state *	pstate
	)

static

Read a replay moment 'STEP' from file.

Parameters

remain	Rest of line (after STEP keyword).
in	file to read from.
name	name to print in errors.
pstate	with lineno, ttl, origin, prev for parse state. lineno is incremented.