mirror of
https://git.wownero.com/wownero/wownero.git
synced 2024-08-15 01:03:23 +00:00
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).
470 lines
12 KiB
C
470 lines
12 KiB
C
/*
|
|
* 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 "testcode/testpkts.h"
|
|
#include "testcode/replay.h"
|
|
#include "testcode/fake_event.h"
|
|
#include "daemon/remote.h"
|
|
#include "util/config_file.h"
|
|
#include "sldns/keyraw.h"
|
|
#include <ctype.h>
|
|
|
|
/** signal that this is a testbound compile */
|
|
#define unbound_testbound 1
|
|
/**
|
|
* 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("-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 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);
|
|
id[strlen(id)-1]=0; /* remove newline */
|
|
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, "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, "CONFIG_END", 10) == 0) {
|
|
fclose(cfg);
|
|
return;
|
|
}
|
|
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 */
|
|
void remove_configfile(void)
|
|
{
|
|
struct config_strlist* p;
|
|
for(p=cfgfiles; p; p=p->next)
|
|
unlink(p->str);
|
|
config_delstrlist(cfgfiles);
|
|
cfgfiles = NULL;
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
struct replay_scenario* scen = NULL;
|
|
|
|
/* we do not want the test to depend on the timezone */
|
|
(void)putenv("TZ=UTC");
|
|
|
|
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, "12egho:p:s")) != -1) {
|
|
switch(c) {
|
|
case 's':
|
|
free(pass_argv[1]);
|
|
testbound_selftest();
|
|
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 'p':
|
|
playback_file = optarg;
|
|
break;
|
|
case 'o':
|
|
add_opts(optarg, &pass_argc, pass_argv);
|
|
break;
|
|
case '?':
|
|
case 'h':
|
|
default:
|
|
testbound_usage();
|
|
return 1;
|
|
}
|
|
}
|
|
argc -= optind;
|
|
argv += optind;
|
|
if(argc != 0) {
|
|
testbound_usage();
|
|
return 1;
|
|
}
|
|
log_info("Start of %s testbound program.", PACKAGE_STRING);
|
|
if(atexit(&remove_configfile) != 0)
|
|
fatal_exit("atexit() failed: %s", strerror(errno));
|
|
|
|
/* 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);
|
|
|
|
/* reset getopt processing */
|
|
optind = init_optind;
|
|
optarg = init_optarg;
|
|
|
|
/* 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]);
|
|
if(res == 0) {
|
|
log_info("Testbound Exit Success");
|
|
#ifdef HAVE_PTHREAD
|
|
/* dlopen frees its thread state (dlopen of gost engine) */
|
|
pthread_exit(NULL);
|
|
#endif
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/* 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,1);
|
|
}
|
|
|
|
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* ATTR_UNUSED(worker))
|
|
{
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
void wsvc_setup_worker(struct worker* ATTR_UNUSED(worker))
|
|
{
|
|
/* do nothing */
|
|
}
|
|
|
|
void wsvc_desetup_worker(struct worker* ATTR_UNUSED(worker))
|
|
{
|
|
/* do nothing */
|
|
}
|
|
|
|
#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 */
|
|
|