1 /* 2 * checkconf - Read and repeat configuration file to output. 3 * 4 * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. 5 * 6 * See LICENSE for the license. 7 * 8 */ 9 #include "config.h" 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <unistd.h> 13 #include <string.h> 14 #include <limits.h> 15 #include "tsig.h" 16 #include "options.h" 17 #include "util.h" 18 #include "dname.h" 19 #include "rrl.h" 20 21 extern char *optarg; 22 extern int optind; 23 24 #define ZONE_GET_ACL(NAME, VAR, PATTERN) \ 25 if (strcasecmp(#NAME, (VAR)) == 0) { \ 26 quote_acl(PATTERN->NAME); \ 27 return; \ 28 } 29 30 #define ZONE_GET_OUTGOING(NAME, VAR, PATTERN) \ 31 if (strcasecmp(#NAME, (VAR)) == 0) { \ 32 acl_options_t* acl; \ 33 for(acl=PATTERN->NAME; acl; acl=acl->next) \ 34 quote(acl->ip_address_spec); \ 35 return; \ 36 } 37 38 #define ZONE_GET_STR(NAME, VAR, PATTERN) \ 39 if (strcasecmp(#NAME, (VAR)) == 0) { \ 40 quote(PATTERN->NAME); \ 41 return; \ 42 } 43 44 #define ZONE_GET_PATH(FINAL, NAME, VAR, PATTERN) \ 45 if (strcasecmp(#NAME, (VAR)) == 0) { \ 46 quotepath(opt, FINAL, PATTERN->NAME); \ 47 return; \ 48 } 49 50 #define ZONE_GET_BIN(NAME, VAR, PATTERN) \ 51 if (strcasecmp(#NAME, (VAR)) == 0) { \ 52 printf("%s\n", (PATTERN->NAME)?"yes":"no"); \ 53 return; \ 54 } 55 56 #define ZONE_GET_RRL(NAME, VAR, PATTERN) \ 57 if (strcasecmp(#NAME, (VAR)) == 0) { \ 58 zone_print_rrl_whitelist("", PATTERN->NAME); \ 59 return; \ 60 } 61 62 #define ZONE_GET_INT(NAME, VAR, PATTERN) \ 63 if (strcasecmp(#NAME, (VAR)) == 0) { \ 64 printf("%d\n", (int) PATTERN->NAME); \ 65 return; \ 66 } 67 68 #define SERV_GET_BIN(NAME, VAR) \ 69 if (strcasecmp(#NAME, (VAR)) == 0) { \ 70 printf("%s\n", opt->NAME?"yes":"no"); \ 71 return; \ 72 } 73 74 #define SERV_GET_STR(NAME, VAR) \ 75 if (strcasecmp(#NAME, (VAR)) == 0) { \ 76 quote(opt->NAME); \ 77 return; \ 78 } 79 80 #define SERV_GET_PATH(FINAL, NAME, VAR) \ 81 if (strcasecmp(#NAME, (VAR)) == 0) { \ 82 quotepath(opt, FINAL, opt->NAME); \ 83 return; \ 84 } 85 86 #define SERV_GET_INT(NAME, VAR) \ 87 if (strcasecmp(#NAME, (VAR)) == 0) { \ 88 printf("%d\n", (int) opt->NAME); \ 89 return; \ 90 } 91 92 #define SERV_GET_IP(NAME, MEMBER, VAR) \ 93 if (strcasecmp(#NAME, (VAR)) == 0) { \ 94 for(ip = opt->MEMBER; ip; ip=ip->next) \ 95 { \ 96 quote(ip->address); \ 97 } \ 98 return; \ 99 } 100 101 #ifdef RATELIMIT 102 static void zone_print_rrl_whitelist(const char* s, uint16_t w) 103 { 104 int i; 105 if(w==rrl_type_all) { 106 printf("%sall\n", s); 107 return; 108 } 109 for(i=0x01; i <= 0x80; i<<=1) { 110 if( (w&i) ) 111 printf("%s%s\n", s, rrltype2str(i)); 112 } 113 } 114 #endif /* RATELIMIT */ 115 116 static char buf[BUFSIZ]; 117 118 static char * 119 underscore(const char *s) { 120 const char *j = s; 121 size_t i = 0; 122 123 while(j && *j) { 124 if (*j == '-') { 125 buf[i++] = '_'; 126 } else { 127 buf[i++] = *j; 128 } 129 j++; 130 if (i >= BUFSIZ) { 131 return NULL; 132 } 133 } 134 buf[i] = '\0'; 135 return buf; 136 } 137 138 static void 139 usage(void) 140 { 141 fprintf(stderr, "usage: nsd-checkconf [-v|-h] [-o option] [-z zonename]\n"); 142 fprintf(stderr, " [-s keyname] <configfilename>\n"); 143 fprintf(stderr, " Checks NSD configuration file for errors.\n"); 144 fprintf(stderr, " Version %s. Report bugs to <%s>.\n\n", 145 PACKAGE_VERSION, PACKAGE_BUGREPORT); 146 fprintf(stderr, "Use with a configfile as argument to check syntax.\n"); 147 fprintf(stderr, "Use with -o, -z or -s options to query the configuration.\n\n"); 148 fprintf(stderr, "-v Verbose, echo settings that take effect to std output.\n"); 149 fprintf(stderr, "-h Print this help information.\n"); 150 fprintf(stderr, "-f Use with -o to print final pathnames, ie. with chroot.\n"); 151 fprintf(stderr, "-o option Print value of the option specified to stdout.\n"); 152 fprintf(stderr, "-p pattern Print option value for the pattern given.\n"); 153 fprintf(stderr, "-z zonename Print option value for the zone given.\n"); 154 fprintf(stderr, "-a keyname Print algorithm name for the TSIG key.\n"); 155 fprintf(stderr, "-s keyname Print base64 secret blob for the TSIG key.\n"); 156 exit(1); 157 } 158 159 static void 160 print_string_var(const char* varname, const char* value) 161 { 162 if (!value) { 163 printf("\t#%s\n", varname); 164 } else { 165 printf("\t%s \"%s\"\n", varname, value); 166 } 167 } 168 169 static void 170 quote(const char *v) 171 { 172 if(v==NULL) 173 printf("\n"); 174 else 175 printf("%s\n", v); 176 } 177 178 static void 179 quotepath(nsd_options_t* opt, int final, const char *f) 180 { 181 const char* chr = opt->chroot; 182 #ifdef CHROOTDIR 183 if(chr == 0) chr = CHROOTDIR; 184 #endif 185 if(f == 0 || f[0] == '/' || !final || !chr || chr[0]==0) { 186 quote(f); 187 return; 188 } 189 /* chroot has had trailing slash applied in check part of checkconf */ 190 printf("%s%s\n", chr, f); 191 } 192 193 static void 194 quote_acl(acl_options_t* acl) 195 { 196 while(acl) 197 { 198 printf("%s %s\n", acl->ip_address_spec, 199 acl->nokey?"NOKEY":(acl->blocked?"BLOCKED": 200 (acl->key_name?acl->key_name:"(null)"))); 201 acl=acl->next; 202 } 203 } 204 205 static void 206 print_acl(const char* varname, acl_options_t* acl) 207 { 208 while(acl) 209 { 210 printf("\t%s ", varname); 211 if(acl->use_axfr_only) 212 printf("AXFR "); 213 if(acl->allow_udp) 214 printf("UDP "); 215 printf("%s %s\n", acl->ip_address_spec, 216 acl->nokey?"NOKEY":(acl->blocked?"BLOCKED": 217 (acl->key_name?acl->key_name:"(null)"))); 218 if(verbosity>1) { 219 printf("\t# %s", acl->is_ipv6?"ip6":"ip4"); 220 if(acl->port == 0) printf(" noport"); 221 else printf(" port=%d", acl->port); 222 if(acl->rangetype == acl_range_single) printf(" single"); 223 if(acl->rangetype == acl_range_mask) printf(" masked"); 224 if(acl->rangetype == acl_range_subnet) printf(" subnet"); 225 if(acl->rangetype == acl_range_minmax) printf(" minmax"); 226 if(acl->is_ipv6) { 227 #ifdef INET6 228 char dest[128]; 229 inet_ntop(AF_INET6, &acl->addr.addr6, dest, sizeof(dest)); 230 printf(" addr=%s", dest); 231 if(acl->rangetype != acl_range_single) { 232 inet_ntop(AF_INET6, &acl->range_mask.addr6, dest, sizeof(dest)); 233 printf(" rangemask=%s", dest); 234 } 235 #else 236 printf(" ip6addr-noip6defined"); 237 #endif 238 } else { 239 char dest[128]; 240 inet_ntop(AF_INET, &acl->addr.addr, dest, sizeof(dest)); 241 printf(" addr=%s", dest); 242 if(acl->rangetype != acl_range_single) { 243 inet_ntop(AF_INET, &acl->range_mask.addr, dest, sizeof(dest)); 244 printf(" rangemask=%s", dest); 245 } 246 } 247 printf("\n"); 248 } 249 acl=acl->next; 250 } 251 } 252 253 static void 254 print_acl_ips(const char* varname, acl_options_t* acl) 255 { 256 while(acl) 257 { 258 printf("\t%s %s\n", varname, acl->ip_address_spec); 259 acl=acl->next; 260 } 261 } 262 263 void 264 config_print_zone(nsd_options_t* opt, const char* k, int s, const char *o, 265 const char *z, const char* pat, int final) 266 { 267 ip_address_option_t* ip; 268 269 if (k) { 270 /* find key */ 271 key_options_t* key = key_options_find(opt, k); 272 if(key) { 273 if (s) { 274 quote(key->secret); 275 } else { 276 quote(key->algorithm); 277 } 278 return; 279 } 280 printf("Could not find key %s\n", k); 281 return; 282 } 283 284 if (!o) { 285 return; 286 } 287 288 if (z) { 289 zone_options_t* zone; 290 const dname_type *dname = dname_parse(opt->region, z); 291 if(!dname) { 292 printf("Could not parse zone name %s\n", z); 293 exit(1); 294 } 295 zone = zone_options_find(opt, dname); 296 if(!zone) { 297 printf("Zone does not exist: %s\n", z); 298 exit(1); 299 } 300 ZONE_GET_STR(name, o, zone); 301 if(strcasecmp("pattern", o)==0) { 302 quote(zone->pattern->pname); 303 return; 304 } 305 ZONE_GET_BIN(part_of_config, o, zone); 306 ZONE_GET_PATH(final, zonefile, o, zone->pattern); 307 ZONE_GET_ACL(request_xfr, o, zone->pattern); 308 ZONE_GET_ACL(provide_xfr, o, zone->pattern); 309 ZONE_GET_ACL(allow_notify, o, zone->pattern); 310 ZONE_GET_ACL(notify, o, zone->pattern); 311 ZONE_GET_BIN(notify_retry, o, zone->pattern); 312 ZONE_GET_STR(zonestats, o, zone->pattern); 313 ZONE_GET_OUTGOING(outgoing_interface, o, zone->pattern); 314 ZONE_GET_BIN(allow_axfr_fallback, o, zone->pattern); 315 ZONE_GET_INT(max_refresh_time, o, zone->pattern); 316 ZONE_GET_INT(min_refresh_time, o, zone->pattern); 317 ZONE_GET_INT(max_retry_time, o, zone->pattern); 318 ZONE_GET_INT(min_retry_time, o, zone->pattern); 319 ZONE_GET_INT(size_limit_xfr, o, zone->pattern); 320 #ifdef RATELIMIT 321 ZONE_GET_RRL(rrl_whitelist, o, zone->pattern); 322 #endif 323 ZONE_GET_BIN(multi_master_check, o, zone->pattern); 324 printf("Zone option not handled: %s %s\n", z, o); 325 exit(1); 326 } else if(pat) { 327 pattern_options_t* p = pattern_options_find(opt, pat); 328 if(!p) { 329 printf("Pattern does not exist: %s\n", pat); 330 exit(1); 331 } 332 if(strcasecmp("name", o)==0) { 333 quote(p->pname); 334 return; 335 } 336 ZONE_GET_STR(zonefile, o, p); 337 ZONE_GET_PATH(final, zonefile, o, p); 338 ZONE_GET_ACL(request_xfr, o, p); 339 ZONE_GET_ACL(provide_xfr, o, p); 340 ZONE_GET_ACL(allow_notify, o, p); 341 ZONE_GET_ACL(notify, o, p); 342 ZONE_GET_BIN(notify_retry, o, p); 343 ZONE_GET_STR(zonestats, o, p); 344 ZONE_GET_OUTGOING(outgoing_interface, o, p); 345 ZONE_GET_BIN(allow_axfr_fallback, o, p); 346 ZONE_GET_INT(max_refresh_time, o, p); 347 ZONE_GET_INT(min_refresh_time, o, p); 348 ZONE_GET_INT(max_retry_time, o, p); 349 ZONE_GET_INT(min_retry_time, o, p); 350 ZONE_GET_INT(size_limit_xfr, o, p); 351 #ifdef RATELIMIT 352 ZONE_GET_RRL(rrl_whitelist, o, p); 353 #endif 354 ZONE_GET_BIN(multi_master_check, o, p); 355 printf("Pattern option not handled: %s %s\n", pat, o); 356 exit(1); 357 } else { 358 /* look in the server section */ 359 SERV_GET_IP(ip_address, ip_addresses, o); 360 /* bin */ 361 SERV_GET_BIN(ip_transparent, o); 362 SERV_GET_BIN(ip_freebind, o); 363 SERV_GET_BIN(debug_mode, o); 364 SERV_GET_BIN(do_ip4, o); 365 SERV_GET_BIN(do_ip6, o); 366 SERV_GET_BIN(reuseport, o); 367 SERV_GET_BIN(hide_version, o); 368 SERV_GET_BIN(zonefiles_check, o); 369 SERV_GET_BIN(log_time_ascii, o); 370 SERV_GET_BIN(round_robin, o); 371 /* str */ 372 SERV_GET_PATH(final, database, o); 373 SERV_GET_STR(identity, o); 374 SERV_GET_STR(version, o); 375 SERV_GET_STR(nsid, o); 376 SERV_GET_PATH(final, logfile, o); 377 SERV_GET_PATH(final, pidfile, o); 378 SERV_GET_STR(chroot, o); 379 SERV_GET_STR(username, o); 380 SERV_GET_PATH(final, zonesdir, o); 381 SERV_GET_PATH(final, xfrdfile, o); 382 SERV_GET_PATH(final, xfrdir, o); 383 SERV_GET_PATH(final, zonelistfile, o); 384 SERV_GET_STR(port, o); 385 /* int */ 386 SERV_GET_INT(server_count, o); 387 SERV_GET_INT(tcp_count, o); 388 SERV_GET_INT(tcp_query_count, o); 389 SERV_GET_INT(tcp_timeout, o); 390 SERV_GET_INT(tcp_mss, o); 391 SERV_GET_INT(outgoing_tcp_mss, o); 392 SERV_GET_INT(ipv4_edns_size, o); 393 SERV_GET_INT(ipv6_edns_size, o); 394 SERV_GET_INT(statistics, o); 395 SERV_GET_INT(xfrd_reload_timeout, o); 396 SERV_GET_INT(verbosity, o); 397 #ifdef RATELIMIT 398 SERV_GET_INT(rrl_size, o); 399 SERV_GET_INT(rrl_ratelimit, o); 400 SERV_GET_INT(rrl_slip, o); 401 SERV_GET_INT(rrl_ipv4_prefix_length, o); 402 SERV_GET_INT(rrl_ipv6_prefix_length, o); 403 SERV_GET_INT(rrl_whitelist_ratelimit, o); 404 #endif 405 SERV_GET_INT(zonefiles_write, o); 406 /* remote control */ 407 SERV_GET_BIN(control_enable, o); 408 SERV_GET_IP(control_interface, control_interface, o); 409 SERV_GET_INT(control_port, o); 410 SERV_GET_STR(server_key_file, o); 411 SERV_GET_STR(server_cert_file, o); 412 SERV_GET_STR(control_key_file, o); 413 SERV_GET_STR(control_cert_file, o); 414 415 if(strcasecmp(o, "zones") == 0) { 416 zone_options_t* zone; 417 RBTREE_FOR(zone, zone_options_t*, opt->zone_options) 418 quote(zone->name); 419 return; 420 } 421 if(strcasecmp(o, "patterns") == 0) { 422 pattern_options_t* p; 423 RBTREE_FOR(p, pattern_options_t*, opt->patterns) 424 quote(p->pname); 425 return; 426 } 427 printf("Server option not handled: %s\n", o); 428 exit(1); 429 } 430 } 431 432 /* print zone content items */ 433 static void print_zone_content_elems(pattern_options_t* pat) 434 { 435 if(pat->zonefile) 436 print_string_var("zonefile:", pat->zonefile); 437 #ifdef RATELIMIT 438 zone_print_rrl_whitelist("\trrl-whitelist: ", pat->rrl_whitelist); 439 #endif 440 print_acl("allow-notify:", pat->allow_notify); 441 print_acl("request-xfr:", pat->request_xfr); 442 if(pat->multi_master_check) 443 printf("\tmulti-master-check: %s\n", pat->multi_master_check?"yes":"no"); 444 if(!pat->notify_retry_is_default) 445 printf("\tnotify-retry: %d\n", pat->notify_retry); 446 print_acl("notify:", pat->notify); 447 print_acl("provide-xfr:", pat->provide_xfr); 448 if(pat->zonestats) 449 print_string_var("zonestats:", pat->zonestats); 450 print_acl_ips("outgoing-interface:", pat->outgoing_interface); 451 if(!pat->allow_axfr_fallback_is_default) 452 printf("\tallow-axfr-fallback: %s\n", 453 pat->allow_axfr_fallback?"yes":"no"); 454 if(!pat->max_refresh_time_is_default) 455 printf("\tmax-refresh-time: %d\n", pat->max_refresh_time); 456 if(!pat->min_refresh_time_is_default) 457 printf("\tmin-refresh-time: %d\n", pat->min_refresh_time); 458 if(!pat->max_retry_time_is_default) 459 printf("\tmax-retry-time: %d\n", pat->max_retry_time); 460 if(!pat->min_retry_time_is_default) 461 printf("\tmin-retry-time: %d\n", pat->min_retry_time); 462 if(pat->size_limit_xfr != 0) 463 printf("\tsize-limit-xfr: %llu\n", 464 (long long unsigned)pat->size_limit_xfr); 465 } 466 467 void 468 config_test_print_server(nsd_options_t* opt) 469 { 470 ip_address_option_t* ip; 471 key_options_t* key; 472 zone_options_t* zone; 473 pattern_options_t* pat; 474 475 printf("# Config settings.\n"); 476 printf("server:\n"); 477 printf("\tdebug-mode: %s\n", opt->debug_mode?"yes":"no"); 478 printf("\tip-transparent: %s\n", opt->ip_transparent?"yes":"no"); 479 printf("\tip-freebind: %s\n", opt->ip_freebind?"yes":"no"); 480 printf("\treuseport: %s\n", opt->reuseport?"yes":"no"); 481 printf("\tdo-ip4: %s\n", opt->do_ip4?"yes":"no"); 482 printf("\tdo-ip6: %s\n", opt->do_ip6?"yes":"no"); 483 printf("\thide-version: %s\n", opt->hide_version?"yes":"no"); 484 print_string_var("database:", opt->database); 485 print_string_var("identity:", opt->identity); 486 print_string_var("version:", opt->version); 487 print_string_var("nsid:", opt->nsid); 488 print_string_var("logfile:", opt->logfile); 489 printf("\tserver-count: %d\n", opt->server_count); 490 printf("\ttcp-count: %d\n", opt->tcp_count); 491 printf("\ttcp-query-count: %d\n", opt->tcp_query_count); 492 printf("\ttcp-timeout: %d\n", opt->tcp_timeout); 493 printf("\ttcp-mss: %d\n", opt->tcp_mss); 494 printf("\toutgoing-tcp-mss: %d\n", opt->outgoing_tcp_mss); 495 printf("\tipv4-edns-size: %d\n", (int) opt->ipv4_edns_size); 496 printf("\tipv6-edns-size: %d\n", (int) opt->ipv6_edns_size); 497 print_string_var("pidfile:", opt->pidfile); 498 print_string_var("port:", opt->port); 499 printf("\tstatistics: %d\n", opt->statistics); 500 print_string_var("chroot:", opt->chroot); 501 print_string_var("username:", opt->username); 502 print_string_var("zonesdir:", opt->zonesdir); 503 print_string_var("xfrdfile:", opt->xfrdfile); 504 print_string_var("zonelistfile:", opt->zonelistfile); 505 print_string_var("xfrdir:", opt->xfrdir); 506 printf("\txfrd-reload-timeout: %d\n", opt->xfrd_reload_timeout); 507 printf("\tlog-time-ascii: %s\n", opt->log_time_ascii?"yes":"no"); 508 printf("\tround-robin: %s\n", opt->round_robin?"yes":"no"); 509 printf("\tverbosity: %d\n", opt->verbosity); 510 for(ip = opt->ip_addresses; ip; ip=ip->next) 511 { 512 print_string_var("ip-address:", ip->address); 513 } 514 #ifdef RATELIMIT 515 printf("\trrl-size: %d\n", (int)opt->rrl_size); 516 printf("\trrl-ratelimit: %d\n", (int)opt->rrl_ratelimit); 517 printf("\trrl-slip: %d\n", (int)opt->rrl_slip); 518 printf("\trrl-ipv4-prefix-length: %d\n", (int)opt->rrl_ipv4_prefix_length); 519 printf("\trrl-ipv6-prefix-length: %d\n", (int)opt->rrl_ipv6_prefix_length); 520 printf("\trrl-whitelist-ratelimit: %d\n", (int)opt->rrl_whitelist_ratelimit); 521 #endif 522 printf("\tzonefiles-check: %s\n", opt->zonefiles_check?"yes":"no"); 523 printf("\tzonefiles-write: %d\n", opt->zonefiles_write); 524 525 printf("\nremote-control:\n"); 526 printf("\tcontrol-enable: %s\n", opt->control_enable?"yes":"no"); 527 for(ip = opt->control_interface; ip; ip=ip->next) 528 print_string_var("control-interface:", ip->address); 529 printf("\tcontrol-port: %d\n", opt->control_port); 530 print_string_var("server-key-file:", opt->server_key_file); 531 print_string_var("server-cert-file:", opt->server_cert_file); 532 print_string_var("control-key-file:", opt->control_key_file); 533 print_string_var("control-cert-file:", opt->control_cert_file); 534 535 RBTREE_FOR(key, key_options_t*, opt->keys) 536 { 537 printf("\nkey:\n"); 538 print_string_var("name:", key->name); 539 print_string_var("algorithm:", key->algorithm); 540 print_string_var("secret:", key->secret); 541 } 542 RBTREE_FOR(pat, pattern_options_t*, opt->patterns) 543 { 544 if(pat->implicit) continue; 545 printf("\npattern:\n"); 546 print_string_var("name:", pat->pname); 547 print_zone_content_elems(pat); 548 } 549 RBTREE_FOR(zone, zone_options_t*, opt->zone_options) 550 { 551 if(!zone->part_of_config) 552 continue; 553 printf("\nzone:\n"); 554 print_string_var("name:", zone->name); 555 print_zone_content_elems(zone->pattern); 556 } 557 558 } 559 560 static void 561 append_trailing_slash(const char** dirname, region_type* region) 562 { 563 int l = strlen(*dirname); 564 if (l>0 && (*dirname)[l-1] != '/' && l < 0xffffff) { 565 char *dirname_slash = region_alloc(region, l+2); 566 memcpy(dirname_slash, *dirname, l+1); 567 strlcat(dirname_slash, "/", l+2); 568 *dirname = dirname_slash; 569 } 570 } 571 572 static int 573 file_inside_chroot(const char* fname, const char* chr) 574 { 575 /* true if filename starts with chroot or is not absolute */ 576 return ((fname && fname[0] && strncmp(fname, chr, strlen(chr)) == 0) || 577 (fname && fname[0] != '/')); 578 } 579 580 static int 581 additional_checks(nsd_options_t* opt, const char* filename) 582 { 583 zone_options_t* zone; 584 int errors = 0; 585 586 RBTREE_FOR(zone, zone_options_t*, opt->zone_options) 587 { 588 const dname_type* dname = dname_parse(opt->region, zone->name); /* memory leak. */ 589 if(!dname) { 590 fprintf(stderr, "%s: cannot parse zone name syntax for zone %s.\n", filename, zone->name); 591 errors ++; 592 } 593 #ifndef ROOT_SERVER 594 /* Is it a root zone? Are we a root server then? Idiot proof. */ 595 if(dname->label_count == 1) { 596 fprintf(stderr, "%s: not configured as a root server.\n", filename); 597 errors ++; 598 } 599 #endif 600 if(zone->pattern->allow_notify && !zone->pattern->request_xfr) { 601 fprintf(stderr, "%s: zone %s has allow-notify but no request-xfr" 602 " items. Where can it get a zone transfer when a notify " 603 "is received?\n", filename, zone->name); 604 errors ++; 605 } 606 if(!zone_is_slave(zone) && (!zone->pattern->zonefile || 607 zone->pattern->zonefile[0] == 0)) { 608 fprintf(stderr, "%s: zone %s is a master zone but has " 609 "no zonefile. Where can the data come from?\n", 610 filename, zone->name); 611 errors ++; 612 } 613 } 614 615 #ifndef BIND8_STATS 616 if(opt->statistics > 0) 617 { 618 fprintf(stderr, "%s: 'statistics: %d' but BIND 8 statistics feature not enabled.\n", 619 filename, opt->statistics); 620 errors ++; 621 } 622 #endif 623 #ifndef HAVE_CHROOT 624 if(opt->chroot != 0) 625 { 626 fprintf(stderr, "%s: chroot %s given. chroot not supported on this platform.\n", 627 filename, opt->chroot); 628 errors ++; 629 } 630 #endif 631 if (opt->identity && strlen(opt->identity) > UCHAR_MAX) { 632 fprintf(stderr, "%s: server identity too long (%u characters)\n", 633 filename, (unsigned) strlen(opt->identity)); 634 errors ++; 635 } 636 if (opt->version && strlen(opt->version) > UCHAR_MAX) { 637 fprintf(stderr, "%s: server version too long (%u characters)\n", 638 filename, (unsigned) strlen(opt->version)); 639 errors ++; 640 } 641 642 /* not done here: parsing of ip-address. parsing of username. */ 643 644 if (opt->chroot && opt->chroot[0]) { 645 /* append trailing slash for strncmp checking */ 646 append_trailing_slash(&opt->chroot, opt->region); 647 append_trailing_slash(&opt->xfrdir, opt->region); 648 append_trailing_slash(&opt->zonesdir, opt->region); 649 650 /* zonesdir must be absolute and within chroot, 651 * all other pathnames may be relative to zonesdir */ 652 if (strncmp(opt->zonesdir, opt->chroot, strlen(opt->chroot)) != 0) { 653 fprintf(stderr, "%s: zonesdir %s has to be an absolute path that starts with the chroot path %s\n", 654 filename, opt->zonesdir, opt->chroot); 655 errors ++; 656 } 657 if (!file_inside_chroot(opt->pidfile, opt->chroot)) { 658 fprintf(stderr, "%s: pidfile %s is not relative to chroot %s.\n", 659 filename, opt->pidfile, opt->chroot); 660 errors ++; 661 } 662 if (!file_inside_chroot(opt->database, opt->chroot)) { 663 fprintf(stderr, "%s: database %s is not relative to chroot %s.\n", 664 filename, opt->database, opt->chroot); 665 errors ++; 666 } 667 if (!file_inside_chroot(opt->xfrdfile, opt->chroot)) { 668 fprintf(stderr, "%s: xfrdfile %s is not relative to chroot %s.\n", 669 filename, opt->xfrdfile, opt->chroot); 670 errors ++; 671 } 672 if (!file_inside_chroot(opt->zonelistfile, opt->chroot)) { 673 fprintf(stderr, "%s: zonelistfile %s is not relative to chroot %s.\n", 674 filename, opt->zonelistfile, opt->chroot); 675 errors ++; 676 } 677 if (!file_inside_chroot(opt->xfrdir, opt->chroot)) { 678 fprintf(stderr, "%s: xfrdir %s is not relative to chroot %s.\n", 679 filename, opt->xfrdir, opt->chroot); 680 errors ++; 681 } 682 } 683 684 if (atoi(opt->port) <= 0) { 685 fprintf(stderr, "%s: port number '%s' is not a positive number.\n", 686 filename, opt->port); 687 errors ++; 688 } 689 if(errors != 0) { 690 fprintf(stderr, "%s: %d semantic errors in %d zones, %d keys.\n", 691 filename, errors, (int)nsd_options_num_zones(opt), 692 (int)opt->keys->count); 693 } 694 695 return (errors == 0); 696 } 697 698 int 699 main(int argc, char* argv[]) 700 { 701 int c; 702 int verbose = 0; 703 int key_sec = 0; 704 int final = 0; 705 const char * conf_opt = NULL; /* what option do you want? Can be NULL -> print all */ 706 const char * conf_zone = NULL; /* what zone are we talking about */ 707 const char * conf_key = NULL; /* what key is needed */ 708 const char * conf_pat = NULL; /* what pattern is talked about */ 709 const char* configfile; 710 nsd_options_t *options; 711 712 log_init("nsd-checkconf"); 713 714 /* Parse the command line... */ 715 while ((c = getopt(argc, argv, "vfo:a:p:s:z:")) != -1) { 716 switch (c) { 717 case 'v': 718 verbose = 1; 719 verbosity++; 720 break; 721 case 'o': 722 conf_opt = optarg; 723 break; 724 case 'f': 725 final = 1; 726 break; 727 case 'p': 728 conf_pat = optarg; 729 break; 730 case 'a': 731 if (conf_key) { 732 fprintf(stderr, "Error: cannot combine -a with -s or other -a.\n"); 733 exit(1); 734 } 735 conf_key = optarg; 736 break; 737 case 's': 738 if (conf_key) { 739 fprintf(stderr, "Error: cannot combine -s with -a or other -s.\n"); 740 exit(1); 741 } 742 conf_key = optarg; 743 key_sec = 1; 744 break; 745 case 'z': 746 conf_zone = optarg; 747 break; 748 default: 749 usage(); 750 }; 751 } 752 argc -= optind; 753 argv += optind; 754 if (argc == 0 || argc>=2) { 755 usage(); 756 } 757 configfile = argv[0]; 758 759 /* read config file */ 760 options = nsd_options_create(region_create(xalloc, free)); 761 tsig_init(options->region); 762 if (!parse_options_file(options, configfile, NULL, NULL) || 763 !additional_checks(options, configfile)) { 764 exit(2); 765 } 766 if (conf_opt || conf_key) { 767 config_print_zone(options, conf_key, key_sec, 768 underscore(conf_opt), conf_zone, conf_pat, final); 769 } else { 770 if (verbose) { 771 printf("# Read file %s: %d patterns, %d fixed-zones, " 772 "%d keys.\n", 773 configfile, 774 (int)options->patterns->count, 775 (int)nsd_options_num_zones(options), 776 (int)options->keys->count); 777 config_test_print_server(options); 778 } 779 } 780 return 0; 781 } 782