1 /* 2 * testcode/testbound.c - test program for unbound. 3 * 4 * Copyright (c) 2007, NLnet Labs. All rights reserved. 5 * 6 * This software is open source. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * Neither the name of the NLNET LABS nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 * 35 */ 36 /** 37 * \file 38 * Exits with code 1 on a failure. 0 if all unit tests are successful. 39 */ 40 41 #include "config.h" 42 #ifdef HAVE_TIME_H 43 # include <time.h> 44 #endif 45 #include "testcode/testpkts.h" 46 #include "testcode/replay.h" 47 #include "testcode/fake_event.h" 48 #include "daemon/remote.h" 49 #include "util/config_file.h" 50 #include "sldns/keyraw.h" 51 #include <ctype.h> 52 53 /** signal that this is a testbound compile */ 54 #define unbound_testbound 1 55 /** 56 * include the main program from the unbound daemon. 57 * rename main to daemon_main to call it 58 */ 59 #define main daemon_main 60 #include "daemon/unbound.c" 61 #undef main 62 63 /** maximum line length for lines in the replay file. */ 64 #define MAX_LINE_LEN 1024 65 /** config files (removed at exit) */ 66 static struct config_strlist* cfgfiles = NULL; 67 68 #ifdef UNBOUND_ALLOC_STATS 69 # define strdup(s) unbound_stat_strdup_log(s, __FILE__, __LINE__, __func__) 70 char* unbound_stat_strdup_log(char* s, const char* file, int line, 71 const char* func); 72 char* unbound_stat_strdup_log(char* s, const char* file, int line, 73 const char* func) { 74 char* result; 75 size_t len; 76 if(!s) return NULL; 77 len = strlen(s); 78 log_info("%s:%d %s strdup(%u)", file, line, func, (unsigned)len+1); 79 result = unbound_stat_malloc(len+1); 80 memmove(result, s, len+1); 81 return result; 82 } 83 #endif /* UNBOUND_ALLOC_STATS */ 84 85 /** give commandline usage for testbound. */ 86 static void 87 testbound_usage(void) 88 { 89 printf("usage: testbound [options]\n"); 90 printf("\ttest the unbound daemon.\n"); 91 printf("-h this help\n"); 92 printf("-p file playback text file\n"); 93 printf("-1 detect SHA1 support (exit code 0 or 1)\n"); 94 printf("-2 detect SHA256 support (exit code 0 or 1)\n"); 95 printf("-g detect GOST support (exit code 0 or 1)\n"); 96 printf("-e detect ECDSA support (exit code 0 or 1)\n"); 97 printf("-c detect CLIENT_SUBNET support (exit code 0 or 1)\n"); 98 printf("-i detect IPSECMOD support (exit code 0 or 1)\n"); 99 printf("-s testbound self-test - unit test of testbound parts.\n"); 100 printf("-o str unbound commandline options separated by spaces.\n"); 101 printf("Version %s\n", PACKAGE_VERSION); 102 printf("BSD licensed, see LICENSE file in source package.\n"); 103 printf("Report bugs to %s.\n", PACKAGE_BUGREPORT); 104 } 105 106 /** Max number of arguments to pass to unbound. */ 107 #define MAXARG 100 108 109 /** 110 * Add options from string to passed argc. splits on whitespace. 111 * @param args: the option argument, "-v -p 12345" or so. 112 * @param pass_argc: ptr to the argc for unbound. Modified. 113 * @param pass_argv: the argv to pass to unbound. Modified. 114 */ 115 static void 116 add_opts(const char* args, int* pass_argc, char* pass_argv[]) 117 { 118 const char *p = args, *np; 119 size_t len; 120 while(p && isspace((unsigned char)*p)) 121 p++; 122 while(p && *p) { 123 /* find location of next string and length of this one */ 124 if((np = strchr(p, ' '))) 125 len = (size_t)(np-p); 126 else len = strlen(p); 127 /* allocate and copy option */ 128 if(*pass_argc >= MAXARG-1) 129 fatal_exit("too many arguments: '%s'", p); 130 pass_argv[*pass_argc] = (char*)malloc(len+1); 131 if(!pass_argv[*pass_argc]) 132 fatal_exit("add_opts: out of memory"); 133 memcpy(pass_argv[*pass_argc], p, len); 134 pass_argv[*pass_argc][len] = 0; 135 (*pass_argc)++; 136 /* go to next option */ 137 p = np; 138 while(p && isspace((unsigned char)*p)) 139 p++; 140 } 141 } 142 143 /** pretty print commandline for unbound in this test */ 144 static void 145 echo_cmdline(int argc, char* argv[]) 146 { 147 int i; 148 fprintf(stderr, "testbound is starting:"); 149 for(i=0; i<argc; i++) { 150 fprintf(stderr, " [%s]", argv[i]); 151 } 152 fprintf(stderr, "\n"); 153 } 154 155 /** spool temp file name */ 156 static void 157 spool_temp_file_name(int* lineno, FILE* cfg, char* id) 158 { 159 char line[MAX_LINE_LEN]; 160 /* find filename for new file */ 161 while(isspace((unsigned char)*id)) 162 id++; 163 if(*id == '\0') 164 fatal_exit("TEMPFILE_NAME must have id, line %d", *lineno); 165 id[strlen(id)-1]=0; /* remove newline */ 166 fake_temp_file("_temp_", id, line, sizeof(line)); 167 fprintf(cfg, "\"%s\"\n", line); 168 } 169 170 /** spool temp file */ 171 static void 172 spool_temp_file(FILE* in, int* lineno, char* id) 173 { 174 char line[MAX_LINE_LEN]; 175 char* parse; 176 FILE* spool; 177 /* find filename for new file */ 178 while(isspace((unsigned char)*id)) 179 id++; 180 if(*id == '\0') 181 fatal_exit("TEMPFILE_CONTENTS must have id, line %d", *lineno); 182 id[strlen(id)-1]=0; /* remove newline */ 183 fake_temp_file("_temp_", id, line, sizeof(line)); 184 /* open file and spool to it */ 185 spool = fopen(line, "w"); 186 if(!spool) fatal_exit("could not open %s: %s", line, strerror(errno)); 187 fprintf(stderr, "testbound is spooling temp file: %s\n", line); 188 if(!cfg_strlist_insert(&cfgfiles, strdup(line))) 189 fatal_exit("out of memory"); 190 line[sizeof(line)-1] = 0; 191 while(fgets(line, MAX_LINE_LEN-1, in)) { 192 parse = line; 193 (*lineno)++; 194 while(isspace((unsigned char)*parse)) 195 parse++; 196 if(strncmp(parse, "$INCLUDE_TEMPFILE", 17) == 0) { 197 char l2[MAX_LINE_LEN-30]; /* -30 makes it fit with 198 a preceding $INCLUDE in the buf line[] */ 199 char* tid = parse+17; 200 while(isspace((unsigned char)*tid)) 201 tid++; 202 tid[strlen(tid)-1]=0; /* remove newline */ 203 fake_temp_file("_temp_", tid, l2, sizeof(l2)); 204 snprintf(line, sizeof(line), "$INCLUDE %s\n", l2); 205 } 206 if(strncmp(parse, "TEMPFILE_END", 12) == 0) { 207 fclose(spool); 208 return; 209 } 210 fputs(line, spool); 211 } 212 fatal_exit("no TEMPFILE_END in input file"); 213 } 214 215 /** spool autotrust file */ 216 static void 217 spool_auto_file(FILE* in, int* lineno, FILE* cfg, char* id) 218 { 219 char line[MAX_LINE_LEN]; 220 char* parse; 221 FILE* spool; 222 /* find filename for new file */ 223 while(isspace((unsigned char)*id)) 224 id++; 225 if(*id == '\0') 226 fatal_exit("AUTROTRUST_FILE must have id, line %d", *lineno); 227 id[strlen(id)-1]=0; /* remove newline */ 228 fake_temp_file("_auto_", id, line, sizeof(line)); 229 /* add option for the file */ 230 fprintf(cfg, "server: auto-trust-anchor-file: \"%s\"\n", line); 231 /* open file and spool to it */ 232 spool = fopen(line, "w"); 233 if(!spool) fatal_exit("could not open %s: %s", line, strerror(errno)); 234 fprintf(stderr, "testbound is spooling key file: %s\n", line); 235 if(!cfg_strlist_insert(&cfgfiles, strdup(line))) 236 fatal_exit("out of memory"); 237 line[sizeof(line)-1] = 0; 238 while(fgets(line, MAX_LINE_LEN-1, in)) { 239 parse = line; 240 (*lineno)++; 241 while(isspace((unsigned char)*parse)) 242 parse++; 243 if(strncmp(parse, "AUTOTRUST_END", 13) == 0) { 244 fclose(spool); 245 return; 246 } 247 fputs(line, spool); 248 } 249 fatal_exit("no AUTOTRUST_END in input file"); 250 } 251 252 /** process config elements */ 253 static void 254 setup_config(FILE* in, int* lineno, int* pass_argc, char* pass_argv[]) 255 { 256 char configfile[MAX_LINE_LEN]; 257 char line[MAX_LINE_LEN]; 258 char* parse; 259 FILE* cfg; 260 fake_temp_file("_cfg", "", configfile, sizeof(configfile)); 261 add_opts("-c", pass_argc, pass_argv); 262 add_opts(configfile, pass_argc, pass_argv); 263 cfg = fopen(configfile, "w"); 264 if(!cfg) fatal_exit("could not open %s: %s", 265 configfile, strerror(errno)); 266 if(!cfg_strlist_insert(&cfgfiles, strdup(configfile))) 267 fatal_exit("out of memory"); 268 line[sizeof(line)-1] = 0; 269 /* some basic settings to not pollute the host system */ 270 fprintf(cfg, "server: use-syslog: no\n"); 271 fprintf(cfg, " directory: \"\"\n"); 272 fprintf(cfg, " chroot: \"\"\n"); 273 fprintf(cfg, " username: \"\"\n"); 274 fprintf(cfg, " pidfile: \"\"\n"); 275 fprintf(cfg, " val-log-level: 2\n"); 276 fprintf(cfg, "remote-control: control-enable: no\n"); 277 while(fgets(line, MAX_LINE_LEN-1, in)) { 278 parse = line; 279 (*lineno)++; 280 while(isspace((unsigned char)*parse)) 281 parse++; 282 if(!*parse || parse[0] == ';') 283 continue; 284 if(strncmp(parse, "COMMANDLINE", 11) == 0) { 285 parse[strlen(parse)-1] = 0; /* strip off \n */ 286 add_opts(parse+11, pass_argc, pass_argv); 287 continue; 288 } 289 if(strncmp(parse, "AUTOTRUST_FILE", 14) == 0) { 290 spool_auto_file(in, lineno, cfg, parse+14); 291 continue; 292 } 293 if(strncmp(parse, "TEMPFILE_NAME", 13) == 0) { 294 spool_temp_file_name(lineno, cfg, parse+13); 295 continue; 296 } 297 if(strncmp(parse, "TEMPFILE_CONTENTS", 17) == 0) { 298 spool_temp_file(in, lineno, parse+17); 299 continue; 300 } 301 if(strncmp(parse, "CONFIG_END", 10) == 0) { 302 fclose(cfg); 303 return; 304 } 305 fputs(line, cfg); 306 } 307 fatal_exit("No CONFIG_END in input file"); 308 309 } 310 311 /** read playback file */ 312 static struct replay_scenario* 313 setup_playback(const char* filename, int* pass_argc, char* pass_argv[]) 314 { 315 struct replay_scenario* scen = NULL; 316 int lineno = 0; 317 318 if(filename) { 319 FILE *in = fopen(filename, "rb"); 320 if(!in) { 321 perror(filename); 322 exit(1); 323 } 324 setup_config(in, &lineno, pass_argc, pass_argv); 325 scen = replay_scenario_read(in, filename, &lineno); 326 fclose(in); 327 if(!scen) 328 fatal_exit("Could not read: %s", filename); 329 } 330 else fatal_exit("need a playback file (-p)"); 331 log_info("Scenario: %s", scen->title); 332 return scen; 333 } 334 335 /** remove config file at exit */ 336 void remove_configfile(void) 337 { 338 struct config_strlist* p; 339 for(p=cfgfiles; p; p=p->next) 340 unlink(p->str); 341 config_delstrlist(cfgfiles); 342 cfgfiles = NULL; 343 } 344 345 /** 346 * Main fake event test program. Setup, teardown and report errors. 347 * @param argc: arg count. 348 * @param argv: array of commandline arguments. 349 * @return program failure if test fails. 350 */ 351 int 352 main(int argc, char* argv[]) 353 { 354 int c, res; 355 int pass_argc = 0; 356 char* pass_argv[MAXARG]; 357 char* playback_file = NULL; 358 int init_optind = optind; 359 char* init_optarg = optarg; 360 struct replay_scenario* scen = NULL; 361 362 /* we do not want the test to depend on the timezone */ 363 (void)putenv("TZ=UTC"); 364 memset(pass_argv, 0, sizeof(pass_argv)); 365 #ifdef HAVE_SYSTEMD 366 /* we do not want the test to use systemd daemon startup notification*/ 367 (void)unsetenv("NOTIFY_SOCKET"); 368 #endif /* HAVE_SYSTEMD */ 369 370 log_init(NULL, 0, NULL); 371 /* determine commandline options for the daemon */ 372 pass_argc = 1; 373 pass_argv[0] = "unbound"; 374 add_opts("-d", &pass_argc, pass_argv); 375 while( (c=getopt(argc, argv, "12egciho:p:s")) != -1) { 376 switch(c) { 377 case 's': 378 free(pass_argv[1]); 379 testbound_selftest(); 380 checklock_stop(); 381 if(log_get_lock()) { 382 lock_basic_destroy((lock_basic_type*)log_get_lock()); 383 } 384 exit(0); 385 case '1': 386 #ifdef USE_SHA1 387 printf("SHA1 supported\n"); 388 exit(0); 389 #else 390 printf("SHA1 not supported\n"); 391 exit(1); 392 #endif 393 break; 394 case '2': 395 #if (defined(HAVE_EVP_SHA256) || defined(HAVE_NSS) || defined(HAVE_NETTLE)) && defined(USE_SHA2) 396 printf("SHA256 supported\n"); 397 exit(0); 398 #else 399 printf("SHA256 not supported\n"); 400 exit(1); 401 #endif 402 break; 403 case 'e': 404 #if defined(USE_ECDSA) 405 printf("ECDSA supported\n"); 406 exit(0); 407 #else 408 printf("ECDSA not supported\n"); 409 exit(1); 410 #endif 411 break; 412 case 'g': 413 #ifdef USE_GOST 414 if(sldns_key_EVP_load_gost_id()) { 415 printf("GOST supported\n"); 416 exit(0); 417 } else { 418 printf("GOST not supported\n"); 419 exit(1); 420 } 421 #else 422 printf("GOST not supported\n"); 423 exit(1); 424 #endif 425 break; 426 case 'c': 427 #ifdef CLIENT_SUBNET 428 printf("CLIENT_SUBNET supported\n"); 429 exit(0); 430 #else 431 printf("CLIENT_SUBNET not supported\n"); 432 exit(1); 433 #endif 434 break; 435 case 'i': 436 #ifdef USE_IPSECMOD 437 printf("IPSECMOD supported\n"); 438 exit(0); 439 #else 440 printf("IPSECMOD not supported\n"); 441 exit(1); 442 #endif 443 break; 444 case 'p': 445 playback_file = optarg; 446 break; 447 case 'o': 448 add_opts(optarg, &pass_argc, pass_argv); 449 break; 450 case '?': 451 case 'h': 452 default: 453 testbound_usage(); 454 exit(1); 455 } 456 } 457 argc -= optind; 458 /* argv += optind; not using further arguments */ 459 if(argc != 0) { 460 testbound_usage(); 461 exit(1); 462 } 463 log_info("Start of %s testbound program.", PACKAGE_STRING); 464 if(atexit(&remove_configfile) != 0) 465 fatal_exit("atexit() failed: %s", strerror(errno)); 466 467 /* setup test environment */ 468 scen = setup_playback(playback_file, &pass_argc, pass_argv); 469 /* init fake event backend */ 470 fake_event_init(scen); 471 472 pass_argv[pass_argc] = NULL; 473 echo_cmdline(pass_argc, pass_argv); 474 475 /* reset getopt processing */ 476 optind = init_optind; 477 optarg = init_optarg; 478 479 /* run the normal daemon */ 480 res = daemon_main(pass_argc, pass_argv); 481 482 fake_event_cleanup(); 483 for(c=1; c<pass_argc; c++) 484 free(pass_argv[c]); 485 if(res == 0) { 486 log_info("Testbound Exit Success\n"); 487 /* remove configfile from here, the atexit() is for when 488 * there is a crash to remove the tmpdir file. 489 * This one removes the file while alloc and log locks are 490 * still valid, and can be logged (for memory calculation), 491 * it leaves the ptr NULL so the atexit does nothing. */ 492 remove_configfile(); 493 if(log_get_lock()) { 494 lock_basic_destroy((lock_basic_type*)log_get_lock()); 495 } 496 #ifdef HAVE_PTHREAD 497 /* dlopen frees its thread state (dlopen of gost engine) */ 498 pthread_exit(NULL); 499 #endif 500 } 501 return res; 502 } 503 504 /* fake remote control */ 505 struct listen_port* daemon_remote_open_ports(struct config_file* 506 ATTR_UNUSED(cfg)) 507 { 508 return NULL; 509 } 510 511 struct daemon_remote* daemon_remote_create(struct config_file* ATTR_UNUSED(cfg)) 512 { 513 return (struct daemon_remote*)calloc(1,1); 514 } 515 516 void daemon_remote_delete(struct daemon_remote* rc) 517 { 518 free(rc); 519 } 520 521 void daemon_remote_clear(struct daemon_remote* ATTR_UNUSED(rc)) 522 { 523 /* nothing */ 524 } 525 526 int daemon_remote_open_accept(struct daemon_remote* ATTR_UNUSED(rc), 527 struct listen_port* ATTR_UNUSED(ports), 528 struct worker* ATTR_UNUSED(worker)) 529 { 530 return 1; 531 } 532 533 int remote_accept_callback(struct comm_point* ATTR_UNUSED(c), 534 void* ATTR_UNUSED(arg), int ATTR_UNUSED(error), 535 struct comm_reply* ATTR_UNUSED(repinfo)) 536 { 537 log_assert(0); 538 return 0; 539 } 540 541 int remote_control_callback(struct comm_point* ATTR_UNUSED(c), 542 void* ATTR_UNUSED(arg), int ATTR_UNUSED(error), 543 struct comm_reply* ATTR_UNUSED(repinfo)) 544 { 545 log_assert(0); 546 return 0; 547 } 548 549 void remote_get_opt_ssl(char* ATTR_UNUSED(str), void* ATTR_UNUSED(arg)) 550 { 551 log_assert(0); 552 } 553 554 void wsvc_command_option(const char* ATTR_UNUSED(wopt), 555 const char* ATTR_UNUSED(cfgfile), int ATTR_UNUSED(v), 556 int ATTR_UNUSED(c)) 557 { 558 log_assert(0); 559 } 560 561 void wsvc_setup_worker(struct worker* ATTR_UNUSED(worker)) 562 { 563 /* do nothing */ 564 } 565 566 void wsvc_desetup_worker(struct worker* ATTR_UNUSED(worker)) 567 { 568 /* do nothing */ 569 } 570 571 #ifdef UB_ON_WINDOWS 572 void worker_win_stop_cb(int ATTR_UNUSED(fd), short ATTR_UNUSED(ev), 573 void* ATTR_UNUSED(arg)) 574 { 575 log_assert(0); 576 } 577 578 void wsvc_cron_cb(void* ATTR_UNUSED(arg)) 579 { 580 log_assert(0); 581 } 582 #endif /* UB_ON_WINDOWS */ 583 584 int tcp_connect_errno_needs_log(struct sockaddr* ATTR_UNUSED(addr), 585 socklen_t ATTR_UNUSED(addrlen)) 586 { 587 return 1; 588 } 589 590 int squelch_err_ssl_handshake(unsigned long ATTR_UNUSED(err)) 591 { 592 return 0; 593 } 594