diff options
Diffstat (limited to 'contrib/unbound/testcode/testbound.c')
| -rw-r--r-- | contrib/unbound/testcode/testbound.c | 788 |
1 files changed, 788 insertions, 0 deletions
diff --git a/contrib/unbound/testcode/testbound.c b/contrib/unbound/testcode/testbound.c new file mode 100644 index 000000000000..063037df4e80 --- /dev/null +++ b/contrib/unbound/testcode/testbound.c @@ -0,0 +1,788 @@ +/* + * testcode/testbound.c - test program for unbound. + * + * 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 + * Exits with code 1 on a failure. 0 if all unit tests are successful. + */ + +#include "config.h" +#ifdef HAVE_TIME_H +# include <time.h> +#endif +#include <ctype.h> +#include "testcode/testpkts.h" +#include "testcode/replay.h" +#include "testcode/fake_event.h" +#include "daemon/remote.h" +#include "libunbound/worker.h" +#include "daemon/worker.h" +#include "util/config_file.h" +#include "sldns/keyraw.h" +#ifdef UB_ON_WINDOWS +#include "winrc/win_svc.h" +#endif + +/** signal that this is a testbound compile */ +#define unbound_testbound 1 +/** renamed main routine */ +int daemon_main(int argc, char* argv[]); +/** + * include the main program from the unbound daemon. + * rename main to daemon_main to call it + */ +#define main daemon_main +#include "daemon/unbound.c" +#undef main + +/** maximum line length for lines in the replay file. */ +#define MAX_LINE_LEN 1024 +/** config files (removed at exit) */ +static struct config_strlist* cfgfiles = NULL; + +/** give commandline usage for testbound. */ +static void +testbound_usage(void) +{ + printf("usage: testbound [options]\n"); + printf("\ttest the unbound daemon.\n"); + printf("-h this help\n"); + printf("-p file playback text file\n"); + printf("-1 detect SHA1 support (exit code 0 or 1)\n"); + printf("-2 detect SHA256 support (exit code 0 or 1)\n"); + printf("-g detect GOST support (exit code 0 or 1)\n"); + printf("-e detect ECDSA support (exit code 0 or 1)\n"); + printf("-c detect CLIENT_SUBNET support (exit code 0 or 1)\n"); + printf("-i detect IPSECMOD support (exit code 0 or 1)\n"); + printf("-s testbound self-test - unit test of testbound parts.\n"); + printf("-o str unbound commandline options separated by spaces.\n"); + printf("Version %s\n", PACKAGE_VERSION); + printf("BSD licensed, see LICENSE file in source package.\n"); + printf("Report bugs to %s.\n", PACKAGE_BUGREPORT); +} + +/** Max number of arguments to pass to unbound. */ +#define MAXARG 100 + +/** + * Add options from string to passed argc. splits on whitespace. + * @param args: the option argument, "-v -p 12345" or so. + * @param pass_argc: ptr to the argc for unbound. Modified. + * @param pass_argv: the argv to pass to unbound. Modified. + */ +static void +add_opts(const char* args, int* pass_argc, char* pass_argv[]) +{ + const char *p = args, *np; + size_t len; + while(p && isspace((unsigned char)*p)) + p++; + while(p && *p) { + /* find location of next string and length of this one */ + if((np = strchr(p, ' '))) + len = (size_t)(np-p); + else len = strlen(p); + /* allocate and copy option */ + if(*pass_argc >= MAXARG-1) + fatal_exit("too many arguments: '%s'", p); + pass_argv[*pass_argc] = (char*)malloc(len+1); + if(!pass_argv[*pass_argc]) + fatal_exit("add_opts: out of memory"); + memcpy(pass_argv[*pass_argc], p, len); + pass_argv[*pass_argc][len] = 0; + (*pass_argc)++; + /* go to next option */ + p = np; + while(p && isspace((unsigned char)*p)) + p++; + } +} + +/** pretty print commandline for unbound in this test */ +static void +echo_cmdline(int argc, char* argv[]) +{ + int i; + fprintf(stderr, "testbound is starting:"); + for(i=0; i<argc; i++) { + fprintf(stderr, " [%s]", argv[i]); + } + fprintf(stderr, "\n"); +} + +/** spool temp file name */ +static void +spool_temp_file_name(int* lineno, FILE* cfg, char* id) +{ + char line[MAX_LINE_LEN]; + /* find filename for new file */ + while(isspace((unsigned char)*id)) + id++; + if(*id == '\0') + fatal_exit("TEMPFILE_NAME must have id, line %d", *lineno); + strip_end_white(id); + fake_temp_file("_temp_", id, line, sizeof(line)); + fprintf(cfg, "\"%s\"\n", line); +} + +/** spool temp file */ +static void +spool_temp_file(FILE* in, int* lineno, char* id) +{ + char line[MAX_LINE_LEN]; + char* parse; + FILE* spool; + /* find filename for new file */ + while(isspace((unsigned char)*id)) + id++; + if(*id == '\0') + fatal_exit("TEMPFILE_CONTENTS must have id, line %d", *lineno); + strip_end_white(id); + fake_temp_file("_temp_", id, line, sizeof(line)); + /* open file and spool to it */ + spool = fopen(line, "w"); + if(!spool) fatal_exit("could not open %s: %s", line, strerror(errno)); + fprintf(stderr, "testbound is spooling temp file: %s\n", line); + if(!cfg_strlist_insert(&cfgfiles, strdup(line))) + fatal_exit("out of memory"); + line[sizeof(line)-1] = 0; + while(fgets(line, MAX_LINE_LEN-1, in)) { + parse = line; + (*lineno)++; + while(isspace((unsigned char)*parse)) + parse++; + if(strncmp(parse, "$INCLUDE_TEMPFILE", 17) == 0) { + char l2[MAX_LINE_LEN-30]; /* -30 makes it fit with + a preceding $INCLUDE in the buf line[] */ + char* tid = parse+17; + while(isspace((unsigned char)*tid)) + tid++; + strip_end_white(tid); + fake_temp_file("_temp_", tid, l2, sizeof(l2)); + snprintf(line, sizeof(line), "$INCLUDE %s\n", l2); + } + if(strncmp(parse, "TEMPFILE_END", 12) == 0) { + fclose(spool); + return; + } + fputs(line, spool); + } + fatal_exit("no TEMPFILE_END in input file"); +} + +/** spool autotrust file */ +static void +spool_auto_file(FILE* in, int* lineno, FILE* cfg, char* id) +{ + char line[MAX_LINE_LEN]; + char* parse; + FILE* spool; + /* find filename for new file */ + while(isspace((unsigned char)*id)) + id++; + if(*id == '\0') + fatal_exit("AUTROTRUST_FILE must have id, line %d", *lineno); + strip_end_white(id); + fake_temp_file("_auto_", id, line, sizeof(line)); + /* add option for the file */ + fprintf(cfg, "server: auto-trust-anchor-file: \"%s\"\n", line); + /* open file and spool to it */ + spool = fopen(line, "w"); + if(!spool) fatal_exit("could not open %s: %s", line, strerror(errno)); + fprintf(stderr, "testbound is spooling key file: %s\n", line); + if(!cfg_strlist_insert(&cfgfiles, strdup(line))) + fatal_exit("out of memory"); + line[sizeof(line)-1] = 0; + while(fgets(line, MAX_LINE_LEN-1, in)) { + parse = line; + (*lineno)++; + while(isspace((unsigned char)*parse)) + parse++; + if(strncmp(parse, "AUTOTRUST_END", 13) == 0) { + fclose(spool); + return; + } + fputs(line, spool); + } + fatal_exit("no AUTOTRUST_END in input file"); +} + +/** process config elements */ +static void +setup_config(FILE* in, int* lineno, int* pass_argc, char* pass_argv[]) +{ + char configfile[MAX_LINE_LEN]; + char line[MAX_LINE_LEN]; + char* parse; + FILE* cfg; + fake_temp_file("_cfg", "", configfile, sizeof(configfile)); + add_opts("-c", pass_argc, pass_argv); + add_opts(configfile, pass_argc, pass_argv); + cfg = fopen(configfile, "w"); + if(!cfg) fatal_exit("could not open %s: %s", + configfile, strerror(errno)); + if(!cfg_strlist_insert(&cfgfiles, strdup(configfile))) + fatal_exit("out of memory"); + line[sizeof(line)-1] = 0; + /* some basic settings to not pollute the host system */ + fprintf(cfg, "server: use-syslog: no\n"); + fprintf(cfg, " directory: \"\"\n"); + fprintf(cfg, " chroot: \"\"\n"); + fprintf(cfg, " username: \"\"\n"); + fprintf(cfg, " pidfile: \"\"\n"); + fprintf(cfg, " val-log-level: 2\n"); + fprintf(cfg, " log-servfail: yes\n"); + fprintf(cfg, "remote-control: control-enable: no\n"); + while(fgets(line, MAX_LINE_LEN-1, in)) { + parse = line; + (*lineno)++; + while(isspace((unsigned char)*parse)) + parse++; + if(!*parse || parse[0] == ';') + continue; + if(strncmp(parse, "COMMANDLINE", 11) == 0) { + parse[strlen(parse)-1] = 0; /* strip off \n */ + add_opts(parse+11, pass_argc, pass_argv); + continue; + } + if(strncmp(parse, "AUTOTRUST_FILE", 14) == 0) { + spool_auto_file(in, lineno, cfg, parse+14); + continue; + } + if(strncmp(parse, "TEMPFILE_NAME", 13) == 0) { + spool_temp_file_name(lineno, cfg, parse+13); + continue; + } + if(strncmp(parse, "TEMPFILE_CONTENTS", 17) == 0) { + spool_temp_file(in, lineno, parse+17); + continue; + } + if(strncmp(parse, "CONFIG_END", 10) == 0) { + fclose(cfg); + return; + } + if(strncmp(parse, "fake-sha1: yes", 14) == 0) { + /* Allow the use of SHA1 signatures for the test, + * in case that OpenSSL disallows use of RSASHA1 + * with rh-allow-sha1-signatures disabled. */ +#ifndef UB_ON_WINDOWS + setenv("OPENSSL_ENABLE_SHA1_SIGNATURES", "1", 0); +#else + _putenv("OPENSSL_ENABLE_SHA1_SIGNATURES=1"); +#endif + } + fputs(line, cfg); + } + fatal_exit("No CONFIG_END in input file"); + +} + +/** read playback file */ +static struct replay_scenario* +setup_playback(const char* filename, int* pass_argc, char* pass_argv[]) +{ + struct replay_scenario* scen = NULL; + int lineno = 0; + + if(filename) { + FILE *in = fopen(filename, "rb"); + if(!in) { + perror(filename); + exit(1); + } + setup_config(in, &lineno, pass_argc, pass_argv); + scen = replay_scenario_read(in, filename, &lineno); + fclose(in); + if(!scen) + fatal_exit("Could not read: %s", filename); + } + else fatal_exit("need a playback file (-p)"); + log_info("Scenario: %s", scen->title); + return scen; +} + +/** remove config file at exit */ +static void remove_configfile(void) +{ + struct config_strlist* p; + for(p=cfgfiles; p; p=p->next) + unlink(p->str); + config_delstrlist(cfgfiles); + cfgfiles = NULL; +} + +/** perform the playback on the playback_file with the args. */ +static int +perform_playback(char* playback_file, int pass_argc, char** pass_argv) +{ + struct replay_scenario* scen = NULL; + int c, res; + + /* setup test environment */ + scen = setup_playback(playback_file, &pass_argc, pass_argv); + /* init fake event backend */ + fake_event_init(scen); + + pass_argv[pass_argc] = NULL; + echo_cmdline(pass_argc, pass_argv); + + /* run the normal daemon */ + res = daemon_main(pass_argc, pass_argv); + + fake_event_cleanup(); + for(c=1; c<pass_argc; c++) + free(pass_argv[c]); + return res; +} + +/* For fuzzing the main routine is replaced with + * LLVMFuzzerTestOneInput. */ +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION +#define main dummy_main +#endif +/** + * Main fake event test program. Setup, teardown and report errors. + * @param argc: arg count. + * @param argv: array of commandline arguments. + * @return program failure if test fails. + */ +int +main(int argc, char* argv[]) +{ + int c, res; + int pass_argc = 0; + char* pass_argv[MAXARG]; + char* playback_file = NULL; + int init_optind = optind; + char* init_optarg = optarg; + + /* we do not want the test to depend on the timezone */ + (void)putenv("TZ=UTC"); + memset(pass_argv, 0, sizeof(pass_argv)); +#ifdef HAVE_SYSTEMD + /* we do not want the test to use systemd daemon startup notification*/ + (void)unsetenv("NOTIFY_SOCKET"); +#endif /* HAVE_SYSTEMD */ + + checklock_start(); + log_init(NULL, 0, NULL); + /* determine commandline options for the daemon */ + pass_argc = 1; + pass_argv[0] = "unbound"; + add_opts("-d", &pass_argc, pass_argv); + while( (c=getopt(argc, argv, "12egciho:p:s")) != -1) { + switch(c) { + case 's': + free(pass_argv[1]); + testbound_selftest(); + checklock_stop(); + if(log_get_lock()) { + lock_basic_destroy((lock_basic_type*)log_get_lock()); + } + exit(0); + case '1': +#ifdef USE_SHA1 + printf("SHA1 supported\n"); + exit(0); +#else + printf("SHA1 not supported\n"); + exit(1); +#endif + break; + case '2': +#if (defined(HAVE_EVP_SHA256) || defined(HAVE_NSS) || defined(HAVE_NETTLE)) && defined(USE_SHA2) + printf("SHA256 supported\n"); + exit(0); +#else + printf("SHA256 not supported\n"); + exit(1); +#endif + break; + case 'e': +#if defined(USE_ECDSA) + printf("ECDSA supported\n"); + exit(0); +#else + printf("ECDSA not supported\n"); + exit(1); +#endif + break; + case 'g': +#ifdef USE_GOST + if(sldns_key_EVP_load_gost_id()) { + printf("GOST supported\n"); + exit(0); + } else { + printf("GOST not supported\n"); + exit(1); + } +#else + printf("GOST not supported\n"); + exit(1); +#endif + break; + case 'c': +#ifdef CLIENT_SUBNET + printf("CLIENT_SUBNET supported\n"); + exit(0); +#else + printf("CLIENT_SUBNET not supported\n"); + exit(1); +#endif + break; + case 'i': +#ifdef USE_IPSECMOD + printf("IPSECMOD supported\n"); + exit(0); +#else + printf("IPSECMOD not supported\n"); + exit(1); +#endif + break; + case 'p': + playback_file = optarg; + break; + case 'o': + add_opts(optarg, &pass_argc, pass_argv); + break; + case '?': + case 'h': + default: + testbound_usage(); + exit(1); + } + } + argc -= optind; + /* argv += optind; not using further arguments */ + if(argc != 0) { + testbound_usage(); + exit(1); + } + log_info("Start of %s testbound program.", PACKAGE_STRING); + if(atexit(&remove_configfile) != 0) + fatal_exit("atexit() failed: %s", strerror(errno)); + + /* reset getopt processing */ + optind = init_optind; + optarg = init_optarg; + + res = perform_playback(playback_file, pass_argc, pass_argv); + if(res == 0) { + log_info("Testbound Exit Success\n"); + /* remove configfile from here, the atexit() is for when + * there is a crash to remove the tmpdir file. + * This one removes the file while alloc and log locks are + * still valid, and can be logged (for memory calculation), + * it leaves the ptr NULL so the atexit does nothing. */ + remove_configfile(); + if(log_get_lock()) { + lock_basic_destroy((lock_basic_type*)log_get_lock()); + } +#ifdef HAVE_PTHREAD + /* dlopen frees its thread state (dlopen of gost engine) */ + pthread_exit(NULL); +#endif + } + return res; +} + +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION +static int delete_file(const char *pathname) { + int ret = unlink(pathname); + free((void *)pathname); + return ret; +} + +static char *buf_to_file(const uint8_t *buf, size_t size) { + int fd; + size_t pos; + char *pathname = strdup("/tmp/fuzz-XXXXXX"); + if (pathname == NULL) + return NULL; + + fd = mkstemp(pathname); + if (fd == -1) { + log_err("mkstemp of file %s failed: %s", pathname, strerror(errno)); + free(pathname); + return NULL; + } + pos = 0; + while (pos < size) { + int nbytes = write(fd, &buf[pos], size - pos); + if (nbytes <= 0) { + if (nbytes == -1 && errno == EINTR) + continue; + log_err("write to file %s failed: %s", pathname, strerror(errno)); + goto err; + } + pos += nbytes; + } + + if (close(fd) == -1) { + log_err("close of file %s failed: %s", pathname, strerror(errno)); + goto err; + } + + return pathname; +err: + delete_file(pathname); + return NULL; +} + +/* based on main() above, but with: hard-coded passed args, file created from fuzz input */ +int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) +{ + int c, res; + int pass_argc = 0; + char* pass_argv[MAXARG]; + char* playback_file = NULL; + + /* we do not want the test to depend on the timezone */ + (void)putenv("TZ=UTC"); + memset(pass_argv, 0, sizeof(pass_argv)); +#ifdef HAVE_SYSTEMD + /* we do not want the test to use systemd daemon startup notification*/ + (void)unsetenv("NOTIFY_SOCKET"); +#endif /* HAVE_SYSTEMD */ + + checklock_start(); + log_init(NULL, 0, NULL); + /* determine commandline options for the daemon */ + pass_argc = 1; + pass_argv[0] = "unbound"; + add_opts("-d", &pass_argc, pass_argv); + + playback_file = buf_to_file(Data, Size); + if (playback_file) { + log_info("Start of %s testbound program.", PACKAGE_STRING); + + res = perform_playback(playback_file, pass_argc, pass_argv); + if(res == 0) { + log_info("Testbound Exit Success\n"); + /* remove configfile from here, the atexit() is for when + * there is a crash to remove the tmpdir file. + * This one removes the file while alloc and log locks are + * still valid, and can be logged (for memory calculation), + * it leaves the ptr NULL so the atexit does nothing. */ + remove_configfile(); +#ifdef HAVE_PTHREAD + /* dlopen frees its thread state (dlopen of gost engine) */ + pthread_exit(NULL); +#endif + } + + delete_file(playback_file); + } + + if(log_get_lock()) { + lock_basic_destroy((lock_basic_type*)log_get_lock()); + } + return res; +} +#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */ + +/* fake remote control */ +struct listen_port* daemon_remote_open_ports(struct config_file* + ATTR_UNUSED(cfg)) +{ + return NULL; +} + +struct daemon_remote* daemon_remote_create(struct config_file* ATTR_UNUSED(cfg)) +{ + return (struct daemon_remote*)calloc(1, sizeof(struct daemon_remote)); +} + +void daemon_remote_delete(struct daemon_remote* rc) +{ + free(rc); +} + +void daemon_remote_clear(struct daemon_remote* ATTR_UNUSED(rc)) +{ + /* nothing */ +} + +int daemon_remote_open_accept(struct daemon_remote* ATTR_UNUSED(rc), + struct listen_port* ATTR_UNUSED(ports), struct worker* worker) +{ + struct replay_runtime* runtime = (struct replay_runtime*)worker->base; + runtime->daemon = worker->daemon; + return 1; +} + +int remote_accept_callback(struct comm_point* ATTR_UNUSED(c), + void* ATTR_UNUSED(arg), int ATTR_UNUSED(error), + struct comm_reply* ATTR_UNUSED(repinfo)) +{ + log_assert(0); + return 0; +} + +int remote_control_callback(struct comm_point* ATTR_UNUSED(c), + void* ATTR_UNUSED(arg), int ATTR_UNUSED(error), + struct comm_reply* ATTR_UNUSED(repinfo)) +{ + log_assert(0); + return 0; +} + +void remote_get_opt_ssl(char* ATTR_UNUSED(str), void* ATTR_UNUSED(arg)) +{ + log_assert(0); +} + +#ifdef UB_ON_WINDOWS +void wsvc_command_option(const char* ATTR_UNUSED(wopt), + const char* ATTR_UNUSED(cfgfile), int ATTR_UNUSED(v), + int ATTR_UNUSED(c)) +{ + log_assert(0); +} +#endif + +#ifdef UB_ON_WINDOWS +void wsvc_setup_worker(struct worker* ATTR_UNUSED(worker)) +{ + /* do nothing */ +} +#endif + +#ifdef UB_ON_WINDOWS +void wsvc_desetup_worker(struct worker* ATTR_UNUSED(worker)) +{ + /* do nothing */ +} +#endif + +#ifdef UB_ON_WINDOWS +void worker_win_stop_cb(int ATTR_UNUSED(fd), short ATTR_UNUSED(ev), + void* ATTR_UNUSED(arg)) +{ + log_assert(0); +} + +void wsvc_cron_cb(void* ATTR_UNUSED(arg)) +{ + log_assert(0); +} +#endif /* UB_ON_WINDOWS */ + +int tcp_connect_errno_needs_log(struct sockaddr* ATTR_UNUSED(addr), + socklen_t ATTR_UNUSED(addrlen)) +{ + return 1; +} + +int squelch_err_ssl_handshake(unsigned long ATTR_UNUSED(err)) +{ + return 0; +} + +void listen_setup_locks(void) +{ + /* nothing */ +} + +void listen_desetup_locks(void) +{ + /* nothing */ +} + +void fast_reload_printq_list_delete( + struct fast_reload_printq* ATTR_UNUSED(list)) +{ + /* nothing */ +} + +void fast_reload_worker_pickup_changes(struct worker* ATTR_UNUSED(worker)) +{ + /* nothing */ +} + +#ifdef HAVE_NGTCP2 +void* quic_sslctx_create(char* ATTR_UNUSED(key), char* ATTR_UNUSED(pem), + char* ATTR_UNUSED(verifypem)) +{ + return NULL; +} + +void comm_point_doq_callback(int ATTR_UNUSED(fd), short ATTR_UNUSED(event), + void* ATTR_UNUSED(arg)) +{ + /* nothing */ +} + +int doq_conn_cmp(const void* ATTR_UNUSED(key1), const void* ATTR_UNUSED(key2)) +{ + return 0; +} + +int doq_conid_cmp(const void* ATTR_UNUSED(key1), const void* ATTR_UNUSED(key2)) +{ + return 0; +} + +int doq_timer_cmp(const void* ATTR_UNUSED(key1), const void* ATTR_UNUSED(key2)) +{ + return 0; +} + +int doq_stream_cmp(const void* ATTR_UNUSED(key1), const void* ATTR_UNUSED(key2)) +{ + return 0; +} + +struct doq_table* doq_table_create(struct config_file* ATTR_UNUSED(cfg), + struct ub_randstate* ATTR_UNUSED(rnd)) +{ + return calloc(1, sizeof(struct doq_table)); +} + +void doq_table_delete(struct doq_table* table) +{ + free(table); +} + +void doq_timer_cb(void* ATTR_UNUSED(arg)) +{ + /* nothing */ +} + +size_t doq_table_quic_size_get(struct doq_table* ATTR_UNUSED(table)) +{ + return 0; +} +#endif |