replay.h

Go to the documentation of this file.

/*
 * 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.
 */

 
#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;

struct replay_scenario {
    char* title;

    struct replay_moment* mom_first;
    struct replay_moment* mom_last;

    struct replay_range* range_list;
};

struct replay_moment {
    int time_step;
    struct replay_moment* mom_next;

    enum replay_event_type {
        repevt_nothing,
        repevt_front_query,
        repevt_front_reply,
        repevt_timeout,
        repevt_time_passes,
        repevt_back_reply,
        repevt_back_query,
        repevt_autotrust_check,
        repevt_tempfile_check,
        repevt_error,
        repevt_assign,
        repevt_infra_rtt,
        repevt_traffic
    }

        evt_type;

    struct entry* match;

    struct timeval elapse;

    struct sockaddr_storage addr;
    socklen_t addrlen;

    char* variable;
    char* string;

    char* autotrust_id;
    struct config_strlist* file_content;
};

struct replay_range {
    int start_step;
    int end_step;
    struct sockaddr_storage addr;
    socklen_t addrlen;

    struct entry* match;

    struct replay_range* next_range;
};

struct replay_runtime {
    struct replay_scenario* scenario;
    struct replay_moment* now;

    struct fake_pending* pending_list;

    struct replay_answer* answer_list;
    
    struct replay_answer* answer_last;

    struct fake_timer* timer_list;

    comm_point_callback_type* callback_query;
    void *cb_arg;

    struct infra_cache* infra;

    time_t now_secs;
    struct timeval now_tv;

    void (*sig_cb)(int, void*);
    void *sig_cb_arg;
    int exit_cleanly;

    size_t bufsize;

    rbtree_type* vars;
};

struct fake_pending {
    struct sldns_buffer* buffer;
    struct sockaddr_storage addr;
    socklen_t addrlen;
    uint8_t* zone;
    size_t zonelen;
    int qtype;
    comm_point_callback_type* callback;
    void* cb_arg;
    int timeout;

    struct fake_pending* next;
    uint8_t* pkt;
    size_t pkt_len;
    enum transport_type transport;
    int serviced;
    int tcp_pkt_counter;
    struct replay_runtime* runtime;
};

struct replay_answer {
    struct replay_answer* next;
    struct comm_reply repinfo;
    uint8_t* pkt;
    size_t pkt_len;
};

struct fake_timer {
    struct fake_timer* next;
    struct replay_runtime* runtime;
    void (*cb)(void*);
    void* cb_arg;
    int enabled;
    struct timeval tv;
};

struct replay_var {
    rbnode_type node;
    char* name;
    char* value;
};

struct replay_scenario* replay_scenario_read(FILE* in, const char* name, 
    int* lineno);

void replay_scenario_delete(struct replay_scenario* scen);

int replay_var_compare(const void* a, const void* b);

struct fake_timer* replay_get_oldest_timer(struct replay_runtime* runtime);

rbtree_type* macro_store_create(void);

void macro_store_delete(rbtree_type* store);

char* macro_process(rbtree_type* store, struct replay_runtime* runtime, 
    char* text);

char* macro_lookup(rbtree_type* store, char* name);

int macro_assign(rbtree_type* store, char* name, char* value);

void macro_print_debug(rbtree_type* store);

void testbound_selftest(void);
 
#endif /* TESTCODE_REPLAY_H */