1 /* ntp_config.c 2 * 3 * This file contains the ntpd configuration code. 4 * 5 * Written By: Sachin Kamboj 6 * University of Delaware 7 * Newark, DE 19711 8 * Some parts borrowed from the older ntp_config.c 9 * Copyright (c) 2006 10 */ 11 12 #ifdef HAVE_CONFIG_H 13 # include <config.h> 14 #endif 15 16 #ifdef HAVE_NETINFO 17 # include <netinfo/ni.h> 18 #endif 19 20 #include <stdio.h> 21 #include <ctype.h> 22 #ifdef HAVE_SYS_PARAM_H 23 # include <sys/param.h> 24 #endif 25 #include <signal.h> 26 #ifndef SIGCHLD 27 # define SIGCHLD SIGCLD 28 #endif 29 #ifdef HAVE_SYS_WAIT_H 30 # include <sys/wait.h> 31 #endif 32 #include <time.h> 33 34 #include <isc/net.h> 35 #include <isc/result.h> 36 37 #include "ntp.h" 38 #include "ntpd.h" 39 #include "ntp_io.h" 40 #include "ntp_unixtime.h" 41 #include "ntp_refclock.h" 42 #include "ntp_filegen.h" 43 #include "ntp_stdlib.h" 44 #include "lib_strbuf.h" 45 #include "ntp_assert.h" 46 #include "ntp_random.h" 47 /* 48 * [Bug 467]: Some linux headers collide with CONFIG_PHONE and CONFIG_KEYS 49 * so #include these later. 50 */ 51 #include "ntp_config.h" 52 #include "ntp_cmdargs.h" 53 #include "ntp_scanner.h" 54 #include "ntp_parser.h" 55 #include "ntpd-opts.h" 56 57 #ifndef IGNORE_DNS_ERRORS 58 # define DNSFLAGS 0 59 #else 60 # define DNSFLAGS GAIR_F_IGNDNSERR 61 #endif 62 63 extern int yyparse(void); 64 65 /* Bug 2817 */ 66 #if defined(HAVE_SYS_MMAN_H) 67 # include <sys/mman.h> 68 #endif 69 70 /* list of servers from command line for config_peers() */ 71 int cmdline_server_count; 72 char ** cmdline_servers; 73 74 /* Current state of memory locking: 75 * -1: default 76 * 0: memory locking disabled 77 * 1: Memory locking enabled 78 */ 79 int cur_memlock = -1; 80 81 /* 82 * "logconfig" building blocks 83 */ 84 struct masks { 85 const char * const name; 86 const u_int32 mask; 87 }; 88 89 static struct masks logcfg_class[] = { 90 { "clock", NLOG_OCLOCK }, 91 { "peer", NLOG_OPEER }, 92 { "sync", NLOG_OSYNC }, 93 { "sys", NLOG_OSYS }, 94 { NULL, 0 } 95 }; 96 97 /* logcfg_noclass_items[] masks are complete and must not be shifted */ 98 static struct masks logcfg_noclass_items[] = { 99 { "allall", NLOG_SYSMASK | NLOG_PEERMASK | NLOG_CLOCKMASK | NLOG_SYNCMASK }, 100 { "allinfo", NLOG_SYSINFO | NLOG_PEERINFO | NLOG_CLOCKINFO | NLOG_SYNCINFO }, 101 { "allevents", NLOG_SYSEVENT | NLOG_PEEREVENT | NLOG_CLOCKEVENT | NLOG_SYNCEVENT }, 102 { "allstatus", NLOG_SYSSTATUS | NLOG_PEERSTATUS | NLOG_CLOCKSTATUS | NLOG_SYNCSTATUS }, 103 { "allstatistics", NLOG_SYSSTATIST | NLOG_PEERSTATIST | NLOG_CLOCKSTATIST | NLOG_SYNCSTATIST }, 104 /* the remainder are misspellings of clockall, peerall, sysall, and syncall. */ 105 { "allclock", (NLOG_INFO | NLOG_STATIST | NLOG_EVENT | NLOG_STATUS) << NLOG_OCLOCK }, 106 { "allpeer", (NLOG_INFO | NLOG_STATIST | NLOG_EVENT | NLOG_STATUS) << NLOG_OPEER }, 107 { "allsys", (NLOG_INFO | NLOG_STATIST | NLOG_EVENT | NLOG_STATUS) << NLOG_OSYS }, 108 { "allsync", (NLOG_INFO | NLOG_STATIST | NLOG_EVENT | NLOG_STATUS) << NLOG_OSYNC }, 109 { NULL, 0 } 110 }; 111 112 /* logcfg_class_items[] masks are shiftable by NLOG_O* counts */ 113 static struct masks logcfg_class_items[] = { 114 { "all", NLOG_INFO | NLOG_EVENT | NLOG_STATUS | NLOG_STATIST }, 115 { "info", NLOG_INFO }, 116 { "events", NLOG_EVENT }, 117 { "status", NLOG_STATUS }, 118 { "statistics", NLOG_STATIST }, 119 { NULL, 0 } 120 }; 121 122 typedef struct peer_resolved_ctx_tag { 123 int flags; 124 int host_mode; /* T_* token identifier */ 125 u_short family; 126 keyid_t keyid; 127 u_char hmode; /* MODE_* */ 128 u_char version; 129 u_char minpoll; 130 u_char maxpoll; 131 u_int32 ttl; 132 const char * group; 133 } peer_resolved_ctx; 134 135 /* Limits */ 136 #define MAXPHONE 10 /* maximum number of phone strings */ 137 #define MAXPPS 20 /* maximum length of PPS device string */ 138 139 /* 140 * Miscellaneous macros 141 */ 142 #define ISEOL(c) ((c) == '#' || (c) == '\n' || (c) == '\0') 143 #define ISSPACE(c) ((c) == ' ' || (c) == '\t') 144 145 #define _UC(str) ((char *)(intptr_t)(str)) 146 147 /* 148 * Definitions of things either imported from or exported to outside 149 */ 150 extern int yydebug; /* ntp_parser.c (.y) */ 151 config_tree cfgt; /* Parser output stored here */ 152 config_tree *cfg_tree_history; /* History of configs */ 153 char * sys_phone[MAXPHONE] = {NULL}; /* ACTS phone numbers */ 154 char default_keysdir[] = NTP_KEYSDIR; 155 char * keysdir = default_keysdir; /* crypto keys directory */ 156 char * saveconfigdir; 157 #if defined(HAVE_SCHED_SETSCHEDULER) 158 int config_priority_override = 0; 159 int config_priority; 160 #endif 161 162 const char *config_file; 163 static char default_ntp_signd_socket[] = 164 #ifdef NTP_SIGND_PATH 165 NTP_SIGND_PATH; 166 #else 167 ""; 168 #endif 169 char *ntp_signd_socket = default_ntp_signd_socket; 170 #ifdef HAVE_NETINFO 171 struct netinfo_config_state *config_netinfo = NULL; 172 int check_netinfo = 1; 173 #endif /* HAVE_NETINFO */ 174 #ifdef SYS_WINNT 175 char *alt_config_file; 176 LPTSTR temp; 177 char config_file_storage[MAX_PATH]; 178 char alt_config_file_storage[MAX_PATH]; 179 #endif /* SYS_WINNT */ 180 181 #ifdef HAVE_NETINFO 182 /* 183 * NetInfo configuration state 184 */ 185 struct netinfo_config_state { 186 void *domain; /* domain with config */ 187 ni_id config_dir; /* ID config dir */ 188 int prop_index; /* current property */ 189 int val_index; /* current value */ 190 char **val_list; /* value list */ 191 }; 192 #endif 193 194 struct REMOTE_CONFIG_INFO remote_config; /* Remote configuration buffer and 195 pointer info */ 196 int old_config_style = 1; /* A boolean flag, which when set, 197 * indicates that the old configuration 198 * format with a newline at the end of 199 * every command is being used 200 */ 201 int cryptosw; /* crypto command called */ 202 203 extern char *stats_drift_file; /* name of the driftfile */ 204 205 #ifdef BC_LIST_FRAMEWORK_NOT_YET_USED 206 /* 207 * backwards compatibility flags 208 */ 209 bc_entry bc_list[] = { 210 { T_Bc_bugXXXX, 1 } /* default enabled */ 211 }; 212 213 /* 214 * declare an int pointer for each flag for quick testing without 215 * walking bc_list. If the pointer is consumed by libntp rather 216 * than ntpd, declare it in a libntp source file pointing to storage 217 * initialized with the appropriate value for other libntp clients, and 218 * redirect it to point into bc_list during ntpd startup. 219 */ 220 int *p_bcXXXX_enabled = &bc_list[0].enabled; 221 #endif 222 223 /* FUNCTION PROTOTYPES */ 224 225 static void init_syntax_tree(config_tree *); 226 static void apply_enable_disable(attr_val_fifo *q, int enable); 227 228 #ifdef FREE_CFG_T 229 static void free_auth_node(config_tree *); 230 static void free_all_config_trees(void); 231 232 static void free_config_access(config_tree *); 233 static void free_config_auth(config_tree *); 234 static void free_config_fudge(config_tree *); 235 static void free_config_logconfig(config_tree *); 236 static void free_config_monitor(config_tree *); 237 static void free_config_nic_rules(config_tree *); 238 static void free_config_other_modes(config_tree *); 239 static void free_config_peers(config_tree *); 240 static void free_config_phone(config_tree *); 241 static void free_config_reset_counters(config_tree *); 242 static void free_config_rlimit(config_tree *); 243 static void free_config_setvar(config_tree *); 244 static void free_config_system_opts(config_tree *); 245 static void free_config_tinker(config_tree *); 246 static void free_config_tos(config_tree *); 247 static void free_config_trap(config_tree *); 248 static void free_config_ttl(config_tree *); 249 static void free_config_unpeers(config_tree *); 250 static void free_config_vars(config_tree *); 251 252 #ifdef SIM 253 static void free_config_sim(config_tree *); 254 #endif 255 static void destroy_address_fifo(address_fifo *); 256 #define FREE_ADDRESS_FIFO(pf) \ 257 do { \ 258 destroy_address_fifo(pf); \ 259 (pf) = NULL; \ 260 } while (0) 261 void free_all_config_trees(void); /* atexit() */ 262 static void free_config_tree(config_tree *ptree); 263 #endif /* FREE_CFG_T */ 264 265 static void destroy_restrict_node(restrict_node *my_node); 266 static int is_sane_resolved_address(sockaddr_u *peeraddr, int hmode); 267 static void save_and_apply_config_tree(int/*BOOL*/ from_file); 268 static void destroy_int_fifo(int_fifo *); 269 #define FREE_INT_FIFO(pf) \ 270 do { \ 271 destroy_int_fifo(pf); \ 272 (pf) = NULL; \ 273 } while (0) 274 static void destroy_string_fifo(string_fifo *); 275 #define FREE_STRING_FIFO(pf) \ 276 do { \ 277 destroy_string_fifo(pf); \ 278 (pf) = NULL; \ 279 } while (0) 280 static void destroy_attr_val_fifo(attr_val_fifo *); 281 #define FREE_ATTR_VAL_FIFO(pf) \ 282 do { \ 283 destroy_attr_val_fifo(pf); \ 284 (pf) = NULL; \ 285 } while (0) 286 static void destroy_filegen_fifo(filegen_fifo *); 287 #define FREE_FILEGEN_FIFO(pf) \ 288 do { \ 289 destroy_filegen_fifo(pf); \ 290 (pf) = NULL; \ 291 } while (0) 292 static void destroy_restrict_fifo(restrict_fifo *); 293 #define FREE_RESTRICT_FIFO(pf) \ 294 do { \ 295 destroy_restrict_fifo(pf); \ 296 (pf) = NULL; \ 297 } while (0) 298 static void destroy_setvar_fifo(setvar_fifo *); 299 #define FREE_SETVAR_FIFO(pf) \ 300 do { \ 301 destroy_setvar_fifo(pf); \ 302 (pf) = NULL; \ 303 } while (0) 304 static void destroy_addr_opts_fifo(addr_opts_fifo *); 305 #define FREE_ADDR_OPTS_FIFO(pf) \ 306 do { \ 307 destroy_addr_opts_fifo(pf); \ 308 (pf) = NULL; \ 309 } while (0) 310 311 static void config_logconfig(config_tree *); 312 static void config_monitor(config_tree *); 313 static void config_rlimit(config_tree *); 314 static void config_system_opts(config_tree *); 315 static void config_tinker(config_tree *); 316 static int config_tos_clock(config_tree *); 317 static void config_tos(config_tree *); 318 static void config_vars(config_tree *); 319 320 #ifdef SIM 321 static sockaddr_u *get_next_address(address_node *addr); 322 static void config_sim(config_tree *); 323 static void config_ntpdsim(config_tree *); 324 #else /* !SIM follows */ 325 static void config_ntpd(config_tree *, int/*BOOL*/ input_from_file); 326 static void config_other_modes(config_tree *); 327 static void config_auth(config_tree *); 328 static void attrtopsl(int poll, attr_val *avp); 329 static void config_access(config_tree *); 330 static void config_mdnstries(config_tree *); 331 static void config_phone(config_tree *); 332 static void config_setvar(config_tree *); 333 static void config_ttl(config_tree *); 334 static void config_trap(config_tree *); 335 static void config_fudge(config_tree *); 336 static void config_peers(config_tree *); 337 static void config_unpeers(config_tree *); 338 static void config_nic_rules(config_tree *, int/*BOOL*/ input_from_file); 339 static void config_reset_counters(config_tree *); 340 static u_char get_correct_host_mode(int token); 341 static int peerflag_bits(peer_node *); 342 #endif /* !SIM */ 343 344 #ifdef WORKER 345 static void peer_name_resolved(int, int, void *, const char *, const char *, 346 const struct addrinfo *, 347 const struct addrinfo *); 348 static void unpeer_name_resolved(int, int, void *, const char *, const char *, 349 const struct addrinfo *, 350 const struct addrinfo *); 351 static void trap_name_resolved(int, int, void *, const char *, const char *, 352 const struct addrinfo *, 353 const struct addrinfo *); 354 #endif 355 356 enum gnn_type { 357 t_UNK, /* Unknown */ 358 t_REF, /* Refclock */ 359 t_MSK /* Network Mask */ 360 }; 361 362 static void ntpd_set_tod_using(const char *); 363 static char * normal_dtoa(double); 364 static u_int32 get_pfxmatch(const char **, struct masks *); 365 static u_int32 get_match(const char *, struct masks *); 366 static u_int32 get_logmask(const char *); 367 static int/*BOOL*/ is_refclk_addr(const address_node * addr); 368 369 static void appendstr(char *, size_t, const char *); 370 371 372 #ifndef SIM 373 static int getnetnum(const char *num, sockaddr_u *addr, int complain, 374 enum gnn_type a_type); 375 376 #endif 377 378 #if defined(__GNUC__) /* this covers CLANG, too */ 379 static void __attribute__((noreturn,format(printf,1,2))) fatal_error(const char *fmt, ...) 380 #elif defined(_MSC_VER) 381 static void __declspec(noreturn) fatal_error(const char *fmt, ...) 382 #else 383 static void fatal_error(const char *fmt, ...) 384 #endif 385 { 386 va_list va; 387 388 va_start(va, fmt); 389 mvsyslog(LOG_EMERG, fmt, va); 390 va_end(va); 391 _exit(1); 392 } 393 394 395 /* FUNCTIONS FOR INITIALIZATION 396 * ---------------------------- 397 */ 398 399 #ifdef FREE_CFG_T 400 static void 401 free_auth_node( 402 config_tree *ptree 403 ) 404 { 405 if (ptree->auth.keys) { 406 free(ptree->auth.keys); 407 ptree->auth.keys = NULL; 408 } 409 410 if (ptree->auth.keysdir) { 411 free(ptree->auth.keysdir); 412 ptree->auth.keysdir = NULL; 413 } 414 415 if (ptree->auth.ntp_signd_socket) { 416 free(ptree->auth.ntp_signd_socket); 417 ptree->auth.ntp_signd_socket = NULL; 418 } 419 } 420 #endif /* DEBUG */ 421 422 423 static void 424 init_syntax_tree( 425 config_tree *ptree 426 ) 427 { 428 ZERO(*ptree); 429 ptree->mdnstries = 5; 430 } 431 432 433 #ifdef FREE_CFG_T 434 static void 435 free_all_config_trees(void) 436 { 437 config_tree *ptree; 438 config_tree *pnext; 439 440 ptree = cfg_tree_history; 441 442 while (ptree != NULL) { 443 pnext = ptree->link; 444 free_config_tree(ptree); 445 ptree = pnext; 446 } 447 } 448 449 450 static void 451 free_config_tree( 452 config_tree *ptree 453 ) 454 { 455 #if defined(_MSC_VER) && defined (_DEBUG) 456 _CrtCheckMemory(); 457 #endif 458 459 if (ptree->source.value.s != NULL) 460 free(ptree->source.value.s); 461 462 free_config_other_modes(ptree); 463 free_config_auth(ptree); 464 free_config_tos(ptree); 465 free_config_monitor(ptree); 466 free_config_access(ptree); 467 free_config_tinker(ptree); 468 free_config_rlimit(ptree); 469 free_config_system_opts(ptree); 470 free_config_logconfig(ptree); 471 free_config_phone(ptree); 472 free_config_setvar(ptree); 473 free_config_ttl(ptree); 474 free_config_trap(ptree); 475 free_config_fudge(ptree); 476 free_config_vars(ptree); 477 free_config_peers(ptree); 478 free_config_unpeers(ptree); 479 free_config_nic_rules(ptree); 480 free_config_reset_counters(ptree); 481 #ifdef SIM 482 free_config_sim(ptree); 483 #endif 484 free_auth_node(ptree); 485 486 free(ptree); 487 488 #if defined(_MSC_VER) && defined (_DEBUG) 489 _CrtCheckMemory(); 490 #endif 491 } 492 #endif /* FREE_CFG_T */ 493 494 495 #ifdef SAVECONFIG 496 /* Dump all trees */ 497 int 498 dump_all_config_trees( 499 FILE *df, 500 int comment 501 ) 502 { 503 config_tree * cfg_ptr; 504 int return_value; 505 time_t now = time(NULL); 506 struct tm tm = *localtime(&now); 507 508 fprintf(df, "#NTF:D %04d%02d%02d@%02d:%02d:%02d\n", 509 tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, 510 tm.tm_hour, tm.tm_min, tm.tm_sec); 511 fprintf(df, "#NTF:V %s\n", Version); 512 513 return_value = 0; 514 for (cfg_ptr = cfg_tree_history; 515 cfg_ptr != NULL; 516 cfg_ptr = cfg_ptr->link) 517 return_value |= dump_config_tree(cfg_ptr, df, comment); 518 519 return return_value; 520 } 521 522 523 /* The config dumper */ 524 int 525 dump_config_tree( 526 config_tree *ptree, 527 FILE *df, 528 int comment 529 ) 530 { 531 peer_node *peern; 532 unpeer_node *unpeern; 533 attr_val *atrv; 534 address_node *addr; 535 address_node *peer_addr; 536 address_node *fudge_addr; 537 filegen_node *fgen_node; 538 restrict_node *rest_node; 539 addr_opts_node *addr_opts; 540 setvar_node *setv_node; 541 nic_rule_node *rule_node; 542 int_node *i_n; 543 int_node *counter_set; 544 string_node *str_node; 545 546 const char *s = NULL; 547 char *s1; 548 char *s2; 549 char timestamp[80]; 550 int enable; 551 552 DPRINTF(1, ("dump_config_tree(%p)\n", ptree)); 553 554 if (comment) { 555 if (!strftime(timestamp, sizeof(timestamp), 556 "%Y-%m-%d %H:%M:%S", 557 localtime(&ptree->timestamp))) 558 timestamp[0] = '\0'; 559 560 fprintf(df, "# %s %s %s\n", 561 timestamp, 562 (CONF_SOURCE_NTPQ == ptree->source.attr) 563 ? "ntpq remote config from" 564 : "startup configuration file", 565 ptree->source.value.s); 566 } 567 568 /* 569 * For options without documentation we just output the name 570 * and its data value 571 */ 572 atrv = HEAD_PFIFO(ptree->vars); 573 for ( ; atrv != NULL; atrv = atrv->link) { 574 switch (atrv->type) { 575 #ifdef DEBUG 576 default: 577 fprintf(df, "\n# dump error:\n" 578 "# unknown vars type %d (%s) for %s\n", 579 atrv->type, token_name(atrv->type), 580 token_name(atrv->attr)); 581 break; 582 #endif 583 case T_Double: 584 fprintf(df, "%s %s\n", keyword(atrv->attr), 585 normal_dtoa(atrv->value.d)); 586 break; 587 588 case T_Integer: 589 fprintf(df, "%s %d\n", keyword(atrv->attr), 590 atrv->value.i); 591 break; 592 593 case T_String: 594 fprintf(df, "%s \"%s\"", keyword(atrv->attr), 595 atrv->value.s); 596 if (T_Driftfile == atrv->attr && 597 atrv->link != NULL && 598 T_WanderThreshold == atrv->link->attr) { 599 atrv = atrv->link; 600 fprintf(df, " %s\n", 601 normal_dtoa(atrv->value.d)); 602 } else if (T_Leapfile == atrv->attr) { 603 fputs((atrv->flag 604 ? " checkhash\n" 605 : " ignorehash\n"), 606 df); 607 } else { 608 fprintf(df, "\n"); 609 } 610 break; 611 } 612 } 613 614 atrv = HEAD_PFIFO(ptree->logconfig); 615 if (atrv != NULL) { 616 fprintf(df, "logconfig"); 617 for ( ; atrv != NULL; atrv = atrv->link) 618 fprintf(df, " %c%s", atrv->attr, atrv->value.s); 619 fprintf(df, "\n"); 620 } 621 622 if (ptree->stats_dir) 623 fprintf(df, "statsdir \"%s\"\n", ptree->stats_dir); 624 625 i_n = HEAD_PFIFO(ptree->stats_list); 626 if (i_n != NULL) { 627 fprintf(df, "statistics"); 628 for ( ; i_n != NULL; i_n = i_n->link) 629 fprintf(df, " %s", keyword(i_n->i)); 630 fprintf(df, "\n"); 631 } 632 633 fgen_node = HEAD_PFIFO(ptree->filegen_opts); 634 for ( ; fgen_node != NULL; fgen_node = fgen_node->link) { 635 atrv = HEAD_PFIFO(fgen_node->options); 636 if (atrv != NULL) { 637 fprintf(df, "filegen %s", 638 keyword(fgen_node->filegen_token)); 639 for ( ; atrv != NULL; atrv = atrv->link) { 640 switch (atrv->attr) { 641 #ifdef DEBUG 642 default: 643 fprintf(df, "\n# dump error:\n" 644 "# unknown filegen option token %s\n" 645 "filegen %s", 646 token_name(atrv->attr), 647 keyword(fgen_node->filegen_token)); 648 break; 649 #endif 650 case T_File: 651 fprintf(df, " file %s", 652 atrv->value.s); 653 break; 654 655 case T_Type: 656 fprintf(df, " type %s", 657 keyword(atrv->value.i)); 658 break; 659 660 case T_Flag: 661 fprintf(df, " %s", 662 keyword(atrv->value.i)); 663 break; 664 } 665 } 666 fprintf(df, "\n"); 667 } 668 } 669 670 atrv = HEAD_PFIFO(ptree->auth.crypto_cmd_list); 671 if (atrv != NULL) { 672 fprintf(df, "crypto"); 673 for ( ; atrv != NULL; atrv = atrv->link) { 674 fprintf(df, " %s %s", keyword(atrv->attr), 675 atrv->value.s); 676 } 677 fprintf(df, "\n"); 678 } 679 680 if (ptree->auth.revoke != 0) 681 fprintf(df, "revoke %d\n", ptree->auth.revoke); 682 683 if (ptree->auth.keysdir != NULL) 684 fprintf(df, "keysdir \"%s\"\n", ptree->auth.keysdir); 685 686 if (ptree->auth.keys != NULL) 687 fprintf(df, "keys \"%s\"\n", ptree->auth.keys); 688 689 atrv = HEAD_PFIFO(ptree->auth.trusted_key_list); 690 if (atrv != NULL) { 691 fprintf(df, "trustedkey"); 692 for ( ; atrv != NULL; atrv = atrv->link) { 693 if (T_Integer == atrv->type) 694 fprintf(df, " %d", atrv->value.i); 695 else if (T_Intrange == atrv->type) 696 fprintf(df, " (%d ... %d)", 697 atrv->value.r.first, 698 atrv->value.r.last); 699 #ifdef DEBUG 700 else 701 fprintf(df, "\n# dump error:\n" 702 "# unknown trustedkey attr type %d\n" 703 "trustedkey", atrv->type); 704 #endif 705 } 706 fprintf(df, "\n"); 707 } 708 709 if (ptree->auth.control_key) 710 fprintf(df, "controlkey %d\n", ptree->auth.control_key); 711 712 if (ptree->auth.request_key) 713 fprintf(df, "requestkey %d\n", ptree->auth.request_key); 714 715 /* dump enable list, then disable list */ 716 for (enable = 1; enable >= 0; enable--) { 717 atrv = (enable) 718 ? HEAD_PFIFO(ptree->enable_opts) 719 : HEAD_PFIFO(ptree->disable_opts); 720 if (atrv != NULL) { 721 fprintf(df, "%s", (enable) 722 ? "enable" 723 : "disable"); 724 for ( ; atrv != NULL; atrv = atrv->link) 725 fprintf(df, " %s", 726 keyword(atrv->value.i)); 727 fprintf(df, "\n"); 728 } 729 } 730 731 atrv = HEAD_PFIFO(ptree->orphan_cmds); 732 if (atrv != NULL) { 733 fprintf(df, "tos"); 734 for ( ; atrv != NULL; atrv = atrv->link) { 735 switch (atrv->type) { 736 #ifdef DEBUG 737 default: 738 fprintf(df, "\n# dump error:\n" 739 "# unknown tos attr type %d %s\n" 740 "tos", atrv->type, 741 token_name(atrv->type)); 742 break; 743 #endif 744 case T_Integer: 745 if (atrv->attr == T_Basedate) { 746 struct calendar jd; 747 ntpcal_rd_to_date(&jd, atrv->value.i + DAY_NTP_STARTS); 748 fprintf(df, " %s \"%04hu-%02hu-%02hu\"", 749 keyword(atrv->attr), jd.year, 750 (u_short)jd.month, 751 (u_short)jd.monthday); 752 } else { 753 fprintf(df, " %s %d", 754 keyword(atrv->attr), 755 atrv->value.i); 756 } 757 break; 758 759 case T_Double: 760 fprintf(df, " %s %s", 761 keyword(atrv->attr), 762 normal_dtoa(atrv->value.d)); 763 break; 764 } 765 } 766 fprintf(df, "\n"); 767 } 768 769 atrv = HEAD_PFIFO(ptree->rlimit); 770 if (atrv != NULL) { 771 fprintf(df, "rlimit"); 772 for ( ; atrv != NULL; atrv = atrv->link) { 773 INSIST(T_Integer == atrv->type); 774 fprintf(df, " %s %d", keyword(atrv->attr), 775 atrv->value.i); 776 } 777 fprintf(df, "\n"); 778 } 779 780 atrv = HEAD_PFIFO(ptree->tinker); 781 if (atrv != NULL) { 782 fprintf(df, "tinker"); 783 for ( ; atrv != NULL; atrv = atrv->link) { 784 INSIST(T_Double == atrv->type); 785 fprintf(df, " %s %s", keyword(atrv->attr), 786 normal_dtoa(atrv->value.d)); 787 } 788 fprintf(df, "\n"); 789 } 790 791 if (ptree->broadcastclient) 792 fprintf(df, "broadcastclient\n"); 793 794 peern = HEAD_PFIFO(ptree->peers); 795 for ( ; peern != NULL; peern = peern->link) { 796 addr = peern->addr; 797 fprintf(df, "%s", keyword(peern->host_mode)); 798 switch (addr->type) { 799 #ifdef DEBUG 800 default: 801 fprintf(df, "# dump error:\n" 802 "# unknown peer family %d for:\n" 803 "%s", addr->type, 804 keyword(peern->host_mode)); 805 break; 806 #endif 807 case AF_UNSPEC: 808 break; 809 810 case AF_INET: 811 fprintf(df, " -4"); 812 break; 813 814 case AF_INET6: 815 fprintf(df, " -6"); 816 break; 817 } 818 fprintf(df, " %s", addr->address); 819 820 if (peern->minpoll != 0) 821 fprintf(df, " minpoll %u", peern->minpoll); 822 823 if (peern->maxpoll != 0) 824 fprintf(df, " maxpoll %u", peern->maxpoll); 825 826 if (peern->ttl != 0) { 827 if (strlen(addr->address) > 8 828 && !memcmp(addr->address, "127.127.", 8)) 829 fprintf(df, " mode %u", peern->ttl); 830 else 831 fprintf(df, " ttl %u", peern->ttl); 832 } 833 834 if (peern->peerversion != NTP_VERSION) 835 fprintf(df, " version %u", peern->peerversion); 836 837 if (peern->peerkey != 0) 838 fprintf(df, " key %u", peern->peerkey); 839 840 if (peern->group != NULL) 841 fprintf(df, " ident \"%s\"", peern->group); 842 843 atrv = HEAD_PFIFO(peern->peerflags); 844 for ( ; atrv != NULL; atrv = atrv->link) { 845 INSIST(T_Flag == atrv->attr); 846 INSIST(T_Integer == atrv->type); 847 fprintf(df, " %s", keyword(atrv->value.i)); 848 } 849 850 fprintf(df, "\n"); 851 852 addr_opts = HEAD_PFIFO(ptree->fudge); 853 for ( ; addr_opts != NULL; addr_opts = addr_opts->link) { 854 peer_addr = peern->addr; 855 fudge_addr = addr_opts->addr; 856 857 s1 = peer_addr->address; 858 s2 = fudge_addr->address; 859 860 if (strcmp(s1, s2)) 861 continue; 862 863 fprintf(df, "fudge %s", s1); 864 865 for (atrv = HEAD_PFIFO(addr_opts->options); 866 atrv != NULL; 867 atrv = atrv->link) { 868 869 switch (atrv->type) { 870 #ifdef DEBUG 871 default: 872 fprintf(df, "\n# dump error:\n" 873 "# unknown fudge atrv->type %d\n" 874 "fudge %s", atrv->type, 875 s1); 876 break; 877 #endif 878 case T_Double: 879 fprintf(df, " %s %s", 880 keyword(atrv->attr), 881 normal_dtoa(atrv->value.d)); 882 break; 883 884 case T_Integer: 885 fprintf(df, " %s %d", 886 keyword(atrv->attr), 887 atrv->value.i); 888 break; 889 890 case T_String: 891 fprintf(df, " %s %s", 892 keyword(atrv->attr), 893 atrv->value.s); 894 break; 895 } 896 } 897 fprintf(df, "\n"); 898 } 899 } 900 901 addr = HEAD_PFIFO(ptree->manycastserver); 902 if (addr != NULL) { 903 fprintf(df, "manycastserver"); 904 for ( ; addr != NULL; addr = addr->link) 905 fprintf(df, " %s", addr->address); 906 fprintf(df, "\n"); 907 } 908 909 addr = HEAD_PFIFO(ptree->multicastclient); 910 if (addr != NULL) { 911 fprintf(df, "multicastclient"); 912 for ( ; addr != NULL; addr = addr->link) 913 fprintf(df, " %s", addr->address); 914 fprintf(df, "\n"); 915 } 916 917 918 for (unpeern = HEAD_PFIFO(ptree->unpeers); 919 unpeern != NULL; 920 unpeern = unpeern->link) 921 fprintf(df, "unpeer %s\n", unpeern->addr->address); 922 923 atrv = HEAD_PFIFO(ptree->mru_opts); 924 if (atrv != NULL) { 925 fprintf(df, "mru"); 926 for ( ; atrv != NULL; atrv = atrv->link) 927 fprintf(df, " %s %d", keyword(atrv->attr), 928 atrv->value.i); 929 fprintf(df, "\n"); 930 } 931 932 atrv = HEAD_PFIFO(ptree->discard_opts); 933 if (atrv != NULL) { 934 fprintf(df, "discard"); 935 for ( ; atrv != NULL; atrv = atrv->link) 936 fprintf(df, " %s %d", keyword(atrv->attr), 937 atrv->value.i); 938 fprintf(df, "\n"); 939 } 940 941 atrv = HEAD_PFIFO(ptree->pollskewlist); 942 if (atrv != NULL) { 943 fprintf(df, "pollskewlist"); 944 for ( ; atrv != NULL; atrv = atrv->link) { 945 if (-1 == atrv->attr) { 946 fprintf(df, " default"); 947 } else { 948 fprintf(df, " %d", atrv->attr); 949 } 950 fprintf(df, " %d|%d", 951 atrv->value.r.first, atrv->value.r.last); 952 } 953 fprintf(df, "\n"); 954 } 955 956 for (rest_node = HEAD_PFIFO(ptree->restrict_opts); 957 rest_node != NULL; 958 rest_node = rest_node->link) { 959 int is_default = 0; 960 961 if (NULL == rest_node->addr) { 962 s = "default"; 963 /* Don't need to set is_default=1 here */ 964 atrv = HEAD_PFIFO(rest_node->flag_tok_fifo); 965 for ( ; atrv != NULL; atrv = atrv->link) { 966 if ( T_Integer == atrv->type 967 && T_Source == atrv->attr) { 968 s = "source"; 969 break; 970 } 971 } 972 } else { 973 const char *ap = rest_node->addr->address; 974 const char *mp = ""; 975 976 if (rest_node->mask) 977 mp = rest_node->mask->address; 978 979 if ( rest_node->addr->type == AF_INET 980 && !strcmp(ap, "0.0.0.0") 981 && !strcmp(mp, "0.0.0.0")) { 982 is_default = 1; 983 s = "-4 default"; 984 } else if ( rest_node->mask 985 && rest_node->mask->type == AF_INET6 986 && !strcmp(ap, "::") 987 && !strcmp(mp, "::")) { 988 is_default = 1; 989 s = "-6 default"; 990 } else { 991 s = ap; 992 } 993 } 994 fprintf(df, "restrict %s", s); 995 if (rest_node->mask != NULL && !is_default) 996 fprintf(df, " mask %s", 997 rest_node->mask->address); 998 fprintf(df, " ippeerlimit %d", rest_node->ippeerlimit); 999 atrv = HEAD_PFIFO(rest_node->flag_tok_fifo); 1000 for ( ; atrv != NULL; atrv = atrv->link) { 1001 if ( T_Integer == atrv->type 1002 && T_Source != atrv->attr) { 1003 fprintf(df, " %s", keyword(atrv->attr)); 1004 } 1005 } 1006 fprintf(df, "\n"); 1007 /**/ 1008 #if 0 1009 msyslog(LOG_INFO, "Dumping flag_tok_fifo:"); 1010 atrv = HEAD_PFIFO(rest_node->flag_tok_fifo); 1011 for ( ; atrv != NULL; atrv = atrv->link) { 1012 msyslog(LOG_INFO, "- flag_tok_fifo: flags: %08x", atrv->flag); 1013 switch(atrv->type) { 1014 case T_Integer: 1015 msyslog(LOG_INFO, "- T_Integer: attr <%s>/%d, value %d", 1016 keyword(atrv->attr), atrv->attr, atrv->value.i); 1017 break; 1018 default: 1019 msyslog(LOG_INFO, "- Other: attr <%s>/%d, value ???", 1020 keyword(atrv->attr), atrv->attr); 1021 break; 1022 1023 } 1024 } 1025 #endif 1026 /**/ 1027 } 1028 1029 rule_node = HEAD_PFIFO(ptree->nic_rules); 1030 for ( ; rule_node != NULL; rule_node = rule_node->link) { 1031 fprintf(df, "interface %s %s\n", 1032 keyword(rule_node->action), 1033 (rule_node->match_class) 1034 ? keyword(rule_node->match_class) 1035 : rule_node->if_name); 1036 } 1037 1038 str_node = HEAD_PFIFO(ptree->phone); 1039 if (str_node != NULL) { 1040 fprintf(df, "phone"); 1041 for ( ; str_node != NULL; str_node = str_node->link) 1042 fprintf(df, " \"%s\"", str_node->s); 1043 fprintf(df, "\n"); 1044 } 1045 1046 setv_node = HEAD_PFIFO(ptree->setvar); 1047 for ( ; setv_node != NULL; setv_node = setv_node->link) { 1048 s1 = quote_if_needed(setv_node->var); 1049 s2 = quote_if_needed(setv_node->val); 1050 fprintf(df, "setvar %s = %s", s1, s2); 1051 free(s1); 1052 free(s2); 1053 if (setv_node->isdefault) 1054 fprintf(df, " default"); 1055 fprintf(df, "\n"); 1056 } 1057 1058 i_n = HEAD_PFIFO(ptree->ttl); 1059 if (i_n != NULL) { 1060 fprintf(df, "ttl"); 1061 for( ; i_n != NULL; i_n = i_n->link) 1062 fprintf(df, " %d", i_n->i); 1063 fprintf(df, "\n"); 1064 } 1065 1066 addr_opts = HEAD_PFIFO(ptree->trap); 1067 for ( ; addr_opts != NULL; addr_opts = addr_opts->link) { 1068 addr = addr_opts->addr; 1069 fprintf(df, "trap %s", addr->address); 1070 atrv = HEAD_PFIFO(addr_opts->options); 1071 for ( ; atrv != NULL; atrv = atrv->link) { 1072 switch (atrv->attr) { 1073 #ifdef DEBUG 1074 default: 1075 fprintf(df, "\n# dump error:\n" 1076 "# unknown trap token %d\n" 1077 "trap %s", atrv->attr, 1078 addr->address); 1079 break; 1080 #endif 1081 case T_Port: 1082 fprintf(df, " port %d", atrv->value.i); 1083 break; 1084 1085 case T_Interface: 1086 fprintf(df, " interface %s", 1087 atrv->value.s); 1088 break; 1089 } 1090 } 1091 fprintf(df, "\n"); 1092 } 1093 1094 counter_set = HEAD_PFIFO(ptree->reset_counters); 1095 if (counter_set != NULL) { 1096 fprintf(df, "reset"); 1097 for ( ; counter_set != NULL; 1098 counter_set = counter_set->link) 1099 fprintf(df, " %s", keyword(counter_set->i)); 1100 fprintf(df, "\n"); 1101 } 1102 1103 return 0; 1104 } 1105 #endif /* SAVECONFIG */ 1106 1107 1108 /* generic fifo routines for structs linked by 1st member */ 1109 void * 1110 append_gen_fifo( 1111 void *fifo, 1112 void *entry 1113 ) 1114 { 1115 gen_fifo *pf; 1116 gen_node *pe; 1117 1118 pf = fifo; 1119 pe = entry; 1120 if (NULL == pf) 1121 pf = emalloc_zero(sizeof(*pf)); 1122 else 1123 CHECK_FIFO_CONSISTENCY(*pf); 1124 if (pe != NULL) 1125 LINK_FIFO(*pf, pe, link); 1126 CHECK_FIFO_CONSISTENCY(*pf); 1127 1128 return pf; 1129 } 1130 1131 1132 void * 1133 concat_gen_fifos( 1134 void *first, 1135 void *second 1136 ) 1137 { 1138 gen_fifo *pf1; 1139 gen_fifo *pf2; 1140 1141 pf1 = first; 1142 pf2 = second; 1143 if (NULL == pf1) 1144 return pf2; 1145 if (NULL == pf2) 1146 return pf1; 1147 1148 CONCAT_FIFO(*pf1, *pf2, link); 1149 free(pf2); 1150 1151 return pf1; 1152 } 1153 1154 void* 1155 destroy_gen_fifo( 1156 void *fifo, 1157 fifo_deleter func 1158 ) 1159 { 1160 any_node * np = NULL; 1161 any_node_fifo * pf1 = fifo; 1162 1163 if (pf1 != NULL) { 1164 if (!func) 1165 func = free; 1166 for (;;) { 1167 UNLINK_FIFO(np, *pf1, link); 1168 if (np == NULL) 1169 break; 1170 (*func)(np); 1171 } 1172 free(pf1); 1173 } 1174 return NULL; 1175 } 1176 1177 /* FUNCTIONS FOR CREATING NODES ON THE SYNTAX TREE 1178 * ----------------------------------------------- 1179 */ 1180 1181 void 1182 destroy_attr_val( 1183 attr_val * av 1184 ) 1185 { 1186 if (av) { 1187 if (T_String == av->type) 1188 free(av->value.s); 1189 free(av); 1190 } 1191 } 1192 1193 attr_val * 1194 create_attr_dval( 1195 int attr, 1196 double value 1197 ) 1198 { 1199 attr_val *my_val; 1200 1201 my_val = emalloc_zero(sizeof(*my_val)); 1202 my_val->attr = attr; 1203 my_val->value.d = value; 1204 my_val->type = T_Double; 1205 1206 return my_val; 1207 } 1208 1209 1210 attr_val * 1211 create_attr_ival( 1212 int attr, 1213 int value 1214 ) 1215 { 1216 attr_val *my_val; 1217 1218 my_val = emalloc_zero(sizeof(*my_val)); 1219 my_val->attr = attr; 1220 my_val->value.i = value; 1221 my_val->type = T_Integer; 1222 1223 return my_val; 1224 } 1225 1226 1227 attr_val * 1228 create_attr_uval( 1229 int attr, 1230 u_int value 1231 ) 1232 { 1233 attr_val *my_val; 1234 1235 my_val = emalloc_zero(sizeof(*my_val)); 1236 my_val->attr = attr; 1237 my_val->value.u = value; 1238 my_val->type = T_U_int; 1239 1240 return my_val; 1241 } 1242 1243 1244 attr_val * 1245 create_attr_rval( 1246 int attr, 1247 int first, 1248 int last 1249 ) 1250 { 1251 attr_val *my_val; 1252 1253 my_val = emalloc_zero(sizeof(*my_val)); 1254 my_val->attr = attr; 1255 my_val->value.r.first = first; 1256 my_val->value.r.last = last; 1257 my_val->type = T_Intrange; 1258 1259 return my_val; 1260 } 1261 1262 1263 attr_val * 1264 create_attr_sval( 1265 int attr, 1266 const char *s 1267 ) 1268 { 1269 attr_val *my_val; 1270 1271 my_val = emalloc_zero(sizeof(*my_val)); 1272 my_val->attr = attr; 1273 if (NULL == s) /* free() hates NULL */ 1274 s = estrdup(""); 1275 my_val->value.s = _UC(s); 1276 my_val->type = T_String; 1277 1278 return my_val; 1279 } 1280 1281 1282 int_node * 1283 create_int_node( 1284 int val 1285 ) 1286 { 1287 int_node *i_n; 1288 1289 i_n = emalloc_zero(sizeof(*i_n)); 1290 i_n->i = val; 1291 1292 return i_n; 1293 } 1294 1295 1296 string_node * 1297 create_string_node( 1298 char *str 1299 ) 1300 { 1301 string_node *sn; 1302 1303 sn = emalloc_zero(sizeof(*sn)); 1304 sn->s = str; 1305 1306 return sn; 1307 } 1308 1309 1310 address_node * 1311 create_address_node( 1312 char * addr, 1313 int type 1314 ) 1315 { 1316 address_node *my_node; 1317 1318 REQUIRE(NULL != addr); 1319 REQUIRE(AF_INET == type || AF_INET6 == type || AF_UNSPEC == type); 1320 my_node = emalloc_zero(sizeof(*my_node)); 1321 my_node->address = addr; 1322 my_node->type = (u_short)type; 1323 1324 return my_node; 1325 } 1326 1327 1328 void 1329 destroy_address_node( 1330 address_node *my_node 1331 ) 1332 { 1333 if (NULL == my_node) 1334 return; 1335 REQUIRE(NULL != my_node->address); 1336 1337 free(my_node->address); 1338 free(my_node); 1339 } 1340 1341 1342 peer_node * 1343 create_peer_node( 1344 int hmode, 1345 address_node * addr, 1346 attr_val_fifo * options 1347 ) 1348 { 1349 peer_node *my_node; 1350 attr_val *option; 1351 int freenode; 1352 int errflag = 0; 1353 1354 my_node = emalloc_zero(sizeof(*my_node)); 1355 1356 /* Initialize node values to default */ 1357 my_node->peerversion = NTP_VERSION; 1358 1359 /* Now set the node to the read values */ 1360 my_node->host_mode = hmode; 1361 my_node->addr = addr; 1362 1363 /* 1364 * the options FIFO mixes items that will be saved in the 1365 * peer_node as explicit members, such as minpoll, and 1366 * those that are moved intact to the peer_node's peerflags 1367 * FIFO. The options FIFO is consumed and reclaimed here. 1368 */ 1369 1370 if (options != NULL) 1371 CHECK_FIFO_CONSISTENCY(*options); 1372 while (options != NULL) { 1373 UNLINK_FIFO(option, *options, link); 1374 if (NULL == option) { 1375 free(options); 1376 break; 1377 } 1378 1379 freenode = 1; 1380 /* Check the kind of option being set */ 1381 switch (option->attr) { 1382 1383 case T_Flag: 1384 APPEND_G_FIFO(my_node->peerflags, option); 1385 freenode = 0; 1386 break; 1387 1388 case T_Minpoll: 1389 if (option->value.i < NTP_MINPOLL || 1390 option->value.i > UCHAR_MAX) { 1391 msyslog(LOG_INFO, 1392 "minpoll: provided value (%d) is out of range [%d-%d])", 1393 option->value.i, NTP_MINPOLL, 1394 UCHAR_MAX); 1395 my_node->minpoll = NTP_MINPOLL; 1396 } else { 1397 my_node->minpoll = 1398 (u_char)option->value.u; 1399 } 1400 break; 1401 1402 case T_Maxpoll: 1403 if (option->value.i < 0 || 1404 option->value.i > NTP_MAXPOLL) { 1405 msyslog(LOG_INFO, 1406 "maxpoll: provided value (%d) is out of range [0-%d])", 1407 option->value.i, NTP_MAXPOLL); 1408 my_node->maxpoll = NTP_MAXPOLL; 1409 } else { 1410 my_node->maxpoll = 1411 (u_char)option->value.u; 1412 } 1413 break; 1414 1415 case T_Ttl: 1416 if (is_refclk_addr(addr)) { 1417 msyslog(LOG_ERR, "'ttl' does not apply for refclocks"); 1418 errflag = 1; 1419 } else if (option->value.u >= MAX_TTL) { 1420 msyslog(LOG_ERR, "ttl: invalid argument"); 1421 errflag = 1; 1422 } else { 1423 my_node->ttl = (u_char)option->value.u; 1424 } 1425 break; 1426 1427 case T_Mode: 1428 if (is_refclk_addr(addr)) { 1429 my_node->ttl = option->value.u; 1430 } else { 1431 msyslog(LOG_ERR, "'mode' does not apply for network peers"); 1432 errflag = 1; 1433 } 1434 break; 1435 1436 case T_Key: 1437 if (option->value.u >= KEYID_T_MAX) { 1438 msyslog(LOG_ERR, "key: invalid argument"); 1439 errflag = 1; 1440 } else { 1441 my_node->peerkey = 1442 (keyid_t)option->value.u; 1443 } 1444 break; 1445 1446 case T_Version: 1447 if (option->value.u >= UCHAR_MAX) { 1448 msyslog(LOG_ERR, "version: invalid argument"); 1449 errflag = 1; 1450 } else { 1451 my_node->peerversion = 1452 (u_char)option->value.u; 1453 } 1454 break; 1455 1456 case T_Ident: 1457 my_node->group = option->value.s; 1458 break; 1459 1460 default: 1461 msyslog(LOG_ERR, 1462 "Unknown peer/server option token %s", 1463 token_name(option->attr)); 1464 errflag = 1; 1465 } 1466 if (freenode) 1467 free(option); 1468 } 1469 1470 /* Check if errors were reported. If yes, ignore the node */ 1471 if (errflag) { 1472 free(my_node); 1473 my_node = NULL; 1474 } 1475 1476 return my_node; 1477 } 1478 1479 1480 unpeer_node * 1481 create_unpeer_node( 1482 address_node *addr 1483 ) 1484 { 1485 unpeer_node * my_node; 1486 u_long u; 1487 const u_char * pch; 1488 1489 my_node = emalloc_zero(sizeof(*my_node)); 1490 1491 /* 1492 * From the parser's perspective an association ID fits into 1493 * its generic T_String definition of a name/address "address". 1494 * We treat all valid 16-bit numbers as association IDs. 1495 */ 1496 for (u = 0, pch = (u_char*)addr->address; isdigit(*pch); ++pch) { 1497 /* accumulate with overflow retention */ 1498 u = (10 * u + *pch - '0') | (u & 0xFF000000u); 1499 } 1500 1501 if (!*pch && u <= ASSOCID_MAX) { 1502 my_node->assocID = (associd_t)u; 1503 my_node->addr = NULL; 1504 destroy_address_node(addr); 1505 } else { 1506 my_node->assocID = 0; 1507 my_node->addr = addr; 1508 } 1509 1510 return my_node; 1511 } 1512 1513 filegen_node * 1514 create_filegen_node( 1515 int filegen_token, 1516 attr_val_fifo * options 1517 ) 1518 { 1519 filegen_node *my_node; 1520 1521 my_node = emalloc_zero(sizeof(*my_node)); 1522 my_node->filegen_token = filegen_token; 1523 my_node->options = options; 1524 1525 return my_node; 1526 } 1527 1528 1529 restrict_node * 1530 create_restrict_node( 1531 address_node * addr, 1532 address_node * mask, 1533 short ippeerlimit, 1534 attr_val_fifo * flag_tok_fifo, 1535 int nline 1536 ) 1537 { 1538 restrict_node *my_node; 1539 1540 my_node = emalloc_zero(sizeof(*my_node)); 1541 my_node->addr = addr; 1542 my_node->mask = mask; 1543 my_node->ippeerlimit = ippeerlimit; 1544 my_node->flag_tok_fifo = flag_tok_fifo; 1545 my_node->line_no = nline; 1546 1547 return my_node; 1548 } 1549 1550 1551 static void 1552 destroy_restrict_node( 1553 restrict_node *my_node 1554 ) 1555 { 1556 /* With great care, free all the memory occupied by 1557 * the restrict node 1558 */ 1559 destroy_address_node(my_node->addr); 1560 destroy_address_node(my_node->mask); 1561 destroy_attr_val_fifo(my_node->flag_tok_fifo); 1562 free(my_node); 1563 } 1564 1565 1566 static void 1567 destroy_int_fifo( 1568 int_fifo * fifo 1569 ) 1570 { 1571 int_node * i_n; 1572 1573 if (fifo != NULL) { 1574 for (;;) { 1575 UNLINK_FIFO(i_n, *fifo, link); 1576 if (i_n == NULL) 1577 break; 1578 free(i_n); 1579 } 1580 free(fifo); 1581 } 1582 } 1583 1584 1585 static void 1586 destroy_string_fifo( 1587 string_fifo * fifo 1588 ) 1589 { 1590 string_node * sn; 1591 1592 if (fifo != NULL) { 1593 for (;;) { 1594 UNLINK_FIFO(sn, *fifo, link); 1595 if (sn == NULL) 1596 break; 1597 free(sn->s); 1598 free(sn); 1599 } 1600 free(fifo); 1601 } 1602 } 1603 1604 1605 static void 1606 destroy_attr_val_fifo( 1607 attr_val_fifo * av_fifo 1608 ) 1609 { 1610 attr_val * av; 1611 1612 if (av_fifo != NULL) { 1613 for (;;) { 1614 UNLINK_FIFO(av, *av_fifo, link); 1615 if (av == NULL) 1616 break; 1617 destroy_attr_val(av); 1618 } 1619 free(av_fifo); 1620 } 1621 } 1622 1623 1624 static void 1625 destroy_filegen_fifo( 1626 filegen_fifo * fifo 1627 ) 1628 { 1629 filegen_node * fg; 1630 1631 if (fifo != NULL) { 1632 for (;;) { 1633 UNLINK_FIFO(fg, *fifo, link); 1634 if (fg == NULL) 1635 break; 1636 destroy_attr_val_fifo(fg->options); 1637 free(fg); 1638 } 1639 free(fifo); 1640 } 1641 } 1642 1643 1644 static void 1645 destroy_restrict_fifo( 1646 restrict_fifo * fifo 1647 ) 1648 { 1649 restrict_node * rn; 1650 1651 if (fifo != NULL) { 1652 for (;;) { 1653 UNLINK_FIFO(rn, *fifo, link); 1654 if (rn == NULL) 1655 break; 1656 destroy_restrict_node(rn); 1657 } 1658 free(fifo); 1659 } 1660 } 1661 1662 1663 static void 1664 destroy_setvar_fifo( 1665 setvar_fifo * fifo 1666 ) 1667 { 1668 setvar_node * sv; 1669 1670 if (fifo != NULL) { 1671 for (;;) { 1672 UNLINK_FIFO(sv, *fifo, link); 1673 if (sv == NULL) 1674 break; 1675 free(sv->var); 1676 free(sv->val); 1677 free(sv); 1678 } 1679 free(fifo); 1680 } 1681 } 1682 1683 1684 static void 1685 destroy_addr_opts_fifo( 1686 addr_opts_fifo * fifo 1687 ) 1688 { 1689 addr_opts_node * aon; 1690 1691 if (fifo != NULL) { 1692 for (;;) { 1693 UNLINK_FIFO(aon, *fifo, link); 1694 if (aon == NULL) 1695 break; 1696 destroy_address_node(aon->addr); 1697 destroy_attr_val_fifo(aon->options); 1698 free(aon); 1699 } 1700 free(fifo); 1701 } 1702 } 1703 1704 1705 setvar_node * 1706 create_setvar_node( 1707 char * var, 1708 char * val, 1709 int isdefault 1710 ) 1711 { 1712 setvar_node * my_node; 1713 char * pch; 1714 1715 /* do not allow = in the variable name */ 1716 pch = strchr(var, '='); 1717 if (NULL != pch) 1718 *pch = '\0'; 1719 1720 /* Now store the string into a setvar_node */ 1721 my_node = emalloc_zero(sizeof(*my_node)); 1722 my_node->var = var; 1723 my_node->val = val; 1724 my_node->isdefault = isdefault; 1725 1726 return my_node; 1727 } 1728 1729 1730 nic_rule_node * 1731 create_nic_rule_node( 1732 int match_class, 1733 char *if_name, /* interface name or numeric address */ 1734 int action 1735 ) 1736 { 1737 nic_rule_node *my_node; 1738 1739 REQUIRE(match_class != 0 || if_name != NULL); 1740 1741 my_node = emalloc_zero(sizeof(*my_node)); 1742 my_node->match_class = match_class; 1743 my_node->if_name = if_name; 1744 my_node->action = action; 1745 1746 return my_node; 1747 } 1748 1749 1750 addr_opts_node * 1751 create_addr_opts_node( 1752 address_node * addr, 1753 attr_val_fifo * options 1754 ) 1755 { 1756 addr_opts_node *my_node; 1757 1758 my_node = emalloc_zero(sizeof(*my_node)); 1759 my_node->addr = addr; 1760 my_node->options = options; 1761 1762 return my_node; 1763 } 1764 1765 1766 #ifdef SIM 1767 script_info * 1768 create_sim_script_info( 1769 double duration, 1770 attr_val_fifo * script_queue 1771 ) 1772 { 1773 script_info *my_info; 1774 attr_val *my_attr_val; 1775 1776 my_info = emalloc_zero(sizeof(*my_info)); 1777 1778 /* Initialize Script Info with default values*/ 1779 my_info->duration = duration; 1780 my_info->prop_delay = NET_DLY; 1781 my_info->proc_delay = PROC_DLY; 1782 1783 /* Traverse the script_queue and fill out non-default values */ 1784 1785 for (my_attr_val = HEAD_PFIFO(script_queue); 1786 my_attr_val != NULL; 1787 my_attr_val = my_attr_val->link) { 1788 1789 /* Set the desired value */ 1790 switch (my_attr_val->attr) { 1791 1792 case T_Freq_Offset: 1793 my_info->freq_offset = my_attr_val->value.d; 1794 break; 1795 1796 case T_Wander: 1797 my_info->wander = my_attr_val->value.d; 1798 break; 1799 1800 case T_Jitter: 1801 my_info->jitter = my_attr_val->value.d; 1802 break; 1803 1804 case T_Prop_Delay: 1805 my_info->prop_delay = my_attr_val->value.d; 1806 break; 1807 1808 case T_Proc_Delay: 1809 my_info->proc_delay = my_attr_val->value.d; 1810 break; 1811 1812 default: 1813 msyslog(LOG_ERR, "Unknown script token %d", 1814 my_attr_val->attr); 1815 } 1816 } 1817 1818 return my_info; 1819 } 1820 #endif /* SIM */ 1821 1822 1823 #ifdef SIM 1824 static sockaddr_u * 1825 get_next_address( 1826 address_node *addr 1827 ) 1828 { 1829 const char addr_prefix[] = "192.168.0."; 1830 static int curr_addr_num = 1; 1831 #define ADDR_LENGTH 16 + 1 /* room for 192.168.1.255 */ 1832 char addr_string[ADDR_LENGTH]; 1833 sockaddr_u *final_addr; 1834 struct addrinfo *ptr; 1835 int gai_err; 1836 1837 final_addr = emalloc(sizeof(*final_addr)); 1838 1839 if (addr->type == T_String) { 1840 snprintf(addr_string, sizeof(addr_string), "%s%d", 1841 addr_prefix, curr_addr_num++); 1842 printf("Selecting ip address %s for hostname %s\n", 1843 addr_string, addr->address); 1844 gai_err = getaddrinfo(addr_string, "ntp", NULL, &ptr); 1845 } else { 1846 gai_err = getaddrinfo(addr->address, "ntp", NULL, &ptr); 1847 } 1848 1849 if (gai_err) { 1850 fprintf(stderr, "ERROR!! Could not get a new address\n"); 1851 exit(1); 1852 } 1853 memcpy(final_addr, ptr->ai_addr, ptr->ai_addrlen); 1854 fprintf(stderr, "Successful in setting ip address of simulated server to: %s\n", 1855 stoa(final_addr)); 1856 freeaddrinfo(ptr); 1857 1858 return final_addr; 1859 } 1860 #endif /* SIM */ 1861 1862 1863 #ifdef SIM 1864 server_info * 1865 create_sim_server( 1866 address_node * addr, 1867 double server_offset, 1868 script_info_fifo * script 1869 ) 1870 { 1871 server_info *my_info; 1872 1873 my_info = emalloc_zero(sizeof(*my_info)); 1874 my_info->server_time = server_offset; 1875 my_info->addr = get_next_address(addr); 1876 my_info->script = script; 1877 UNLINK_FIFO(my_info->curr_script, *my_info->script, link); 1878 1879 return my_info; 1880 } 1881 #endif /* SIM */ 1882 1883 sim_node * 1884 create_sim_node( 1885 attr_val_fifo * init_opts, 1886 server_info_fifo * servers 1887 ) 1888 { 1889 sim_node *my_node; 1890 1891 my_node = emalloc(sizeof(*my_node)); 1892 my_node->init_opts = init_opts; 1893 my_node->servers = servers; 1894 1895 return my_node; 1896 } 1897 1898 1899 1900 1901 /* FUNCTIONS FOR PERFORMING THE CONFIGURATION 1902 * ------------------------------------------ 1903 */ 1904 1905 #ifndef SIM 1906 static void 1907 config_other_modes( 1908 config_tree * ptree 1909 ) 1910 { 1911 sockaddr_u addr_sock; 1912 address_node * addr_node; 1913 1914 if (ptree->broadcastclient) 1915 proto_config(PROTO_BROADCLIENT, ptree->broadcastclient, 1916 0., NULL); 1917 1918 addr_node = HEAD_PFIFO(ptree->manycastserver); 1919 while (addr_node != NULL) { 1920 ZERO_SOCK(&addr_sock); 1921 AF(&addr_sock) = addr_node->type; 1922 if (1 == getnetnum(addr_node->address, &addr_sock, 1, 1923 t_UNK)) { 1924 proto_config(PROTO_MULTICAST_ADD, 1925 0, 0., &addr_sock); 1926 sys_manycastserver = 1; 1927 } 1928 addr_node = addr_node->link; 1929 } 1930 1931 /* Configure the multicast clients */ 1932 addr_node = HEAD_PFIFO(ptree->multicastclient); 1933 if (addr_node != NULL) { 1934 do { 1935 ZERO_SOCK(&addr_sock); 1936 AF(&addr_sock) = addr_node->type; 1937 if (1 == getnetnum(addr_node->address, 1938 &addr_sock, 1, t_UNK)) { 1939 proto_config(PROTO_MULTICAST_ADD, 0, 0., 1940 &addr_sock); 1941 } 1942 addr_node = addr_node->link; 1943 } while (addr_node != NULL); 1944 proto_config(PROTO_MULTICAST_ADD, 1, 0., NULL); 1945 } 1946 } 1947 #endif /* !SIM */ 1948 1949 1950 #ifdef FREE_CFG_T 1951 static void 1952 destroy_address_fifo( 1953 address_fifo * pfifo 1954 ) 1955 { 1956 address_node * addr_node; 1957 1958 if (pfifo != NULL) { 1959 for (;;) { 1960 UNLINK_FIFO(addr_node, *pfifo, link); 1961 if (addr_node == NULL) 1962 break; 1963 destroy_address_node(addr_node); 1964 } 1965 free(pfifo); 1966 } 1967 } 1968 1969 1970 static void 1971 free_config_other_modes( 1972 config_tree *ptree 1973 ) 1974 { 1975 FREE_ADDRESS_FIFO(ptree->manycastserver); 1976 FREE_ADDRESS_FIFO(ptree->multicastclient); 1977 } 1978 #endif /* FREE_CFG_T */ 1979 1980 1981 #ifndef SIM 1982 static void 1983 config_auth( 1984 config_tree *ptree 1985 ) 1986 { 1987 attr_val * my_val; 1988 int first; 1989 int last; 1990 int i; 1991 int count; 1992 #ifdef AUTOKEY 1993 int item; 1994 #endif 1995 1996 /* Crypto Command */ 1997 #ifdef AUTOKEY 1998 my_val = HEAD_PFIFO(ptree->auth.crypto_cmd_list); 1999 for (; my_val != NULL; my_val = my_val->link) { 2000 switch (my_val->attr) { 2001 2002 default: 2003 fatal_error("config_auth: attr-token=%d", my_val->attr); 2004 2005 case T_Host: 2006 item = CRYPTO_CONF_PRIV; 2007 break; 2008 2009 case T_Ident: 2010 item = CRYPTO_CONF_IDENT; 2011 break; 2012 2013 case T_Pw: 2014 item = CRYPTO_CONF_PW; 2015 break; 2016 2017 case T_Randfile: 2018 item = CRYPTO_CONF_RAND; 2019 break; 2020 2021 case T_Digest: 2022 item = CRYPTO_CONF_NID; 2023 break; 2024 } 2025 crypto_config(item, my_val->value.s); 2026 } 2027 #endif /* AUTOKEY */ 2028 2029 /* Keysdir Command */ 2030 if (ptree->auth.keysdir) { 2031 if (keysdir != default_keysdir) 2032 free(keysdir); 2033 keysdir = estrdup(ptree->auth.keysdir); 2034 } 2035 2036 2037 /* ntp_signd_socket Command */ 2038 if (ptree->auth.ntp_signd_socket) { 2039 if (ntp_signd_socket != default_ntp_signd_socket) 2040 free(ntp_signd_socket); 2041 ntp_signd_socket = estrdup(ptree->auth.ntp_signd_socket); 2042 } 2043 2044 #ifdef AUTOKEY 2045 if (ptree->auth.cryptosw && !cryptosw) { 2046 crypto_setup(); 2047 cryptosw = 1; 2048 } 2049 #endif /* AUTOKEY */ 2050 2051 /* 2052 * Count the number of trusted keys to preallocate storage and 2053 * size the hash table. 2054 */ 2055 count = 0; 2056 my_val = HEAD_PFIFO(ptree->auth.trusted_key_list); 2057 for (; my_val != NULL; my_val = my_val->link) { 2058 if (T_Integer == my_val->type) { 2059 first = my_val->value.i; 2060 if (first > 1 && first <= NTP_MAXKEY) 2061 count++; 2062 } else { 2063 REQUIRE(T_Intrange == my_val->type); 2064 first = my_val->value.r.first; 2065 last = my_val->value.r.last; 2066 if (!(first > last || first < 1 || 2067 last > NTP_MAXKEY)) { 2068 count += 1 + last - first; 2069 } 2070 } 2071 } 2072 auth_prealloc_symkeys(count); 2073 2074 /* Keys Command */ 2075 if (ptree->auth.keys) 2076 getauthkeys(ptree->auth.keys); 2077 2078 /* Control Key Command */ 2079 if (ptree->auth.control_key) 2080 ctl_auth_keyid = (keyid_t)ptree->auth.control_key; 2081 2082 /* Requested Key Command */ 2083 if (ptree->auth.request_key) { 2084 DPRINTF(4, ("set info_auth_keyid to %08lx\n", 2085 (u_long) ptree->auth.request_key)); 2086 info_auth_keyid = (keyid_t)ptree->auth.request_key; 2087 } 2088 2089 /* Trusted Key Command */ 2090 my_val = HEAD_PFIFO(ptree->auth.trusted_key_list); 2091 for (; my_val != NULL; my_val = my_val->link) { 2092 if (T_Integer == my_val->type) { 2093 first = my_val->value.i; 2094 if (first >= 1 && first <= NTP_MAXKEY) { 2095 authtrust(first, TRUE); 2096 } else { 2097 msyslog(LOG_NOTICE, 2098 "Ignoring invalid trustedkey %d, min 1 max %d.", 2099 first, NTP_MAXKEY); 2100 } 2101 } else { 2102 first = my_val->value.r.first; 2103 last = my_val->value.r.last; 2104 if (first > last || first < 1 || 2105 last > NTP_MAXKEY) { 2106 msyslog(LOG_NOTICE, 2107 "Ignoring invalid trustedkey range %d ... %d, min 1 max %d.", 2108 first, last, NTP_MAXKEY); 2109 } else { 2110 for (i = first; i <= last; i++) { 2111 authtrust(i, TRUE); 2112 } 2113 } 2114 } 2115 } 2116 2117 #ifdef AUTOKEY 2118 /* crypto revoke command */ 2119 if (ptree->auth.revoke > 2 && ptree->auth.revoke < 32) 2120 sys_revoke = (u_char)ptree->auth.revoke; 2121 else if (ptree->auth.revoke) 2122 msyslog(LOG_ERR, 2123 "'revoke' value %d ignored", 2124 ptree->auth.revoke); 2125 #endif /* AUTOKEY */ 2126 } 2127 #endif /* !SIM */ 2128 2129 2130 #ifdef FREE_CFG_T 2131 static void 2132 free_config_auth( 2133 config_tree *ptree 2134 ) 2135 { 2136 destroy_attr_val_fifo(ptree->auth.crypto_cmd_list); 2137 ptree->auth.crypto_cmd_list = NULL; 2138 destroy_attr_val_fifo(ptree->auth.trusted_key_list); 2139 ptree->auth.trusted_key_list = NULL; 2140 } 2141 #endif /* FREE_CFG_T */ 2142 2143 2144 /* Configure low-level clock-related parameters. Return TRUE if the 2145 * clock might need adjustment like era-checking after the call, FALSE 2146 * otherwise. 2147 */ 2148 static int/*BOOL*/ 2149 config_tos_clock( 2150 config_tree *ptree 2151 ) 2152 { 2153 int ret; 2154 attr_val * tos; 2155 2156 ret = FALSE; 2157 tos = HEAD_PFIFO(ptree->orphan_cmds); 2158 for (; tos != NULL; tos = tos->link) { 2159 switch(tos->attr) { 2160 2161 default: 2162 break; 2163 2164 case T_Basedate: 2165 basedate_set_day(tos->value.i); 2166 ret = TRUE; 2167 break; 2168 } 2169 } 2170 2171 if (basedate_get_day() <= NTP_TO_UNIX_DAYS) 2172 basedate_set_day(basedate_eval_buildstamp() - 11); 2173 2174 return ret; 2175 } 2176 2177 static void 2178 config_tos( 2179 config_tree *ptree 2180 ) 2181 { 2182 attr_val * tos; 2183 int item; 2184 double val; 2185 2186 /* [Bug 2896] For the daemon to work properly it is essential 2187 * that minsane < minclock <= maxclock. 2188 * 2189 * If either constraint is violated, the daemon will be or might 2190 * become dysfunctional. Fixing the values is too fragile here, 2191 * since three variables with interdependecies are involved. We 2192 * just log an error but do not stop: This might be caused by 2193 * remote config, and it might be fixed by remote config, too. 2194 */ 2195 int l_maxclock = sys_maxclock; 2196 int l_minclock = sys_minclock; 2197 int l_minsane = sys_minsane; 2198 2199 /* -*- phase one: inspect / sanitize the values */ 2200 tos = HEAD_PFIFO(ptree->orphan_cmds); 2201 for (; tos != NULL; tos = tos->link) { 2202 /* not all attributes are doubles (any more), so loading 2203 * 'val' in all cases is not a good idea: It should be 2204 * done as needed in every case processed here. 2205 */ 2206 switch(tos->attr) { 2207 default: 2208 break; 2209 2210 case T_Bcpollbstep: 2211 val = tos->value.d; 2212 if (val > 4) { 2213 msyslog(LOG_WARNING, 2214 "Using maximum bcpollbstep ceiling %d, %d requested", 2215 4, (int)val); 2216 tos->value.d = 4; 2217 } else if (val < 0) { 2218 msyslog(LOG_WARNING, 2219 "Using minimum bcpollbstep floor %d, %d requested", 2220 0, (int)val); 2221 tos->value.d = 0; 2222 } 2223 break; 2224 2225 case T_Ceiling: 2226 val = tos->value.d; 2227 if (val > STRATUM_UNSPEC - 1) { 2228 msyslog(LOG_WARNING, 2229 "Using maximum tos ceiling %d, %d requested", 2230 STRATUM_UNSPEC - 1, (int)val); 2231 tos->value.d = STRATUM_UNSPEC - 1; 2232 } else if (val < 1) { 2233 msyslog(LOG_WARNING, 2234 "Using minimum tos floor %d, %d requested", 2235 1, (int)val); 2236 tos->value.d = 1; 2237 } 2238 break; 2239 2240 case T_Minclock: 2241 val = tos->value.d; 2242 if ((int)tos->value.d < 1) 2243 tos->value.d = 1; 2244 l_minclock = (int)tos->value.d; 2245 break; 2246 2247 case T_Maxclock: 2248 val = tos->value.d; 2249 if ((int)tos->value.d < 1) 2250 tos->value.d = 1; 2251 l_maxclock = (int)tos->value.d; 2252 break; 2253 2254 case T_Minsane: 2255 val = tos->value.d; 2256 if ((int)tos->value.d < 0) 2257 tos->value.d = 0; 2258 l_minsane = (int)tos->value.d; 2259 break; 2260 } 2261 } 2262 2263 if ( ! (l_minsane < l_minclock && l_minclock <= l_maxclock)) { 2264 msyslog(LOG_ERR, 2265 "tos error: must have minsane (%d) < minclock (%d) <= maxclock (%d)" 2266 " - daemon will not operate properly!", 2267 l_minsane, l_minclock, l_maxclock); 2268 } 2269 2270 /* -*- phase two: forward the values to the protocol machinery */ 2271 tos = HEAD_PFIFO(ptree->orphan_cmds); 2272 for (; tos != NULL; tos = tos->link) { 2273 switch(tos->attr) { 2274 2275 default: 2276 fatal_error("config-tos: attr-token=%d", tos->attr); 2277 2278 case T_Bcpollbstep: 2279 item = PROTO_BCPOLLBSTEP; 2280 break; 2281 2282 case T_Ceiling: 2283 item = PROTO_CEILING; 2284 break; 2285 2286 case T_Floor: 2287 item = PROTO_FLOOR; 2288 break; 2289 2290 case T_Cohort: 2291 item = PROTO_COHORT; 2292 break; 2293 2294 case T_Orphan: 2295 item = PROTO_ORPHAN; 2296 break; 2297 2298 case T_Orphanwait: 2299 item = PROTO_ORPHWAIT; 2300 break; 2301 2302 case T_Mindist: 2303 item = PROTO_MINDISP; 2304 break; 2305 2306 case T_Maxdist: 2307 item = PROTO_MAXDIST; 2308 break; 2309 2310 case T_Minclock: 2311 item = PROTO_MINCLOCK; 2312 break; 2313 2314 case T_Maxclock: 2315 item = PROTO_MAXCLOCK; 2316 break; 2317 2318 case T_Minsane: 2319 item = PROTO_MINSANE; 2320 break; 2321 2322 case T_Beacon: 2323 item = PROTO_BEACON; 2324 break; 2325 2326 case T_Basedate: 2327 continue; /* SKIP proto-config for this! */ 2328 } 2329 proto_config(item, 0, tos->value.d, NULL); 2330 } 2331 } 2332 2333 2334 #ifdef FREE_CFG_T 2335 static void 2336 free_config_tos( 2337 config_tree *ptree 2338 ) 2339 { 2340 FREE_ATTR_VAL_FIFO(ptree->orphan_cmds); 2341 } 2342 #endif /* FREE_CFG_T */ 2343 2344 2345 static void 2346 config_monitor( 2347 config_tree *ptree 2348 ) 2349 { 2350 int_node *pfilegen_token; 2351 const char *filegen_string; 2352 const char *filegen_file; 2353 FILEGEN *filegen; 2354 filegen_node *my_node; 2355 attr_val *my_opts; 2356 int filegen_type; 2357 int filegen_flag; 2358 2359 /* Set the statistics directory */ 2360 if (ptree->stats_dir) 2361 stats_config(STATS_STATSDIR, ptree->stats_dir, 0); 2362 2363 /* NOTE: 2364 * Calling filegen_get is brain dead. Doing a string 2365 * comparison to find the relavant filegen structure is 2366 * expensive. 2367 * 2368 * Through the parser, we already know which filegen is 2369 * being specified. Hence, we should either store a 2370 * pointer to the specified structure in the syntax tree 2371 * or an index into a filegen array. 2372 * 2373 * Need to change the filegen code to reflect the above. 2374 */ 2375 2376 /* Turn on the specified statistics */ 2377 pfilegen_token = HEAD_PFIFO(ptree->stats_list); 2378 for (; pfilegen_token != NULL; pfilegen_token = pfilegen_token->link) { 2379 filegen_string = keyword(pfilegen_token->i); 2380 filegen = filegen_get(filegen_string); 2381 if (NULL == filegen) { 2382 msyslog(LOG_ERR, 2383 "stats %s unrecognized", 2384 filegen_string); 2385 continue; 2386 } 2387 DPRINTF(4, ("enabling filegen for %s statistics '%s%s'\n", 2388 filegen_string, filegen->dir, 2389 filegen->fname)); 2390 filegen_flag = filegen->flag; 2391 filegen_flag |= FGEN_FLAG_ENABLED; 2392 filegen_config(filegen, statsdir, filegen_string, 2393 filegen->type, filegen_flag); 2394 } 2395 2396 /* Configure the statistics with the options */ 2397 my_node = HEAD_PFIFO(ptree->filegen_opts); 2398 for (; my_node != NULL; my_node = my_node->link) { 2399 filegen_string = keyword(my_node->filegen_token); 2400 filegen = filegen_get(filegen_string); 2401 if (NULL == filegen) { 2402 msyslog(LOG_ERR, 2403 "filegen category '%s' unrecognized", 2404 filegen_string); 2405 continue; 2406 } 2407 filegen_file = filegen_string; 2408 2409 /* Initialize the filegen variables to their pre-configuration states */ 2410 filegen_flag = filegen->flag; 2411 filegen_type = filegen->type; 2412 2413 /* "filegen ... enabled" is the default (when filegen is used) */ 2414 filegen_flag |= FGEN_FLAG_ENABLED; 2415 2416 my_opts = HEAD_PFIFO(my_node->options); 2417 for (; my_opts != NULL; my_opts = my_opts->link) { 2418 switch (my_opts->attr) { 2419 2420 case T_File: 2421 filegen_file = my_opts->value.s; 2422 break; 2423 2424 case T_Type: 2425 switch (my_opts->value.i) { 2426 2427 default: 2428 fatal_error("config-monitor: type-token=%d", my_opts->value.i); 2429 2430 case T_None: 2431 filegen_type = FILEGEN_NONE; 2432 break; 2433 2434 case T_Pid: 2435 filegen_type = FILEGEN_PID; 2436 break; 2437 2438 case T_Day: 2439 filegen_type = FILEGEN_DAY; 2440 break; 2441 2442 case T_Week: 2443 filegen_type = FILEGEN_WEEK; 2444 break; 2445 2446 case T_Month: 2447 filegen_type = FILEGEN_MONTH; 2448 break; 2449 2450 case T_Year: 2451 filegen_type = FILEGEN_YEAR; 2452 break; 2453 2454 case T_Age: 2455 filegen_type = FILEGEN_AGE; 2456 break; 2457 } 2458 break; 2459 2460 case T_Flag: 2461 switch (my_opts->value.i) { 2462 2463 case T_Link: 2464 filegen_flag |= FGEN_FLAG_LINK; 2465 break; 2466 2467 case T_Nolink: 2468 filegen_flag &= ~FGEN_FLAG_LINK; 2469 break; 2470 2471 case T_Enable: 2472 filegen_flag |= FGEN_FLAG_ENABLED; 2473 break; 2474 2475 case T_Disable: 2476 filegen_flag &= ~FGEN_FLAG_ENABLED; 2477 break; 2478 2479 default: 2480 msyslog(LOG_ERR, 2481 "Unknown filegen flag token %d", 2482 my_opts->value.i); 2483 exit(1); 2484 } 2485 break; 2486 2487 default: 2488 msyslog(LOG_ERR, 2489 "Unknown filegen option token %d", 2490 my_opts->attr); 2491 exit(1); 2492 } 2493 } 2494 filegen_config(filegen, statsdir, filegen_file, 2495 filegen_type, filegen_flag); 2496 } 2497 } 2498 2499 2500 #ifdef FREE_CFG_T 2501 static void 2502 free_config_monitor( 2503 config_tree *ptree 2504 ) 2505 { 2506 if (ptree->stats_dir) { 2507 free(ptree->stats_dir); 2508 ptree->stats_dir = NULL; 2509 } 2510 2511 FREE_INT_FIFO(ptree->stats_list); 2512 FREE_FILEGEN_FIFO(ptree->filegen_opts); 2513 } 2514 #endif /* FREE_CFG_T */ 2515 2516 2517 #ifndef SIM 2518 static void 2519 config_access( 2520 config_tree *ptree 2521 ) 2522 { 2523 static int warned_signd; 2524 attr_val * my_opt; 2525 restrict_node * my_node; 2526 sockaddr_u addr; 2527 sockaddr_u mask; 2528 struct addrinfo hints; 2529 struct addrinfo * ai_list; 2530 struct addrinfo * pai; 2531 int rc; 2532 int restrict_default; 2533 u_short rflags; 2534 u_short mflags; 2535 short ippeerlimit; 2536 int range_err; 2537 psl_item my_psl_item; 2538 attr_val * atrv; 2539 attr_val * dflt_psl_atr; 2540 const char * signd_warning = 2541 #ifdef HAVE_NTP_SIGND 2542 "MS-SNTP signd operations currently block ntpd degrading service to all clients."; 2543 #else 2544 "mssntp restrict bit ignored, this ntpd was configured without --enable-ntp-signd."; 2545 #endif 2546 2547 /* Configure the mru options */ 2548 my_opt = HEAD_PFIFO(ptree->mru_opts); 2549 for (; my_opt != NULL; my_opt = my_opt->link) { 2550 2551 range_err = FALSE; 2552 2553 switch (my_opt->attr) { 2554 2555 case T_Incalloc: 2556 if (0 <= my_opt->value.i) 2557 mru_incalloc = my_opt->value.u; 2558 else 2559 range_err = TRUE; 2560 break; 2561 2562 case T_Incmem: 2563 if (0 <= my_opt->value.i) 2564 mru_incalloc = (my_opt->value.u * 1024U) 2565 / sizeof(mon_entry); 2566 else 2567 range_err = TRUE; 2568 break; 2569 2570 case T_Initalloc: 2571 if (0 <= my_opt->value.i) 2572 mru_initalloc = my_opt->value.u; 2573 else 2574 range_err = TRUE; 2575 break; 2576 2577 case T_Initmem: 2578 if (0 <= my_opt->value.i) 2579 mru_initalloc = (my_opt->value.u * 1024U) 2580 / sizeof(mon_entry); 2581 else 2582 range_err = TRUE; 2583 break; 2584 2585 case T_Mindepth: 2586 if (0 <= my_opt->value.i) 2587 mru_mindepth = my_opt->value.u; 2588 else 2589 range_err = TRUE; 2590 break; 2591 2592 case T_Maxage: 2593 mru_maxage = my_opt->value.i; 2594 break; 2595 2596 case T_Maxdepth: 2597 if (0 <= my_opt->value.i) 2598 mru_maxdepth = my_opt->value.u; 2599 else 2600 mru_maxdepth = UINT_MAX; 2601 break; 2602 2603 case T_Maxmem: 2604 if (0 <= my_opt->value.i) 2605 mru_maxdepth = (my_opt->value.u * 1024U) / 2606 sizeof(mon_entry); 2607 else 2608 mru_maxdepth = UINT_MAX; 2609 break; 2610 2611 default: 2612 msyslog(LOG_ERR, 2613 "Unknown mru option %s (%d)", 2614 keyword(my_opt->attr), my_opt->attr); 2615 exit(1); 2616 } 2617 if (range_err) 2618 msyslog(LOG_ERR, 2619 "mru %s %d out of range, ignored.", 2620 keyword(my_opt->attr), my_opt->value.i); 2621 } 2622 2623 /* Configure the discard options */ 2624 my_opt = HEAD_PFIFO(ptree->discard_opts); 2625 for (; my_opt != NULL; my_opt = my_opt->link) { 2626 2627 switch (my_opt->attr) { 2628 2629 case T_Average: 2630 if (0 <= my_opt->value.i && 2631 my_opt->value.i <= UCHAR_MAX) 2632 ntp_minpoll = (u_char)my_opt->value.u; 2633 else 2634 msyslog(LOG_ERR, 2635 "discard average %d out of range, ignored.", 2636 my_opt->value.i); 2637 break; 2638 2639 case T_Minimum: 2640 ntp_minpkt = my_opt->value.i; 2641 break; 2642 2643 case T_Monitor: 2644 mon_age = my_opt->value.i; 2645 break; 2646 2647 default: 2648 msyslog(LOG_ERR, 2649 "Unknown discard option %s (%d)", 2650 keyword(my_opt->attr), my_opt->attr); 2651 exit(1); 2652 } 2653 } 2654 2655 /* Configure each line of restrict options */ 2656 my_node = HEAD_PFIFO(ptree->restrict_opts); 2657 2658 for (; my_node != NULL; my_node = my_node->link) { 2659 2660 /* Grab the ippeerlmit */ 2661 ippeerlimit = my_node->ippeerlimit; 2662 2663 /* Parse the flags */ 2664 rflags = 0; 2665 mflags = 0; 2666 2667 my_opt = HEAD_PFIFO(my_node->flag_tok_fifo); 2668 for (; my_opt != NULL; my_opt = my_opt->link) { 2669 switch (my_opt->attr) { 2670 2671 default: 2672 fatal_error("config_access: Unknown flag-type-token=%s/%d", keyword(my_opt->attr), my_opt->attr); 2673 2674 case T_Ntpport: 2675 mflags |= RESM_NTPONLY; 2676 break; 2677 2678 case T_Source: 2679 mflags |= RESM_SOURCE; 2680 break; 2681 2682 case T_Flake: 2683 rflags |= RES_FLAKE; 2684 break; 2685 2686 case T_Ignore: 2687 rflags |= RES_IGNORE; 2688 break; 2689 2690 case T_Kod: 2691 rflags |= RES_KOD; 2692 break; 2693 2694 case T_Limited: 2695 rflags |= RES_LIMITED; 2696 break; 2697 2698 case T_Lowpriotrap: 2699 rflags |= RES_LPTRAP; 2700 break; 2701 2702 case T_Mssntp: 2703 rflags |= RES_MSSNTP; 2704 break; 2705 2706 case T_Nomodify: 2707 rflags |= RES_NOMODIFY; 2708 break; 2709 2710 case T_Nomrulist: 2711 rflags |= RES_NOMRULIST; 2712 break; 2713 2714 case T_Noepeer: 2715 rflags |= RES_NOEPEER; 2716 break; 2717 2718 case T_Nopeer: 2719 rflags |= RES_NOPEER; 2720 break; 2721 2722 case T_Noquery: 2723 rflags |= RES_NOQUERY; 2724 break; 2725 2726 case T_Noserve: 2727 rflags |= RES_DONTSERVE; 2728 break; 2729 2730 case T_Notrap: 2731 rflags |= RES_NOTRAP; 2732 break; 2733 2734 case T_Notrust: 2735 rflags |= RES_DONTTRUST; 2736 break; 2737 2738 case T_ServerresponseFuzz: 2739 rflags |= RES_SRVRSPFUZ; 2740 break; 2741 2742 case T_Version: 2743 rflags |= RES_VERSION; 2744 break; 2745 } 2746 } 2747 2748 if ((RES_MSSNTP & rflags) && !warned_signd) { 2749 warned_signd = 1; 2750 fprintf(stderr, "%s\n", signd_warning); 2751 msyslog(LOG_WARNING, "%s", signd_warning); 2752 } 2753 2754 /* It would be swell if we could identify the line number */ 2755 if ((RES_KOD & rflags) && !(RES_LIMITED & rflags)) { 2756 const char *kod_where = (my_node->addr) 2757 ? my_node->addr->address 2758 : (mflags & RESM_SOURCE) 2759 ? "source" 2760 : "default"; 2761 const char *kod_warn = "KOD does nothing without LIMITED."; 2762 2763 fprintf(stderr, "restrict %s: %s\n", kod_where, kod_warn); 2764 msyslog(LOG_WARNING, "restrict %s: %s", kod_where, kod_warn); 2765 } 2766 2767 ZERO_SOCK(&addr); 2768 ai_list = NULL; 2769 pai = NULL; 2770 restrict_default = 0; 2771 2772 if (NULL == my_node->addr) { 2773 ZERO_SOCK(&mask); 2774 if (!(RESM_SOURCE & mflags)) { 2775 /* 2776 * The user specified a default rule 2777 * without a -4 / -6 qualifier, add to 2778 * both lists 2779 */ 2780 restrict_default = 1; 2781 } else { 2782 /* apply "restrict source ..." */ 2783 DPRINTF(1, ("restrict source template ippeerlimit %d mflags %x rflags %x\n", 2784 ippeerlimit, mflags, rflags)); 2785 hack_restrict(RESTRICT_FLAGS, NULL, NULL, 2786 ippeerlimit, mflags, rflags, 0); 2787 continue; 2788 } 2789 } else { 2790 /* Resolve the specified address */ 2791 AF(&addr) = (u_short)my_node->addr->type; 2792 2793 if (getnetnum(my_node->addr->address, 2794 &addr, 1, t_UNK) != 1) { 2795 /* 2796 * Attempt a blocking lookup. This 2797 * is in violation of the nonblocking 2798 * design of ntpd's mainline code. The 2799 * alternative of running without the 2800 * restriction until the name resolved 2801 * seems worse. 2802 * Ideally some scheme could be used for 2803 * restrict directives in the startup 2804 * ntp.conf to delay starting up the 2805 * protocol machinery until after all 2806 * restrict hosts have been resolved. 2807 */ 2808 ai_list = NULL; 2809 ZERO(hints); 2810 hints.ai_protocol = IPPROTO_UDP; 2811 hints.ai_socktype = SOCK_DGRAM; 2812 hints.ai_family = my_node->addr->type; 2813 rc = getaddrinfo(my_node->addr->address, 2814 "ntp", &hints, 2815 &ai_list); 2816 if (rc) { 2817 msyslog(LOG_ERR, 2818 "restrict: ignoring line %d, address/host '%s' unusable.", 2819 my_node->line_no, 2820 my_node->addr->address); 2821 continue; 2822 } 2823 INSIST(ai_list != NULL); 2824 pai = ai_list; 2825 INSIST(pai->ai_addr != NULL); 2826 INSIST(sizeof(addr) >= 2827 pai->ai_addrlen); 2828 memcpy(&addr, pai->ai_addr, 2829 pai->ai_addrlen); 2830 INSIST(AF_INET == AF(&addr) || 2831 AF_INET6 == AF(&addr)); 2832 } 2833 2834 SET_HOSTMASK(&mask, AF(&addr)); 2835 2836 /* Resolve the mask */ 2837 if (my_node->mask) { 2838 ZERO_SOCK(&mask); 2839 AF(&mask) = my_node->mask->type; 2840 if (getnetnum(my_node->mask->address, 2841 &mask, 1, t_MSK) != 1) { 2842 msyslog(LOG_ERR, 2843 "restrict: ignoring line %d, mask '%s' unusable.", 2844 my_node->line_no, 2845 my_node->mask->address); 2846 continue; 2847 } 2848 } 2849 } 2850 2851 /* Set the flags */ 2852 if (restrict_default) { 2853 AF(&addr) = AF_INET; 2854 AF(&mask) = AF_INET; 2855 hack_restrict(RESTRICT_FLAGS, &addr, &mask, 2856 ippeerlimit, mflags, rflags, 0); 2857 AF(&addr) = AF_INET6; 2858 AF(&mask) = AF_INET6; 2859 } 2860 2861 do { 2862 hack_restrict(RESTRICT_FLAGS, &addr, &mask, 2863 ippeerlimit, mflags, rflags, 0); 2864 if (pai != NULL && 2865 NULL != (pai = pai->ai_next)) { 2866 INSIST(pai->ai_addr != NULL); 2867 INSIST(sizeof(addr) >= 2868 pai->ai_addrlen); 2869 ZERO_SOCK(&addr); 2870 memcpy(&addr, pai->ai_addr, 2871 pai->ai_addrlen); 2872 INSIST(AF_INET == AF(&addr) || 2873 AF_INET6 == AF(&addr)); 2874 SET_HOSTMASK(&mask, AF(&addr)); 2875 } 2876 } while (pai != NULL); 2877 2878 if (ai_list != NULL) 2879 freeaddrinfo(ai_list); 2880 } 2881 2882 /* Deal with the Poll Skew List */ 2883 2884 ZERO(psl); 2885 ZERO(my_psl_item); 2886 2887 /* 2888 * First, find the last default pollskewlist item. 2889 * There should only be one of these with the current grammar, 2890 * but better safe than sorry. 2891 */ 2892 dflt_psl_atr = NULL; 2893 atrv = HEAD_PFIFO(ptree->pollskewlist); 2894 for ( ; atrv != NULL; atrv = atrv->link) { 2895 switch (atrv->attr) { 2896 case -1: /* default */ 2897 dflt_psl_atr = atrv; 2898 break; 2899 2900 case 3: /* Fall through */ 2901 case 4: /* Fall through */ 2902 case 5: /* Fall through */ 2903 case 6: /* Fall through */ 2904 case 7: /* Fall through */ 2905 case 8: /* Fall through */ 2906 case 9: /* Fall through */ 2907 case 10: /* Fall through */ 2908 case 11: /* Fall through */ 2909 case 12: /* Fall through */ 2910 case 13: /* Fall through */ 2911 case 14: /* Fall through */ 2912 case 15: /* Fall through */ 2913 case 16: /* Fall through */ 2914 case 17: 2915 /* ignore */ 2916 break; 2917 2918 default: 2919 msyslog(LOG_ERR, 2920 "config_access: default PSL scan: ignoring unexpected poll value %d", 2921 atrv->attr); 2922 break; 2923 } 2924 } 2925 2926 /* If we have a nonzero default, initialize the PSL */ 2927 if ( dflt_psl_atr 2928 && ( 0 != dflt_psl_atr->value.r.first 2929 || 0 != dflt_psl_atr->value.r.last)) { 2930 int i; 2931 2932 for (i = 3; i <= 17; ++i) { 2933 attrtopsl(i, dflt_psl_atr); 2934 } 2935 } 2936 2937 /* Finally, update the PSL with any explicit entries */ 2938 atrv = HEAD_PFIFO(ptree->pollskewlist); 2939 for ( ; atrv != NULL; atrv = atrv->link) { 2940 switch (atrv->attr) { 2941 case -1: /* default */ 2942 /* Ignore */ 2943 break; 2944 2945 case 3: /* Fall through */ 2946 case 4: /* Fall through */ 2947 case 5: /* Fall through */ 2948 case 6: /* Fall through */ 2949 case 7: /* Fall through */ 2950 case 8: /* Fall through */ 2951 case 9: /* Fall through */ 2952 case 10: /* Fall through */ 2953 case 11: /* Fall through */ 2954 case 12: /* Fall through */ 2955 case 13: /* Fall through */ 2956 case 14: /* Fall through */ 2957 case 15: /* Fall through */ 2958 case 16: /* Fall through */ 2959 case 17: 2960 attrtopsl(atrv->attr, atrv); 2961 break; 2962 2963 default: 2964 break; /* Ignore - we reported this above */ 2965 } 2966 } 2967 2968 #if 0 2969 int p; 2970 msyslog(LOG_INFO, "Dumping PSL:"); 2971 for (p = 3; p <= 17; ++p) { 2972 psl_item psi; 2973 2974 if (0 == get_pollskew(p, &psi)) { 2975 msyslog(LOG_INFO, "poll %d: sub %d, qty %d, msk %d", 2976 p, psi.sub, psi.qty, psi.msk); 2977 } else { 2978 msyslog(LOG_ERR, "Dumping PSL: get_pollskew(%d) failed!", p); 2979 } 2980 } 2981 #endif 2982 } 2983 2984 2985 void 2986 attrtopsl(int poll, attr_val *avp) 2987 { 2988 2989 DEBUG_INSIST((poll - 3) < sizeof psl); 2990 if (poll < 3 || poll > 17) { 2991 msyslog(LOG_ERR, "attrtopsl(%d, ...): Poll value is out of range - ignoring", poll); 2992 } else { 2993 int pao = poll - 3; /* poll array offset */ 2994 int lower = avp->value.r.first; /* a positive number */ 2995 int upper = avp->value.r.last; 2996 int psmax = 1 << (poll - 1); 2997 int qmsk; 2998 2999 if (lower > psmax) { 3000 msyslog(LOG_WARNING, "attrtopsl: default: poll %d lower bound reduced from %d to %d", 3001 poll, lower, psmax); 3002 lower = psmax; 3003 } 3004 if (upper > psmax) { 3005 msyslog(LOG_WARNING, "attrtopsl: default: poll %d upper bound reduced from %d to %d", 3006 poll, upper, psmax); 3007 upper = psmax; 3008 } 3009 psl[pao].sub = lower; 3010 psl[pao].qty = lower + upper; 3011 3012 qmsk = 1; 3013 while (qmsk < (lower + upper)) { 3014 qmsk <<= 1; 3015 qmsk |= 1; 3016 }; 3017 psl[pao].msk = qmsk; 3018 } 3019 3020 return; 3021 } 3022 #endif /* !SIM */ 3023 3024 3025 int 3026 get_pollskew( 3027 int p, 3028 psl_item *rv 3029 ) 3030 { 3031 3032 DEBUG_INSIST(3 <= p && 17 >= p); 3033 if (3 <= p && 17 >= p) { 3034 *rv = psl[p - 3]; 3035 3036 return 0; 3037 } else { 3038 msyslog(LOG_ERR, "get_pollskew(%d): poll is not between 3 and 17!", p); 3039 return -1; 3040 } 3041 3042 /* NOTREACHED */ 3043 } 3044 3045 3046 #ifdef FREE_CFG_T 3047 static void 3048 free_config_access( 3049 config_tree *ptree 3050 ) 3051 { 3052 FREE_ATTR_VAL_FIFO(ptree->mru_opts); 3053 FREE_ATTR_VAL_FIFO(ptree->discard_opts); 3054 FREE_RESTRICT_FIFO(ptree->restrict_opts); 3055 } 3056 #endif /* FREE_CFG_T */ 3057 3058 3059 static void 3060 config_rlimit( 3061 config_tree *ptree 3062 ) 3063 { 3064 attr_val * rlimit_av; 3065 3066 rlimit_av = HEAD_PFIFO(ptree->rlimit); 3067 for (; rlimit_av != NULL; rlimit_av = rlimit_av->link) { 3068 switch (rlimit_av->attr) { 3069 3070 default: 3071 fatal_error("config-rlimit: value-token=%d", rlimit_av->attr); 3072 3073 case T_Memlock: 3074 /* What if we HAVE_OPT(SAVECONFIGQUIT) ? */ 3075 if (HAVE_OPT( SAVECONFIGQUIT )) { 3076 break; 3077 } 3078 if (rlimit_av->value.i == -1) { 3079 # if defined(HAVE_MLOCKALL) 3080 if (cur_memlock != 0) { 3081 if (-1 == munlockall()) { 3082 msyslog(LOG_ERR, "munlockall() failed: %m"); 3083 } 3084 } 3085 cur_memlock = 0; 3086 # endif /* HAVE_MLOCKALL */ 3087 } else if (rlimit_av->value.i >= 0) { 3088 #if defined(RLIMIT_MEMLOCK) 3089 # if defined(HAVE_MLOCKALL) 3090 if (cur_memlock != 1) { 3091 if (-1 == mlockall(MCL_CURRENT|MCL_FUTURE)) { 3092 msyslog(LOG_ERR, "mlockall() failed: %m"); 3093 } 3094 } 3095 # endif /* HAVE_MLOCKALL */ 3096 ntp_rlimit(RLIMIT_MEMLOCK, 3097 (rlim_t)(rlimit_av->value.i * 1024 * 1024), 3098 1024 * 1024, 3099 "MB"); 3100 cur_memlock = 1; 3101 #else 3102 /* STDERR as well would be fine... */ 3103 msyslog(LOG_WARNING, "'rlimit memlock' specified but is not available on this system."); 3104 #endif /* RLIMIT_MEMLOCK */ 3105 } else { 3106 msyslog(LOG_WARNING, "'rlimit memlock' value of %d is unexpected!", rlimit_av->value.i); 3107 } 3108 break; 3109 3110 case T_Stacksize: 3111 #if defined(RLIMIT_STACK) 3112 ntp_rlimit(RLIMIT_STACK, 3113 (rlim_t)(rlimit_av->value.i * 4096), 3114 4096, 3115 "4k"); 3116 #else 3117 /* STDERR as well would be fine... */ 3118 msyslog(LOG_WARNING, "'rlimit stacksize' specified but is not available on this system."); 3119 #endif /* RLIMIT_STACK */ 3120 break; 3121 3122 case T_Filenum: 3123 #if defined(RLIMIT_NOFILE) 3124 ntp_rlimit(RLIMIT_NOFILE, 3125 (rlim_t)(rlimit_av->value.i), 3126 1, 3127 ""); 3128 #else 3129 /* STDERR as well would be fine... */ 3130 msyslog(LOG_WARNING, "'rlimit filenum' specified but is not available on this system."); 3131 #endif /* RLIMIT_NOFILE */ 3132 break; 3133 3134 } 3135 } 3136 } 3137 3138 3139 static void 3140 config_tinker( 3141 config_tree *ptree 3142 ) 3143 { 3144 attr_val * tinker; 3145 int item; 3146 3147 tinker = HEAD_PFIFO(ptree->tinker); 3148 for (; tinker != NULL; tinker = tinker->link) { 3149 switch (tinker->attr) { 3150 3151 default: 3152 fatal_error("config_tinker: attr-token=%d", tinker->attr); 3153 3154 case T_Allan: 3155 item = LOOP_ALLAN; 3156 break; 3157 3158 case T_Dispersion: 3159 item = LOOP_PHI; 3160 break; 3161 3162 case T_Freq: 3163 item = LOOP_FREQ; 3164 break; 3165 3166 case T_Huffpuff: 3167 item = LOOP_HUFFPUFF; 3168 break; 3169 3170 case T_Panic: 3171 item = LOOP_PANIC; 3172 break; 3173 3174 case T_Step: 3175 item = LOOP_MAX; 3176 break; 3177 3178 case T_Stepback: 3179 item = LOOP_MAX_BACK; 3180 break; 3181 3182 case T_Stepfwd: 3183 item = LOOP_MAX_FWD; 3184 break; 3185 3186 case T_Stepout: 3187 item = LOOP_MINSTEP; 3188 break; 3189 3190 case T_Tick: 3191 item = LOOP_TICK; 3192 break; 3193 } 3194 loop_config(item, tinker->value.d); 3195 } 3196 } 3197 3198 3199 #ifdef FREE_CFG_T 3200 static void 3201 free_config_rlimit( 3202 config_tree *ptree 3203 ) 3204 { 3205 FREE_ATTR_VAL_FIFO(ptree->rlimit); 3206 } 3207 3208 static void 3209 free_config_tinker( 3210 config_tree *ptree 3211 ) 3212 { 3213 FREE_ATTR_VAL_FIFO(ptree->tinker); 3214 } 3215 #endif /* FREE_CFG_T */ 3216 3217 3218 /* 3219 * config_nic_rules - apply interface listen/ignore/drop items 3220 */ 3221 #ifndef SIM 3222 static void 3223 config_nic_rules( 3224 config_tree *ptree, 3225 int/*BOOL*/ input_from_file 3226 ) 3227 { 3228 nic_rule_node * curr_node; 3229 sockaddr_u addr; 3230 nic_rule_match match_type; 3231 nic_rule_action action; 3232 char * if_name; 3233 char * pchSlash; 3234 int prefixlen; 3235 int addrbits; 3236 3237 curr_node = HEAD_PFIFO(ptree->nic_rules); 3238 3239 if (curr_node != NULL 3240 && (HAVE_OPT( NOVIRTUALIPS ) || HAVE_OPT( INTERFACE ))) { 3241 msyslog(LOG_ERR, 3242 "interface/nic rules are not allowed with --interface (-I) or --novirtualips (-L)%s", 3243 (input_from_file) ? ", exiting" : ""); 3244 if (input_from_file) 3245 exit(1); 3246 else 3247 return; 3248 } 3249 3250 for (; curr_node != NULL; curr_node = curr_node->link) { 3251 prefixlen = -1; 3252 if_name = curr_node->if_name; 3253 if (if_name != NULL) 3254 if_name = estrdup(if_name); 3255 3256 switch (curr_node->match_class) { 3257 3258 default: 3259 fatal_error("config_nic_rules: match-class-token=%d", curr_node->match_class); 3260 3261 case 0: 3262 /* 3263 * 0 is out of range for valid token T_... 3264 * and in a nic_rules_node indicates the 3265 * interface descriptor is either a name or 3266 * address, stored in if_name in either case. 3267 */ 3268 INSIST(if_name != NULL); 3269 pchSlash = strchr(if_name, '/'); 3270 if (pchSlash != NULL) 3271 *pchSlash = '\0'; 3272 if (is_ip_address(if_name, AF_UNSPEC, &addr)) { 3273 match_type = MATCH_IFADDR; 3274 if (pchSlash != NULL 3275 && 1 == sscanf(pchSlash + 1, "%d", 3276 &prefixlen)) { 3277 addrbits = 8 * 3278 SIZEOF_INADDR(AF(&addr)); 3279 prefixlen = max(-1, prefixlen); 3280 prefixlen = min(prefixlen, 3281 addrbits); 3282 } 3283 } else { 3284 match_type = MATCH_IFNAME; 3285 if (pchSlash != NULL) 3286 *pchSlash = '/'; 3287 } 3288 break; 3289 3290 case T_All: 3291 match_type = MATCH_ALL; 3292 break; 3293 3294 case T_Ipv4: 3295 match_type = MATCH_IPV4; 3296 break; 3297 3298 case T_Ipv6: 3299 match_type = MATCH_IPV6; 3300 break; 3301 3302 case T_Wildcard: 3303 match_type = MATCH_WILDCARD; 3304 break; 3305 } 3306 3307 switch (curr_node->action) { 3308 3309 default: 3310 fatal_error("config_nic_rules: action-token=%d", curr_node->action); 3311 3312 case T_Listen: 3313 action = ACTION_LISTEN; 3314 break; 3315 3316 case T_Ignore: 3317 action = ACTION_IGNORE; 3318 break; 3319 3320 case T_Drop: 3321 action = ACTION_DROP; 3322 break; 3323 } 3324 3325 add_nic_rule(match_type, if_name, prefixlen, 3326 action); 3327 timer_interfacetimeout(current_time + 2); 3328 if (if_name != NULL) 3329 free(if_name); 3330 } 3331 } 3332 #endif /* !SIM */ 3333 3334 3335 #ifdef FREE_CFG_T 3336 static void 3337 free_config_nic_rules( 3338 config_tree *ptree 3339 ) 3340 { 3341 nic_rule_node *curr_node; 3342 3343 if (ptree->nic_rules != NULL) { 3344 for (;;) { 3345 UNLINK_FIFO(curr_node, *ptree->nic_rules, link); 3346 if (NULL == curr_node) 3347 break; 3348 free(curr_node->if_name); 3349 free(curr_node); 3350 } 3351 free(ptree->nic_rules); 3352 ptree->nic_rules = NULL; 3353 } 3354 } 3355 #endif /* FREE_CFG_T */ 3356 3357 3358 static void 3359 apply_enable_disable( 3360 attr_val_fifo * fifo, 3361 int enable 3362 ) 3363 { 3364 attr_val *curr_tok_fifo; 3365 int option; 3366 #ifdef BC_LIST_FRAMEWORK_NOT_YET_USED 3367 bc_entry *pentry; 3368 #endif 3369 3370 for (curr_tok_fifo = HEAD_PFIFO(fifo); 3371 curr_tok_fifo != NULL; 3372 curr_tok_fifo = curr_tok_fifo->link) { 3373 3374 option = curr_tok_fifo->value.i; 3375 switch (option) { 3376 3377 default: 3378 msyslog(LOG_ERR, 3379 "can not apply enable/disable token %d, unknown", 3380 option); 3381 break; 3382 3383 case T_Auth: 3384 proto_config(PROTO_AUTHENTICATE, enable, 0., NULL); 3385 break; 3386 3387 case T_Bclient: 3388 proto_config(PROTO_BROADCLIENT, enable, 0., NULL); 3389 break; 3390 3391 case T_Calibrate: 3392 proto_config(PROTO_CAL, enable, 0., NULL); 3393 break; 3394 3395 case T_Kernel: 3396 proto_config(PROTO_KERNEL, enable, 0., NULL); 3397 break; 3398 3399 case T_Monitor: 3400 proto_config(PROTO_MONITOR, enable, 0., NULL); 3401 break; 3402 3403 case T_Mode7: 3404 proto_config(PROTO_MODE7, enable, 0., NULL); 3405 break; 3406 3407 case T_Ntp: 3408 proto_config(PROTO_NTP, enable, 0., NULL); 3409 break; 3410 3411 case T_PCEdigest: 3412 proto_config(PROTO_PCEDIGEST, enable, 0., NULL); 3413 break; 3414 3415 case T_Stats: 3416 proto_config(PROTO_FILEGEN, enable, 0., NULL); 3417 break; 3418 3419 case T_UEcrypto: 3420 proto_config(PROTO_UECRYPTO, enable, 0., NULL); 3421 break; 3422 3423 case T_UEcryptonak: 3424 proto_config(PROTO_UECRYPTONAK, enable, 0., NULL); 3425 break; 3426 3427 case T_UEdigest: 3428 proto_config(PROTO_UEDIGEST, enable, 0., NULL); 3429 break; 3430 3431 #ifdef BC_LIST_FRAMEWORK_NOT_YET_USED 3432 case T_Bc_bugXXXX: 3433 pentry = bc_list; 3434 while (pentry->token) { 3435 if (pentry->token == option) 3436 break; 3437 pentry++; 3438 } 3439 if (!pentry->token) { 3440 msyslog(LOG_ERR, 3441 "compat token %d not in bc_list[]", 3442 option); 3443 continue; 3444 } 3445 pentry->enabled = enable; 3446 break; 3447 #endif 3448 } 3449 } 3450 } 3451 3452 3453 static void 3454 config_system_opts( 3455 config_tree *ptree 3456 ) 3457 { 3458 apply_enable_disable(ptree->enable_opts, 1); 3459 apply_enable_disable(ptree->disable_opts, 0); 3460 } 3461 3462 3463 #ifdef FREE_CFG_T 3464 static void 3465 free_config_system_opts( 3466 config_tree *ptree 3467 ) 3468 { 3469 FREE_ATTR_VAL_FIFO(ptree->enable_opts); 3470 FREE_ATTR_VAL_FIFO(ptree->disable_opts); 3471 } 3472 #endif /* FREE_CFG_T */ 3473 3474 3475 static void 3476 config_logconfig( 3477 config_tree *ptree 3478 ) 3479 { 3480 attr_val * my_lc; 3481 3482 my_lc = HEAD_PFIFO(ptree->logconfig); 3483 for (; my_lc != NULL; my_lc = my_lc->link) { 3484 switch (my_lc->attr) { 3485 3486 case '+': 3487 ntp_syslogmask |= get_logmask(my_lc->value.s); 3488 break; 3489 3490 case '-': 3491 ntp_syslogmask &= ~get_logmask(my_lc->value.s); 3492 break; 3493 3494 case '=': 3495 ntp_syslogmask = get_logmask(my_lc->value.s); 3496 break; 3497 default: 3498 fatal_error("config-logconfig: modifier='%c'", my_lc->attr); 3499 } 3500 } 3501 } 3502 3503 3504 #ifdef FREE_CFG_T 3505 static void 3506 free_config_logconfig( 3507 config_tree *ptree 3508 ) 3509 { 3510 FREE_ATTR_VAL_FIFO(ptree->logconfig); 3511 } 3512 #endif /* FREE_CFG_T */ 3513 3514 3515 #ifndef SIM 3516 static void 3517 config_phone( 3518 config_tree *ptree 3519 ) 3520 { 3521 size_t i; 3522 string_node * sn; 3523 3524 i = 0; 3525 sn = HEAD_PFIFO(ptree->phone); 3526 for (; sn != NULL; sn = sn->link) { 3527 /* need to leave array entry for NULL terminator */ 3528 if (i < COUNTOF(sys_phone) - 1) { 3529 sys_phone[i++] = estrdup(sn->s); 3530 sys_phone[i] = NULL; 3531 } else { 3532 msyslog(LOG_INFO, 3533 "phone: Number of phone entries exceeds %zu. Ignoring phone %s...", 3534 (COUNTOF(sys_phone) - 1), sn->s); 3535 } 3536 } 3537 } 3538 #endif /* !SIM */ 3539 3540 static void 3541 config_mdnstries( 3542 config_tree *ptree 3543 ) 3544 { 3545 #ifdef HAVE_DNSREGISTRATION 3546 extern int mdnstries; 3547 mdnstries = ptree->mdnstries; 3548 #endif /* HAVE_DNSREGISTRATION */ 3549 } 3550 3551 #ifdef FREE_CFG_T 3552 static void 3553 free_config_phone( 3554 config_tree *ptree 3555 ) 3556 { 3557 FREE_STRING_FIFO(ptree->phone); 3558 } 3559 #endif /* FREE_CFG_T */ 3560 3561 3562 #ifndef SIM 3563 static void 3564 config_setvar( 3565 config_tree *ptree 3566 ) 3567 { 3568 setvar_node *my_node; 3569 size_t varlen, vallen, octets; 3570 char * str; 3571 3572 str = NULL; 3573 my_node = HEAD_PFIFO(ptree->setvar); 3574 for (; my_node != NULL; my_node = my_node->link) { 3575 varlen = strlen(my_node->var); 3576 vallen = strlen(my_node->val); 3577 octets = varlen + vallen + 1 + 1; 3578 str = erealloc(str, octets); 3579 snprintf(str, octets, "%s=%s", my_node->var, 3580 my_node->val); 3581 set_sys_var(str, octets, (my_node->isdefault) 3582 ? DEF 3583 : 0); 3584 } 3585 if (str != NULL) 3586 free(str); 3587 } 3588 #endif /* !SIM */ 3589 3590 3591 #ifdef FREE_CFG_T 3592 static void 3593 free_config_setvar( 3594 config_tree *ptree 3595 ) 3596 { 3597 FREE_SETVAR_FIFO(ptree->setvar); 3598 } 3599 #endif /* FREE_CFG_T */ 3600 3601 3602 #ifndef SIM 3603 static void 3604 config_ttl( 3605 config_tree *ptree 3606 ) 3607 { 3608 size_t i = 0; 3609 int_node *curr_ttl; 3610 3611 /* [Bug 3465] There is a built-in default for the TTLs. We must 3612 * overwrite 'sys_ttlmax' if we change that preset, and leave it 3613 * alone otherwise! 3614 */ 3615 curr_ttl = HEAD_PFIFO(ptree->ttl); 3616 for (; curr_ttl != NULL; curr_ttl = curr_ttl->link) { 3617 if (i < COUNTOF(sys_ttl)) 3618 sys_ttl[i++] = (u_char)curr_ttl->i; 3619 else 3620 msyslog(LOG_INFO, 3621 "ttl: Number of TTL entries exceeds %zu. Ignoring TTL %d...", 3622 COUNTOF(sys_ttl), curr_ttl->i); 3623 } 3624 if (0 != i) /* anything written back at all? */ 3625 sys_ttlmax = i - 1; 3626 } 3627 #endif /* !SIM */ 3628 3629 3630 #ifdef FREE_CFG_T 3631 static void 3632 free_config_ttl( 3633 config_tree *ptree 3634 ) 3635 { 3636 FREE_INT_FIFO(ptree->ttl); 3637 } 3638 #endif /* FREE_CFG_T */ 3639 3640 3641 #ifndef SIM 3642 static void 3643 config_trap( 3644 config_tree *ptree 3645 ) 3646 { 3647 addr_opts_node *curr_trap; 3648 attr_val *curr_opt; 3649 sockaddr_u addr_sock; 3650 sockaddr_u peeraddr; 3651 struct interface *localaddr; 3652 struct addrinfo hints; 3653 char port_text[8]; 3654 settrap_parms *pstp; 3655 u_short port; 3656 int err_flag; 3657 int rc; 3658 3659 /* silence warning about addr_sock potentially uninitialized */ 3660 AF(&addr_sock) = AF_UNSPEC; 3661 3662 curr_trap = HEAD_PFIFO(ptree->trap); 3663 for (; curr_trap != NULL; curr_trap = curr_trap->link) { 3664 err_flag = 0; 3665 port = 0; 3666 localaddr = NULL; 3667 3668 curr_opt = HEAD_PFIFO(curr_trap->options); 3669 for (; curr_opt != NULL; curr_opt = curr_opt->link) { 3670 if (T_Port == curr_opt->attr) { 3671 if (curr_opt->value.i < 1 3672 || curr_opt->value.i > USHRT_MAX) { 3673 msyslog(LOG_ERR, 3674 "invalid port number " 3675 "%d, trap ignored", 3676 curr_opt->value.i); 3677 err_flag = 1; 3678 } 3679 port = (u_short)curr_opt->value.i; 3680 } 3681 else if (T_Interface == curr_opt->attr) { 3682 /* Resolve the interface address */ 3683 ZERO_SOCK(&addr_sock); 3684 if (getnetnum(curr_opt->value.s, 3685 &addr_sock, 1, t_UNK) != 1) { 3686 err_flag = 1; 3687 break; 3688 } 3689 3690 localaddr = findinterface(&addr_sock); 3691 3692 if (NULL == localaddr) { 3693 msyslog(LOG_ERR, 3694 "can't find interface with address %s", 3695 stoa(&addr_sock)); 3696 err_flag = 1; 3697 } 3698 } 3699 } 3700 3701 /* Now process the trap for the specified interface 3702 * and port number 3703 */ 3704 if (!err_flag) { 3705 if (!port) 3706 port = TRAPPORT; 3707 ZERO_SOCK(&peeraddr); 3708 rc = getnetnum(curr_trap->addr->address, 3709 &peeraddr, 1, t_UNK); 3710 if (1 != rc) { 3711 #ifndef WORKER 3712 msyslog(LOG_ERR, 3713 "trap: unable to use IP address %s.", 3714 curr_trap->addr->address); 3715 #else /* WORKER follows */ 3716 /* 3717 * save context and hand it off 3718 * for name resolution. 3719 */ 3720 ZERO(hints); 3721 hints.ai_protocol = IPPROTO_UDP; 3722 hints.ai_socktype = SOCK_DGRAM; 3723 snprintf(port_text, sizeof(port_text), 3724 "%u", port); 3725 hints.ai_flags = Z_AI_NUMERICSERV; 3726 pstp = emalloc_zero(sizeof(*pstp)); 3727 if (localaddr != NULL) { 3728 hints.ai_family = localaddr->family; 3729 pstp->ifaddr_nonnull = 1; 3730 memcpy(&pstp->ifaddr, 3731 &localaddr->sin, 3732 sizeof(pstp->ifaddr)); 3733 } 3734 rc = getaddrinfo_sometime( 3735 curr_trap->addr->address, 3736 port_text, &hints, 3737 INITIAL_DNS_RETRY, 3738 &trap_name_resolved, 3739 pstp); 3740 if (!rc) 3741 msyslog(LOG_ERR, 3742 "config_trap: getaddrinfo_sometime(%s,%s): %m", 3743 curr_trap->addr->address, 3744 port_text); 3745 #endif /* WORKER */ 3746 continue; 3747 } 3748 /* port is at same location for v4 and v6 */ 3749 SET_PORT(&peeraddr, port); 3750 3751 if (NULL == localaddr) 3752 localaddr = ANY_INTERFACE_CHOOSE(&peeraddr); 3753 else 3754 AF(&peeraddr) = AF(&addr_sock); 3755 3756 if (!ctlsettrap(&peeraddr, localaddr, 0, 3757 NTP_VERSION)) 3758 msyslog(LOG_ERR, 3759 "set trap %s -> %s failed.", 3760 latoa(localaddr), 3761 stoa(&peeraddr)); 3762 } 3763 } 3764 } 3765 3766 3767 /* 3768 * trap_name_resolved() 3769 * 3770 * Callback invoked when config_trap()'s DNS lookup completes. 3771 */ 3772 # ifdef WORKER 3773 static void 3774 trap_name_resolved( 3775 int rescode, 3776 int gai_errno, 3777 void * context, 3778 const char * name, 3779 const char * service, 3780 const struct addrinfo * hints, 3781 const struct addrinfo * res 3782 ) 3783 { 3784 settrap_parms *pstp; 3785 struct interface *localaddr; 3786 sockaddr_u peeraddr; 3787 3788 (void)gai_errno; 3789 (void)service; 3790 (void)hints; 3791 pstp = context; 3792 if (rescode) { 3793 msyslog(LOG_ERR, 3794 "giving up resolving trap host %s: %s (%d)", 3795 name, gai_strerror(rescode), rescode); 3796 free(pstp); 3797 return; 3798 } 3799 INSIST(sizeof(peeraddr) >= res->ai_addrlen); 3800 ZERO(peeraddr); 3801 memcpy(&peeraddr, res->ai_addr, res->ai_addrlen); 3802 localaddr = NULL; 3803 if (pstp->ifaddr_nonnull) 3804 localaddr = findinterface(&pstp->ifaddr); 3805 if (NULL == localaddr) 3806 localaddr = ANY_INTERFACE_CHOOSE(&peeraddr); 3807 if (!ctlsettrap(&peeraddr, localaddr, 0, NTP_VERSION)) 3808 msyslog(LOG_ERR, "set trap %s -> %s failed.", 3809 latoa(localaddr), stoa(&peeraddr)); 3810 free(pstp); 3811 } 3812 # endif /* WORKER */ 3813 #endif /* !SIM */ 3814 3815 3816 #ifdef FREE_CFG_T 3817 static void 3818 free_config_trap( 3819 config_tree *ptree 3820 ) 3821 { 3822 FREE_ADDR_OPTS_FIFO(ptree->trap); 3823 } 3824 #endif /* FREE_CFG_T */ 3825 3826 3827 #ifndef SIM 3828 static void 3829 config_fudge( 3830 config_tree *ptree 3831 ) 3832 { 3833 addr_opts_node *curr_fudge; 3834 attr_val *curr_opt; 3835 sockaddr_u addr_sock; 3836 address_node *addr_node; 3837 struct refclockstat clock_stat; 3838 int err_flag; 3839 3840 curr_fudge = HEAD_PFIFO(ptree->fudge); 3841 for (; curr_fudge != NULL; curr_fudge = curr_fudge->link) { 3842 err_flag = 0; 3843 3844 /* Get the reference clock address and 3845 * ensure that it is sane 3846 */ 3847 addr_node = curr_fudge->addr; 3848 ZERO_SOCK(&addr_sock); 3849 if (getnetnum(addr_node->address, &addr_sock, 1, t_REF) 3850 != 1) { 3851 err_flag = 1; 3852 msyslog(LOG_ERR, 3853 "unrecognized fudge reference clock address %s, line ignored", 3854 addr_node->address); 3855 } else if (!ISREFCLOCKADR(&addr_sock)) { 3856 err_flag = 1; 3857 msyslog(LOG_ERR, 3858 "inappropriate address %s for the fudge command, line ignored", 3859 stoa(&addr_sock)); 3860 } 3861 3862 /* Parse all the options to the fudge command */ 3863 ZERO(clock_stat); 3864 /* some things are not necessarily cleared by ZERO...*/ 3865 clock_stat.fudgeminjitter = 0.0; 3866 clock_stat.fudgetime1 = 0.0; 3867 clock_stat.fudgetime2 = 0.0; 3868 clock_stat.p_lastcode = NULL; 3869 clock_stat.clockdesc = NULL; 3870 clock_stat.kv_list = NULL; 3871 curr_opt = HEAD_PFIFO(curr_fudge->options); 3872 for (; curr_opt != NULL; curr_opt = curr_opt->link) { 3873 switch (curr_opt->attr) { 3874 3875 case T_Time1: 3876 clock_stat.haveflags |= CLK_HAVETIME1; 3877 clock_stat.fudgetime1 = curr_opt->value.d; 3878 break; 3879 3880 case T_Time2: 3881 clock_stat.haveflags |= CLK_HAVETIME2; 3882 clock_stat.fudgetime2 = curr_opt->value.d; 3883 break; 3884 3885 case T_Stratum: 3886 clock_stat.haveflags |= CLK_HAVEVAL1; 3887 clock_stat.fudgeval1 = curr_opt->value.i; 3888 break; 3889 3890 case T_Refid: 3891 clock_stat.haveflags |= CLK_HAVEVAL2; 3892 /* strncpy() does exactly what we want here: */ 3893 strncpy((char*)&clock_stat.fudgeval2, 3894 curr_opt->value.s, 4); 3895 break; 3896 3897 case T_Flag1: 3898 clock_stat.haveflags |= CLK_HAVEFLAG1; 3899 if (curr_opt->value.i) 3900 clock_stat.flags |= CLK_FLAG1; 3901 else 3902 clock_stat.flags &= ~CLK_FLAG1; 3903 break; 3904 3905 case T_Flag2: 3906 clock_stat.haveflags |= CLK_HAVEFLAG2; 3907 if (curr_opt->value.i) 3908 clock_stat.flags |= CLK_FLAG2; 3909 else 3910 clock_stat.flags &= ~CLK_FLAG2; 3911 break; 3912 3913 case T_Flag3: 3914 clock_stat.haveflags |= CLK_HAVEFLAG3; 3915 if (curr_opt->value.i) 3916 clock_stat.flags |= CLK_FLAG3; 3917 else 3918 clock_stat.flags &= ~CLK_FLAG3; 3919 break; 3920 3921 case T_Flag4: 3922 clock_stat.haveflags |= CLK_HAVEFLAG4; 3923 if (curr_opt->value.i) 3924 clock_stat.flags |= CLK_FLAG4; 3925 else 3926 clock_stat.flags &= ~CLK_FLAG4; 3927 break; 3928 3929 case T_Minjitter: 3930 clock_stat.haveflags |= CLK_HAVEMINJIT; 3931 clock_stat.fudgeminjitter = curr_opt->value.d; 3932 break; 3933 3934 default: 3935 msyslog(LOG_ERR, 3936 "Unexpected fudge flag %s (%d) for %s", 3937 token_name(curr_opt->attr), 3938 curr_opt->attr, addr_node->address); 3939 exit(curr_opt->attr ? curr_opt->attr : 1); 3940 } 3941 } 3942 # ifdef REFCLOCK 3943 if (!err_flag) 3944 refclock_control(&addr_sock, &clock_stat, NULL); 3945 # endif 3946 } 3947 } 3948 #endif /* !SIM */ 3949 3950 3951 #ifdef FREE_CFG_T 3952 static void 3953 free_config_fudge( 3954 config_tree *ptree 3955 ) 3956 { 3957 FREE_ADDR_OPTS_FIFO(ptree->fudge); 3958 } 3959 #endif /* FREE_CFG_T */ 3960 3961 3962 static void 3963 config_vars( 3964 config_tree *ptree 3965 ) 3966 { 3967 attr_val *curr_var; 3968 int len; 3969 3970 curr_var = HEAD_PFIFO(ptree->vars); 3971 for (; curr_var != NULL; curr_var = curr_var->link) { 3972 /* Determine which variable to set and set it */ 3973 switch (curr_var->attr) { 3974 3975 case T_Broadcastdelay: 3976 proto_config(PROTO_BROADDELAY, 0, curr_var->value.d, NULL); 3977 break; 3978 3979 case T_Tick: 3980 loop_config(LOOP_TICK, curr_var->value.d); 3981 break; 3982 3983 case T_Driftfile: 3984 if ('\0' == curr_var->value.s[0]) { 3985 stats_drift_file = 0; 3986 msyslog(LOG_INFO, "config: driftfile disabled"); 3987 } else 3988 stats_config(STATS_FREQ_FILE, curr_var->value.s, 0); 3989 break; 3990 3991 case T_Dscp: 3992 /* DSCP is in the upper 6 bits of the IP TOS/DS field */ 3993 qos = curr_var->value.i << 2; 3994 break; 3995 3996 case T_Ident: 3997 sys_ident = curr_var->value.s; 3998 break; 3999 4000 case T_WanderThreshold: /* FALLTHROUGH */ 4001 case T_Nonvolatile: 4002 wander_threshold = curr_var->value.d; 4003 break; 4004 4005 case T_Leapfile: 4006 stats_config(STATS_LEAP_FILE, curr_var->value.s, curr_var->flag); 4007 break; 4008 4009 #ifdef LEAP_SMEAR 4010 case T_Leapsmearinterval: 4011 leap_smear_intv = curr_var->value.i; 4012 msyslog(LOG_INFO, "config: leap smear interval %i s", leap_smear_intv); 4013 break; 4014 #endif 4015 4016 case T_Pidfile: 4017 stats_config(STATS_PID_FILE, curr_var->value.s, 0); 4018 break; 4019 4020 case T_Logfile: 4021 if (-1 == change_logfile(curr_var->value.s, TRUE)) 4022 msyslog(LOG_ERR, 4023 "Cannot open logfile %s: %m", 4024 curr_var->value.s); 4025 break; 4026 4027 case T_Saveconfigdir: 4028 if (saveconfigdir != NULL) 4029 free(saveconfigdir); 4030 len = strlen(curr_var->value.s); 4031 if (0 == len) { 4032 saveconfigdir = NULL; 4033 } else if (DIR_SEP != curr_var->value.s[len - 1] 4034 #ifdef SYS_WINNT /* slash is also a dir. sep. on Windows */ 4035 && '/' != curr_var->value.s[len - 1] 4036 #endif 4037 ) { 4038 len++; 4039 saveconfigdir = emalloc(len + 1); 4040 snprintf(saveconfigdir, len + 1, 4041 "%s%c", 4042 curr_var->value.s, 4043 DIR_SEP); 4044 } else { 4045 saveconfigdir = estrdup( 4046 curr_var->value.s); 4047 } 4048 break; 4049 4050 case T_Automax: 4051 #ifdef AUTOKEY 4052 if (curr_var->value.i > 2 && curr_var->value.i < 32) 4053 sys_automax = (u_char)curr_var->value.i; 4054 else 4055 msyslog(LOG_ERR, 4056 "'automax' value %d ignored", 4057 curr_var->value.i); 4058 #endif 4059 break; 4060 4061 default: 4062 msyslog(LOG_ERR, 4063 "config_vars(): unexpected token %d", 4064 curr_var->attr); 4065 } 4066 } 4067 } 4068 4069 4070 #ifdef FREE_CFG_T 4071 static void 4072 free_config_vars( 4073 config_tree *ptree 4074 ) 4075 { 4076 FREE_ATTR_VAL_FIFO(ptree->vars); 4077 } 4078 #endif /* FREE_CFG_T */ 4079 4080 4081 /* Define a function to check if a resolved address is sane. 4082 * If yes, return 1, else return 0; 4083 */ 4084 static int 4085 is_sane_resolved_address( 4086 sockaddr_u * peeraddr, 4087 int hmode 4088 ) 4089 { 4090 if (!ISREFCLOCKADR(peeraddr) && ISBADADR(peeraddr)) { 4091 msyslog(LOG_ERR, 4092 "attempt to configure invalid address %s", 4093 stoa(peeraddr)); 4094 return 0; 4095 } 4096 /* 4097 * Shouldn't be able to specify: 4098 * - multicast address for server/peer! 4099 * - unicast address for manycastclient! 4100 */ 4101 if ((T_Server == hmode || T_Peer == hmode || T_Pool == hmode) 4102 && IS_MCAST(peeraddr)) { 4103 msyslog(LOG_ERR, 4104 "attempt to configure invalid address %s", 4105 stoa(peeraddr)); 4106 return 0; 4107 } 4108 if (T_Manycastclient == hmode && !IS_MCAST(peeraddr)) { 4109 msyslog(LOG_ERR, 4110 "attempt to configure invalid address %s", 4111 stoa(peeraddr)); 4112 return 0; 4113 } 4114 4115 if (IS_IPV6(peeraddr) && !ipv6_works) 4116 return 0; 4117 4118 /* Ok, all tests succeeded, now we can return 1 */ 4119 return 1; 4120 } 4121 4122 4123 #ifndef SIM 4124 static u_char 4125 get_correct_host_mode( 4126 int token 4127 ) 4128 { 4129 switch (token) { 4130 4131 case T_Server: 4132 case T_Pool: 4133 case T_Manycastclient: 4134 return MODE_CLIENT; 4135 4136 case T_Peer: 4137 return MODE_ACTIVE; 4138 4139 case T_Broadcast: 4140 return MODE_BROADCAST; 4141 4142 default: 4143 return 0; 4144 } 4145 } 4146 4147 4148 /* 4149 * peerflag_bits() get config_peers() peerflags value from a 4150 * peer_node's queue of flag attr_val entries. 4151 */ 4152 static int 4153 peerflag_bits( 4154 peer_node *pn 4155 ) 4156 { 4157 int peerflags; 4158 attr_val *option; 4159 int hmode; 4160 4161 DEBUG_INSIST(pn); 4162 /* translate peerflags options to bits */ 4163 peerflags = 0; 4164 hmode = pn->host_mode; 4165 option = HEAD_PFIFO(pn->peerflags); 4166 for (; option != NULL; option = option->link) { 4167 switch (option->value.i) { 4168 4169 default: 4170 fatal_error("peerflag_bits: option-token=%d", option->value.i); 4171 4172 case T_Autokey: 4173 peerflags |= FLAG_SKEY; 4174 break; 4175 4176 case T_Burst: 4177 peerflags |= FLAG_BURST; 4178 break; 4179 4180 case T_Iburst: 4181 peerflags |= FLAG_IBURST; 4182 break; 4183 4184 case T_Noselect: 4185 peerflags |= FLAG_NOSELECT; 4186 break; 4187 4188 case T_Preempt: 4189 peerflags |= FLAG_PREEMPT; 4190 break; 4191 4192 case T_Prefer: 4193 peerflags |= FLAG_PREFER; 4194 break; 4195 4196 case T_True: 4197 peerflags |= FLAG_TRUE; 4198 break; 4199 4200 case T_Xleave: 4201 peerflags |= FLAG_XLEAVE; 4202 break; 4203 4204 case T_Xmtnonce: 4205 if ( MODE_CLIENT == hmode ) { 4206 peerflags |= FLAG_LOOPNONCE; 4207 } 4208 break; 4209 } 4210 } 4211 4212 return peerflags; 4213 } 4214 4215 4216 static void 4217 config_peers( 4218 config_tree *ptree 4219 ) 4220 { 4221 sockaddr_u peeraddr; 4222 struct addrinfo hints; 4223 peer_node * curr_peer; 4224 peer_resolved_ctx * ctx; 4225 u_char hmode; 4226 4227 /* add servers named on the command line with iburst implied */ 4228 for (; 4229 cmdline_server_count > 0; 4230 cmdline_server_count--, cmdline_servers++) { 4231 4232 ZERO_SOCK(&peeraddr); 4233 /* 4234 * If we have a numeric address, we can safely 4235 * proceed in the mainline with it. Otherwise, hand 4236 * the hostname off to the blocking child. 4237 * 4238 * Note that if we're told to add the peer here, we 4239 * do that regardless of ippeerlimit. 4240 */ 4241 if (is_ip_address(*cmdline_servers, AF_UNSPEC, 4242 &peeraddr)) { 4243 4244 SET_PORT(&peeraddr, NTP_PORT); 4245 if (is_sane_resolved_address(&peeraddr, 4246 T_Server)) 4247 peer_config( 4248 &peeraddr, 4249 NULL, 4250 NULL, 4251 -1, 4252 MODE_CLIENT, 4253 NTP_VERSION, 4254 0, 4255 0, 4256 FLAG_IBURST, 4257 0, 4258 0, 4259 NULL); 4260 } else { 4261 /* we have a hostname to resolve */ 4262 # ifdef WORKER 4263 ctx = emalloc_zero(sizeof(*ctx)); 4264 ctx->family = AF_UNSPEC; 4265 ctx->host_mode = T_Server; 4266 ctx->hmode = MODE_CLIENT; 4267 ctx->version = NTP_VERSION; 4268 ctx->flags = FLAG_IBURST; 4269 4270 ZERO(hints); 4271 hints.ai_family = (u_short)ctx->family; 4272 hints.ai_socktype = SOCK_DGRAM; 4273 hints.ai_protocol = IPPROTO_UDP; 4274 4275 getaddrinfo_sometime_ex(*cmdline_servers, 4276 "ntp", &hints, 4277 INITIAL_DNS_RETRY, 4278 &peer_name_resolved, 4279 (void *)ctx, DNSFLAGS); 4280 # else /* !WORKER follows */ 4281 msyslog(LOG_ERR, 4282 "hostname %s can not be used, please use IP address instead.", 4283 curr_peer->addr->address); 4284 # endif 4285 } 4286 } 4287 4288 /* add associations from the configuration file */ 4289 curr_peer = HEAD_PFIFO(ptree->peers); 4290 for (; curr_peer != NULL; curr_peer = curr_peer->link) { 4291 ZERO_SOCK(&peeraddr); 4292 /* Find the correct host-mode */ 4293 hmode = get_correct_host_mode(curr_peer->host_mode); 4294 INSIST(hmode != 0); 4295 4296 if (T_Pool == curr_peer->host_mode) { 4297 AF(&peeraddr) = curr_peer->addr->type; 4298 peer_config( 4299 &peeraddr, 4300 curr_peer->addr->address, 4301 NULL, 4302 -1, 4303 hmode, 4304 curr_peer->peerversion, 4305 curr_peer->minpoll, 4306 curr_peer->maxpoll, 4307 peerflag_bits(curr_peer), 4308 curr_peer->ttl, 4309 curr_peer->peerkey, 4310 curr_peer->group); 4311 /* 4312 * If we have a numeric address, we can safely 4313 * proceed in the mainline with it. Otherwise, hand 4314 * the hostname off to the blocking child. 4315 */ 4316 } else if (is_ip_address(curr_peer->addr->address, 4317 curr_peer->addr->type, &peeraddr)) { 4318 4319 SET_PORT(&peeraddr, NTP_PORT); 4320 if (is_sane_resolved_address(&peeraddr, 4321 curr_peer->host_mode)) 4322 peer_config( 4323 &peeraddr, 4324 NULL, 4325 NULL, 4326 -1, 4327 hmode, 4328 curr_peer->peerversion, 4329 curr_peer->minpoll, 4330 curr_peer->maxpoll, 4331 peerflag_bits(curr_peer), 4332 curr_peer->ttl, 4333 curr_peer->peerkey, 4334 curr_peer->group); 4335 } else { 4336 /* we have a hostname to resolve */ 4337 # ifdef WORKER 4338 ctx = emalloc_zero(sizeof(*ctx)); 4339 ctx->family = curr_peer->addr->type; 4340 ctx->host_mode = curr_peer->host_mode; 4341 ctx->hmode = hmode; 4342 ctx->version = curr_peer->peerversion; 4343 ctx->minpoll = curr_peer->minpoll; 4344 ctx->maxpoll = curr_peer->maxpoll; 4345 ctx->flags = peerflag_bits(curr_peer); 4346 ctx->ttl = curr_peer->ttl; 4347 ctx->keyid = curr_peer->peerkey; 4348 ctx->group = curr_peer->group; 4349 4350 ZERO(hints); 4351 hints.ai_family = ctx->family; 4352 hints.ai_socktype = SOCK_DGRAM; 4353 hints.ai_protocol = IPPROTO_UDP; 4354 4355 getaddrinfo_sometime_ex(curr_peer->addr->address, 4356 "ntp", &hints, 4357 INITIAL_DNS_RETRY, 4358 &peer_name_resolved, ctx, 4359 DNSFLAGS); 4360 # else /* !WORKER follows */ 4361 msyslog(LOG_ERR, 4362 "hostname %s can not be used, please use IP address instead.", 4363 curr_peer->addr->address); 4364 # endif 4365 } 4366 } 4367 } 4368 #endif /* !SIM */ 4369 4370 /* 4371 * peer_name_resolved() 4372 * 4373 * Callback invoked when config_peers()'s DNS lookup completes. 4374 */ 4375 #ifdef WORKER 4376 static void 4377 peer_name_resolved( 4378 int rescode, 4379 int gai_errno, 4380 void * context, 4381 const char * name, 4382 const char * service, 4383 const struct addrinfo * hints, 4384 const struct addrinfo * res 4385 ) 4386 { 4387 sockaddr_u peeraddr; 4388 peer_resolved_ctx * ctx; 4389 u_short af; 4390 const char * fam_spec; 4391 4392 (void)gai_errno; 4393 (void)service; 4394 (void)hints; 4395 ctx = context; 4396 4397 DPRINTF(1, ("peer_name_resolved(%s) rescode %d\n", name, rescode)); 4398 4399 if (rescode) { 4400 free(ctx); 4401 msyslog(LOG_ERR, 4402 "giving up resolving host %s: %s (%d)", 4403 name, gai_strerror(rescode), rescode); 4404 return; 4405 } 4406 4407 /* Loop to configure a single association */ 4408 for (; res != NULL; res = res->ai_next) { 4409 memcpy(&peeraddr, res->ai_addr, res->ai_addrlen); 4410 if (is_sane_resolved_address(&peeraddr, 4411 ctx->host_mode)) { 4412 NLOG(NLOG_SYSINFO) { 4413 af = ctx->family; 4414 fam_spec = (AF_INET6 == af) 4415 ? "(AAAA) " 4416 : (AF_INET == af) 4417 ? "(A) " 4418 : ""; 4419 msyslog(LOG_INFO, "DNS %s %s-> %s", 4420 name, fam_spec, 4421 stoa(&peeraddr)); 4422 } 4423 peer_config( 4424 &peeraddr, 4425 NULL, 4426 NULL, 4427 -1, 4428 ctx->hmode, 4429 ctx->version, 4430 ctx->minpoll, 4431 ctx->maxpoll, 4432 ctx->flags, 4433 ctx->ttl, 4434 ctx->keyid, 4435 ctx->group); 4436 break; 4437 } 4438 } 4439 free(ctx); 4440 } 4441 #endif /* WORKER */ 4442 4443 4444 #ifdef FREE_CFG_T 4445 static void 4446 free_config_peers( 4447 config_tree *ptree 4448 ) 4449 { 4450 peer_node *curr_peer; 4451 4452 if (ptree->peers != NULL) { 4453 for (;;) { 4454 UNLINK_FIFO(curr_peer, *ptree->peers, link); 4455 if (NULL == curr_peer) 4456 break; 4457 destroy_address_node(curr_peer->addr); 4458 destroy_attr_val_fifo(curr_peer->peerflags); 4459 free(curr_peer); 4460 } 4461 free(ptree->peers); 4462 ptree->peers = NULL; 4463 } 4464 } 4465 #endif /* FREE_CFG_T */ 4466 4467 4468 #ifndef SIM 4469 static void 4470 config_unpeers( 4471 config_tree *ptree 4472 ) 4473 { 4474 sockaddr_u peeraddr; 4475 struct addrinfo hints; 4476 unpeer_node * curr_unpeer; 4477 struct peer * p; 4478 const char * name; 4479 int rc; 4480 4481 curr_unpeer = HEAD_PFIFO(ptree->unpeers); 4482 for (; curr_unpeer != NULL; curr_unpeer = curr_unpeer->link) { 4483 /* 4484 * If we have no address attached, assume we have to 4485 * unpeer by AssocID. 4486 */ 4487 if (!curr_unpeer->addr) { 4488 p = findpeerbyassoc(curr_unpeer->assocID); 4489 if (p != NULL) { 4490 msyslog(LOG_NOTICE, "unpeered %s", 4491 stoa(&p->srcadr)); 4492 peer_clear(p, "GONE"); 4493 unpeer(p); 4494 } 4495 continue; 4496 } 4497 4498 ZERO(peeraddr); 4499 AF(&peeraddr) = curr_unpeer->addr->type; 4500 name = curr_unpeer->addr->address; 4501 rc = getnetnum(name, &peeraddr, 0, t_UNK); 4502 /* Do we have a numeric address? */ 4503 if (rc > 0) { 4504 DPRINTF(1, ("unpeer: searching for %s\n", 4505 stoa(&peeraddr))); 4506 p = findexistingpeer(&peeraddr, NULL, NULL, -1, 0, NULL); 4507 if (p != NULL) { 4508 msyslog(LOG_NOTICE, "unpeered %s", 4509 stoa(&peeraddr)); 4510 peer_clear(p, "GONE"); 4511 unpeer(p); 4512 } 4513 continue; 4514 } 4515 /* 4516 * It's not a numeric IP address, it's a hostname. 4517 * Check for associations with a matching hostname. 4518 */ 4519 for (p = peer_list; p != NULL; p = p->p_link) 4520 if (p->hostname != NULL) 4521 if (!strcasecmp(p->hostname, name)) 4522 break; 4523 if (p != NULL) { 4524 msyslog(LOG_NOTICE, "unpeered %s", name); 4525 peer_clear(p, "GONE"); 4526 unpeer(p); 4527 } 4528 /* Resolve the hostname to address(es). */ 4529 # ifdef WORKER 4530 ZERO(hints); 4531 hints.ai_family = curr_unpeer->addr->type; 4532 hints.ai_socktype = SOCK_DGRAM; 4533 hints.ai_protocol = IPPROTO_UDP; 4534 getaddrinfo_sometime(name, "ntp", &hints, 4535 INITIAL_DNS_RETRY, 4536 &unpeer_name_resolved, NULL); 4537 # else /* !WORKER follows */ 4538 msyslog(LOG_ERR, 4539 "hostname %s can not be used, please use IP address instead.", 4540 name); 4541 # endif 4542 } 4543 } 4544 #endif /* !SIM */ 4545 4546 4547 /* 4548 * unpeer_name_resolved() 4549 * 4550 * Callback invoked when config_unpeers()'s DNS lookup completes. 4551 */ 4552 #ifdef WORKER 4553 static void 4554 unpeer_name_resolved( 4555 int rescode, 4556 int gai_errno, 4557 void * context, 4558 const char * name, 4559 const char * service, 4560 const struct addrinfo * hints, 4561 const struct addrinfo * res 4562 ) 4563 { 4564 sockaddr_u peeraddr; 4565 struct peer * peer; 4566 u_short af; 4567 const char * fam_spec; 4568 4569 (void)context; 4570 (void)hints; 4571 DPRINTF(1, ("unpeer_name_resolved(%s) rescode %d\n", name, rescode)); 4572 4573 if (rescode) { 4574 msyslog(LOG_ERR, "giving up resolving unpeer %s: %s (%d)", 4575 name, gai_strerror(rescode), rescode); 4576 return; 4577 } 4578 /* 4579 * Loop through the addresses found 4580 */ 4581 for (; res != NULL; res = res->ai_next) { 4582 INSIST(res->ai_addrlen <= sizeof(peeraddr)); 4583 memcpy(&peeraddr, res->ai_addr, res->ai_addrlen); 4584 DPRINTF(1, ("unpeer: searching for peer %s\n", 4585 stoa(&peeraddr))); 4586 peer = findexistingpeer(&peeraddr, NULL, NULL, -1, 0, NULL); 4587 if (peer != NULL) { 4588 af = AF(&peeraddr); 4589 fam_spec = (AF_INET6 == af) 4590 ? "(AAAA) " 4591 : (AF_INET == af) 4592 ? "(A) " 4593 : ""; 4594 msyslog(LOG_NOTICE, "unpeered %s %s-> %s", name, 4595 fam_spec, stoa(&peeraddr)); 4596 peer_clear(peer, "GONE"); 4597 unpeer(peer); 4598 } 4599 } 4600 } 4601 #endif /* WORKER */ 4602 4603 4604 #ifdef FREE_CFG_T 4605 static void 4606 free_config_unpeers( 4607 config_tree *ptree 4608 ) 4609 { 4610 unpeer_node *curr_unpeer; 4611 4612 if (ptree->unpeers != NULL) { 4613 for (;;) { 4614 UNLINK_FIFO(curr_unpeer, *ptree->unpeers, link); 4615 if (NULL == curr_unpeer) 4616 break; 4617 destroy_address_node(curr_unpeer->addr); 4618 free(curr_unpeer); 4619 } 4620 free(ptree->unpeers); 4621 } 4622 } 4623 #endif /* FREE_CFG_T */ 4624 4625 4626 #ifndef SIM 4627 static void 4628 config_reset_counters( 4629 config_tree *ptree 4630 ) 4631 { 4632 int_node *counter_set; 4633 4634 for (counter_set = HEAD_PFIFO(ptree->reset_counters); 4635 counter_set != NULL; 4636 counter_set = counter_set->link) { 4637 switch (counter_set->i) { 4638 default: 4639 DPRINTF(1, ("config_reset_counters %s (%d) invalid\n", 4640 keyword(counter_set->i), counter_set->i)); 4641 break; 4642 4643 case T_Allpeers: 4644 peer_all_reset(); 4645 break; 4646 4647 case T_Auth: 4648 reset_auth_stats(); 4649 break; 4650 4651 case T_Ctl: 4652 ctl_clr_stats(); 4653 break; 4654 4655 case T_Io: 4656 io_clr_stats(); 4657 break; 4658 4659 case T_Mem: 4660 peer_clr_stats(); 4661 break; 4662 4663 case T_Sys: 4664 proto_clr_stats(); 4665 break; 4666 4667 case T_Timer: 4668 timer_clr_stats(); 4669 break; 4670 } 4671 } 4672 } 4673 #endif /* !SIM */ 4674 4675 4676 #ifdef FREE_CFG_T 4677 static void 4678 free_config_reset_counters( 4679 config_tree *ptree 4680 ) 4681 { 4682 FREE_INT_FIFO(ptree->reset_counters); 4683 } 4684 #endif /* FREE_CFG_T */ 4685 4686 4687 #ifdef SIM 4688 static void 4689 config_sim( 4690 config_tree *ptree 4691 ) 4692 { 4693 int i; 4694 server_info *serv_info; 4695 attr_val *init_stmt; 4696 sim_node *sim_n; 4697 4698 /* Check if a simulate block was found in the configuration code. 4699 * If not, return an error and exit 4700 */ 4701 sim_n = HEAD_PFIFO(ptree->sim_details); 4702 if (NULL == sim_n) { 4703 fprintf(stderr, "ERROR!! I couldn't find a \"simulate\" block for configuring the simulator.\n"); 4704 fprintf(stderr, "\tCheck your configuration file.\n"); 4705 exit(1); 4706 } 4707 4708 /* Process the initialization statements 4709 * ------------------------------------- 4710 */ 4711 init_stmt = HEAD_PFIFO(sim_n->init_opts); 4712 for (; init_stmt != NULL; init_stmt = init_stmt->link) { 4713 switch(init_stmt->attr) { 4714 4715 case T_Beep_Delay: 4716 simulation.beep_delay = init_stmt->value.d; 4717 break; 4718 4719 case T_Sim_Duration: 4720 simulation.end_time = init_stmt->value.d; 4721 break; 4722 4723 default: 4724 fprintf(stderr, 4725 "Unknown simulator init token %d\n", 4726 init_stmt->attr); 4727 exit(1); 4728 } 4729 } 4730 4731 /* Process the server list 4732 * ----------------------- 4733 */ 4734 simulation.num_of_servers = 0; 4735 serv_info = HEAD_PFIFO(sim_n->servers); 4736 for (; serv_info != NULL; serv_info = serv_info->link) 4737 simulation.num_of_servers++; 4738 simulation.servers = eallocarray(simulation.num_of_servers, 4739 sizeof(simulation.servers[0])); 4740 4741 i = 0; 4742 serv_info = HEAD_PFIFO(sim_n->servers); 4743 for (; serv_info != NULL; serv_info = serv_info->link) { 4744 if (NULL == serv_info) { 4745 fprintf(stderr, "Simulator server list is corrupt\n"); 4746 exit(1); 4747 } else { 4748 simulation.servers[i] = *serv_info; 4749 simulation.servers[i].link = NULL; 4750 i++; 4751 } 4752 } 4753 4754 printf("Creating server associations\n"); 4755 create_server_associations(); 4756 fprintf(stderr,"\tServer associations successfully created!!\n"); 4757 } 4758 4759 4760 #ifdef FREE_CFG_T 4761 static void 4762 free_config_sim( 4763 config_tree *ptree 4764 ) 4765 { 4766 sim_node *sim_n; 4767 server_info *serv_n; 4768 script_info *script_n; 4769 4770 if (NULL == ptree->sim_details) 4771 return; 4772 sim_n = HEAD_PFIFO(ptree->sim_details); 4773 free(ptree->sim_details); 4774 ptree->sim_details = NULL; 4775 if (NULL == sim_n) 4776 return; 4777 4778 FREE_ATTR_VAL_FIFO(sim_n->init_opts); 4779 for (;;) { 4780 UNLINK_FIFO(serv_n, *sim_n->servers, link); 4781 if (NULL == serv_n) 4782 break; 4783 free(serv_n->curr_script); 4784 if (serv_n->script != NULL) { 4785 for (;;) { 4786 UNLINK_FIFO(script_n, *serv_n->script, 4787 link); 4788 if (script_n == NULL) 4789 break; 4790 free(script_n); 4791 } 4792 free(serv_n->script); 4793 } 4794 free(serv_n); 4795 } 4796 free(sim_n); 4797 } 4798 #endif /* FREE_CFG_T */ 4799 #endif /* SIM */ 4800 4801 4802 /* Define two different config functions. One for the daemon and the other for 4803 * the simulator. The simulator ignores a lot of the standard ntpd configuration 4804 * options 4805 */ 4806 #ifndef SIM 4807 static void 4808 config_ntpd( 4809 config_tree *ptree, 4810 int/*BOOL*/ input_from_files 4811 ) 4812 { 4813 /* [Bug 3435] check and esure clock sanity if configured from 4814 * file and clock sanity parameters (-> basedate) are given. Do 4815 * this ASAP, so we don't disturb the closed loop controller. 4816 */ 4817 if (input_from_files) { 4818 if (config_tos_clock(ptree)) 4819 clamp_systime(); 4820 } 4821 4822 config_nic_rules(ptree, input_from_files); 4823 config_monitor(ptree); 4824 config_auth(ptree); 4825 config_tos(ptree); 4826 config_access(ptree); 4827 config_tinker(ptree); 4828 config_rlimit(ptree); 4829 config_system_opts(ptree); 4830 config_logconfig(ptree); 4831 config_phone(ptree); 4832 config_mdnstries(ptree); 4833 config_setvar(ptree); 4834 config_ttl(ptree); 4835 config_vars(ptree); 4836 4837 io_open_sockets(); /* [bug 2837] dep. on config_vars() */ 4838 4839 config_trap(ptree); /* [bug 2923] dep. on io_open_sockets() */ 4840 config_other_modes(ptree); 4841 config_peers(ptree); 4842 config_unpeers(ptree); 4843 config_fudge(ptree); 4844 config_reset_counters(ptree); 4845 4846 #ifdef DEBUG 4847 if (debug > 1) { 4848 dump_restricts(); 4849 } 4850 #endif 4851 4852 #ifdef TEST_BLOCKING_WORKER 4853 { 4854 struct addrinfo hints; 4855 4856 ZERO(hints); 4857 hints.ai_socktype = SOCK_STREAM; 4858 hints.ai_protocol = IPPROTO_TCP; 4859 getaddrinfo_sometime("www.cnn.com", "ntp", &hints, 4860 INITIAL_DNS_RETRY, 4861 gai_test_callback, (void *)1); 4862 hints.ai_family = AF_INET6; 4863 getaddrinfo_sometime("ipv6.google.com", "ntp", &hints, 4864 INITIAL_DNS_RETRY, 4865 gai_test_callback, (void *)0x600); 4866 } 4867 #endif 4868 } 4869 #endif /* !SIM */ 4870 4871 4872 #ifdef SIM 4873 static void 4874 config_ntpdsim( 4875 config_tree *ptree 4876 ) 4877 { 4878 printf("Configuring Simulator...\n"); 4879 printf("Some ntpd-specific commands in the configuration file will be ignored.\n"); 4880 4881 config_tos(ptree); 4882 config_monitor(ptree); 4883 config_tinker(ptree); 4884 if (0) 4885 config_rlimit(ptree); /* not needed for the simulator */ 4886 config_system_opts(ptree); 4887 config_logconfig(ptree); 4888 config_vars(ptree); 4889 config_sim(ptree); 4890 } 4891 #endif /* SIM */ 4892 4893 4894 /* 4895 * config_remotely() - implements ntpd side of ntpq :config 4896 */ 4897 void 4898 config_remotely( 4899 sockaddr_u * remote_addr 4900 ) 4901 { 4902 char origin[128]; 4903 4904 snprintf(origin, sizeof(origin), "remote config from %s", 4905 stoa(remote_addr)); 4906 lex_init_stack(origin, NULL); /* no checking needed... */ 4907 init_syntax_tree(&cfgt); 4908 yyparse(); 4909 lex_drop_stack(); 4910 4911 cfgt.source.attr = CONF_SOURCE_NTPQ; 4912 cfgt.timestamp = time(NULL); 4913 cfgt.source.value.s = estrdup(stoa(remote_addr)); 4914 4915 DPRINTF(1, ("Finished Parsing!!\n")); 4916 4917 save_and_apply_config_tree(FALSE); 4918 } 4919 4920 4921 /* 4922 * getconfig() - process startup configuration file e.g /etc/ntp.conf 4923 */ 4924 void 4925 getconfig( 4926 int argc, 4927 char ** argv 4928 ) 4929 { 4930 char line[256]; 4931 4932 #ifdef DEBUG 4933 atexit(free_all_config_trees); 4934 #endif 4935 #ifndef SYS_WINNT 4936 config_file = CONFIG_FILE; 4937 #else 4938 temp = CONFIG_FILE; 4939 if (!ExpandEnvironmentStringsA(temp, config_file_storage, 4940 sizeof(config_file_storage))) { 4941 msyslog(LOG_ERR, "ExpandEnvironmentStrings CONFIG_FILE failed: %m"); 4942 exit(1); 4943 } 4944 config_file = config_file_storage; 4945 4946 temp = ALT_CONFIG_FILE; 4947 if (!ExpandEnvironmentStringsA(temp, alt_config_file_storage, 4948 sizeof(alt_config_file_storage))) { 4949 msyslog(LOG_ERR, "ExpandEnvironmentStrings ALT_CONFIG_FILE failed: %m"); 4950 exit(1); 4951 } 4952 alt_config_file = alt_config_file_storage; 4953 #endif /* SYS_WINNT */ 4954 4955 /* 4956 * install a non default variable with this daemon version 4957 */ 4958 snprintf(line, sizeof(line), "daemon_version=\"%s\"", Version); 4959 set_sys_var(line, strlen(line) + 1, RO); 4960 4961 /* 4962 * Set up for the first time step to install a variable showing 4963 * which syscall is being used to step. 4964 */ 4965 set_tod_using = &ntpd_set_tod_using; 4966 4967 getCmdOpts(argc, argv); 4968 init_syntax_tree(&cfgt); 4969 if ( 4970 !lex_init_stack(FindConfig(config_file), "r") 4971 #ifdef HAVE_NETINFO 4972 /* If there is no config_file, try NetInfo. */ 4973 && check_netinfo && !(config_netinfo = get_netinfo_config()) 4974 #endif /* HAVE_NETINFO */ 4975 ) { 4976 msyslog(LOG_INFO, "getconfig: Couldn't open <%s>: %m", FindConfig(config_file)); 4977 #ifndef SYS_WINNT 4978 io_open_sockets(); 4979 4980 return; 4981 #else 4982 /* Under WinNT try alternate_config_file name, first NTP.CONF, then NTP.INI */ 4983 4984 if (!lex_init_stack(FindConfig(alt_config_file), "r")) { 4985 /* 4986 * Broadcast clients can sometimes run without 4987 * a configuration file. 4988 */ 4989 msyslog(LOG_INFO, "getconfig: Couldn't open <%s>: %m", FindConfig(alt_config_file)); 4990 io_open_sockets(); 4991 4992 return; 4993 } 4994 cfgt.source.value.s = estrdup(alt_config_file); 4995 #endif /* SYS_WINNT */ 4996 } else 4997 cfgt.source.value.s = estrdup(config_file); 4998 4999 5000 /*** BULK OF THE PARSER ***/ 5001 #ifdef DEBUG 5002 yydebug = !!(debug >= 5); 5003 #endif 5004 yyparse(); 5005 lex_drop_stack(); 5006 5007 DPRINTF(1, ("Finished Parsing!!\n")); 5008 5009 cfgt.source.attr = CONF_SOURCE_FILE; 5010 cfgt.timestamp = time(NULL); 5011 5012 save_and_apply_config_tree(TRUE); 5013 5014 #ifdef HAVE_NETINFO 5015 if (config_netinfo) 5016 free_netinfo_config(config_netinfo); 5017 #endif /* HAVE_NETINFO */ 5018 } 5019 5020 5021 void 5022 save_and_apply_config_tree(int/*BOOL*/ input_from_file) 5023 { 5024 config_tree *ptree; 5025 #ifndef SAVECONFIG 5026 config_tree *punlinked; 5027 #endif 5028 5029 /* 5030 * Keep all the configuration trees applied since startup in 5031 * a list that can be used to dump the configuration back to 5032 * a text file. 5033 */ 5034 ptree = emalloc(sizeof(*ptree)); 5035 memcpy(ptree, &cfgt, sizeof(*ptree)); 5036 ZERO(cfgt); 5037 5038 LINK_TAIL_SLIST(cfg_tree_history, ptree, link, config_tree); 5039 5040 #ifdef SAVECONFIG 5041 if (HAVE_OPT( SAVECONFIGQUIT )) { 5042 FILE *dumpfile; 5043 int err; 5044 int dumpfailed; 5045 5046 dumpfile = fopen(OPT_ARG( SAVECONFIGQUIT ), "w"); 5047 if (NULL == dumpfile) { 5048 err = errno; 5049 mfprintf(stderr, 5050 "can not create save file %s, error %d %m\n", 5051 OPT_ARG(SAVECONFIGQUIT), err); 5052 exit(err); 5053 } 5054 5055 dumpfailed = dump_all_config_trees(dumpfile, 0); 5056 if (dumpfailed) 5057 fprintf(stderr, 5058 "--saveconfigquit %s error %d\n", 5059 OPT_ARG( SAVECONFIGQUIT ), 5060 dumpfailed); 5061 else 5062 fprintf(stderr, 5063 "configuration saved to %s\n", 5064 OPT_ARG( SAVECONFIGQUIT )); 5065 5066 exit(dumpfailed); 5067 } 5068 #endif /* SAVECONFIG */ 5069 5070 /* The actual configuration done depends on whether we are configuring the 5071 * simulator or the daemon. Perform a check and call the appropriate 5072 * function as needed. 5073 */ 5074 5075 #ifndef SIM 5076 config_ntpd(ptree, input_from_file); 5077 #else 5078 config_ntpdsim(ptree); 5079 #endif 5080 5081 /* 5082 * With configure --disable-saveconfig, there's no use keeping 5083 * the config tree around after application, so free it. 5084 */ 5085 #ifndef SAVECONFIG 5086 UNLINK_SLIST(punlinked, cfg_tree_history, ptree, link, 5087 config_tree); 5088 INSIST(punlinked == ptree); 5089 free_config_tree(ptree); 5090 #endif 5091 } 5092 5093 /* Hack to disambiguate 'server' statements for refclocks and network peers. 5094 * Please note the qualification 'hack'. It's just that. 5095 */ 5096 static int/*BOOL*/ 5097 is_refclk_addr( 5098 const address_node * addr 5099 ) 5100 { 5101 return addr && addr->address && !strncmp(addr->address, "127.127.", 8); 5102 } 5103 5104 static void 5105 ntpd_set_tod_using( 5106 const char *which 5107 ) 5108 { 5109 char line[128]; 5110 5111 snprintf(line, sizeof(line), "settimeofday=\"%s\"", which); 5112 set_sys_var(line, strlen(line) + 1, RO); 5113 } 5114 5115 5116 static char * 5117 normal_dtoa( 5118 double d 5119 ) 5120 { 5121 char * buf; 5122 char * pch_e; 5123 char * pch_nz; 5124 5125 LIB_GETBUF(buf); 5126 snprintf(buf, LIB_BUFLENGTH, "%g", d); 5127 5128 /* use lowercase 'e', strip any leading zeroes in exponent */ 5129 pch_e = strchr(buf, 'e'); 5130 if (NULL == pch_e) { 5131 pch_e = strchr(buf, 'E'); 5132 if (NULL == pch_e) 5133 return buf; 5134 *pch_e = 'e'; 5135 } 5136 pch_e++; 5137 if ('-' == *pch_e) 5138 pch_e++; 5139 pch_nz = pch_e; 5140 while ('0' == *pch_nz) 5141 pch_nz++; 5142 if (pch_nz == pch_e) 5143 return buf; 5144 strlcpy(pch_e, pch_nz, LIB_BUFLENGTH - (pch_e - buf)); 5145 5146 return buf; 5147 } 5148 5149 5150 /* FUNCTIONS COPIED FROM THE OLDER ntp_config.c 5151 * -------------------------------------------- 5152 */ 5153 5154 5155 /* 5156 * get_pfxmatch - find value for prefixmatch 5157 * and update char * accordingly 5158 */ 5159 static u_int32 5160 get_pfxmatch( 5161 const char ** pstr, 5162 struct masks * m 5163 ) 5164 { 5165 while (m->name != NULL) { 5166 if (strncmp(*pstr, m->name, strlen(m->name)) == 0) { 5167 *pstr += strlen(m->name); 5168 return m->mask; 5169 } else { 5170 m++; 5171 } 5172 } 5173 return 0; 5174 } 5175 5176 /* 5177 * get_match - find logmask value 5178 */ 5179 static u_int32 5180 get_match( 5181 const char * str, 5182 struct masks * m 5183 ) 5184 { 5185 while (m->name != NULL) { 5186 if (strcmp(str, m->name) == 0) 5187 return m->mask; 5188 else 5189 m++; 5190 } 5191 return 0; 5192 } 5193 5194 /* 5195 * get_logmask - build bitmask for ntp_syslogmask 5196 */ 5197 static u_int32 5198 get_logmask( 5199 const char * str 5200 ) 5201 { 5202 const char * t; 5203 u_int32 offset; 5204 u_int32 mask; 5205 5206 mask = get_match(str, logcfg_noclass_items); 5207 if (mask != 0) 5208 return mask; 5209 5210 t = str; 5211 offset = get_pfxmatch(&t, logcfg_class); 5212 mask = get_match(t, logcfg_class_items); 5213 5214 if (mask) 5215 return mask << offset; 5216 else 5217 msyslog(LOG_ERR, "logconfig: '%s' not recognized - ignored", 5218 str); 5219 5220 return 0; 5221 } 5222 5223 5224 #ifdef HAVE_NETINFO 5225 5226 /* 5227 * get_netinfo_config - find the nearest NetInfo domain with an ntp 5228 * configuration and initialize the configuration state. 5229 */ 5230 static struct netinfo_config_state * 5231 get_netinfo_config(void) 5232 { 5233 ni_status status; 5234 void *domain; 5235 ni_id config_dir; 5236 struct netinfo_config_state *config; 5237 5238 if (ni_open(NULL, ".", &domain) != NI_OK) return NULL; 5239 5240 while ((status = ni_pathsearch(domain, &config_dir, NETINFO_CONFIG_DIR)) == NI_NODIR) { 5241 void *next_domain; 5242 if (ni_open(domain, "..", &next_domain) != NI_OK) { 5243 ni_free(next_domain); 5244 break; 5245 } 5246 ni_free(domain); 5247 domain = next_domain; 5248 } 5249 if (status != NI_OK) { 5250 ni_free(domain); 5251 return NULL; 5252 } 5253 5254 config = emalloc(sizeof(*config)); 5255 config->domain = domain; 5256 config->config_dir = config_dir; 5257 config->prop_index = 0; 5258 config->val_index = 0; 5259 config->val_list = NULL; 5260 5261 return config; 5262 } 5263 5264 5265 /* 5266 * free_netinfo_config - release NetInfo configuration state 5267 */ 5268 static void 5269 free_netinfo_config( 5270 struct netinfo_config_state *config 5271 ) 5272 { 5273 ni_free(config->domain); 5274 free(config); 5275 } 5276 5277 5278 /* 5279 * gettokens_netinfo - return tokens from NetInfo 5280 */ 5281 static int 5282 gettokens_netinfo ( 5283 struct netinfo_config_state *config, 5284 char **tokenlist, 5285 int *ntokens 5286 ) 5287 { 5288 int prop_index = config->prop_index; 5289 int val_index = config->val_index; 5290 char **val_list = config->val_list; 5291 5292 /* 5293 * Iterate through each keyword and look for a property that matches it. 5294 */ 5295 again: 5296 if (!val_list) { 5297 for (; prop_index < COUNTOF(keywords); prop_index++) 5298 { 5299 ni_namelist namelist; 5300 struct keyword current_prop = keywords[prop_index]; 5301 ni_index index; 5302 5303 /* 5304 * For each value associated in the property, we're going to return 5305 * a separate line. We squirrel away the values in the config state 5306 * so the next time through, we don't need to do this lookup. 5307 */ 5308 NI_INIT(&namelist); 5309 if (NI_OK == ni_lookupprop(config->domain, 5310 &config->config_dir, current_prop.text, 5311 &namelist)) { 5312 5313 /* Found the property, but it has no values */ 5314 if (namelist.ni_namelist_len == 0) continue; 5315 5316 config->val_list = 5317 eallocarray( 5318 (namelist.ni_namelist_len + 1), 5319 sizeof(char*)); 5320 val_list = config->val_list; 5321 5322 for (index = 0; 5323 index < namelist.ni_namelist_len; 5324 index++) { 5325 char *value; 5326 5327 value = namelist.ni_namelist_val[index]; 5328 val_list[index] = estrdup(value); 5329 } 5330 val_list[index] = NULL; 5331 5332 break; 5333 } 5334 ni_namelist_free(&namelist); 5335 } 5336 config->prop_index = prop_index; 5337 } 5338 5339 /* No list; we're done here. */ 5340 if (!val_list) 5341 return CONFIG_UNKNOWN; 5342 5343 /* 5344 * We have a list of values for the current property. 5345 * Iterate through them and return each in order. 5346 */ 5347 if (val_list[val_index]) { 5348 int ntok = 1; 5349 int quoted = 0; 5350 char *tokens = val_list[val_index]; 5351 5352 msyslog(LOG_INFO, "%s %s", keywords[prop_index].text, val_list[val_index]); 5353 5354 (const char*)tokenlist[0] = keywords[prop_index].text; 5355 for (ntok = 1; ntok < MAXTOKENS; ntok++) { 5356 tokenlist[ntok] = tokens; 5357 while (!ISEOL(*tokens) && (!ISSPACE(*tokens) || quoted)) 5358 quoted ^= (*tokens++ == '"'); 5359 5360 if (ISEOL(*tokens)) { 5361 *tokens = '\0'; 5362 break; 5363 } else { /* must be space */ 5364 *tokens++ = '\0'; 5365 while (ISSPACE(*tokens)) 5366 tokens++; 5367 if (ISEOL(*tokens)) 5368 break; 5369 } 5370 } 5371 5372 if (ntok == MAXTOKENS) { 5373 /* HMS: chomp it to lose the EOL? */ 5374 msyslog(LOG_ERR, 5375 "gettokens_netinfo: too many tokens. Ignoring: %s", 5376 tokens); 5377 } else { 5378 *ntokens = ntok + 1; 5379 } 5380 5381 config->val_index++; /* HMS: Should this be in the 'else'? */ 5382 5383 return keywords[prop_index].keytype; 5384 } 5385 5386 /* We're done with the current property. */ 5387 prop_index = ++config->prop_index; 5388 5389 /* Free val_list and reset counters. */ 5390 for (val_index = 0; val_list[val_index]; val_index++) 5391 free(val_list[val_index]); 5392 free(val_list); 5393 val_list = config->val_list = NULL; 5394 val_index = config->val_index = 0; 5395 5396 goto again; 5397 } 5398 #endif /* HAVE_NETINFO */ 5399 5400 5401 /* 5402 * getnetnum - return a net number (this is crude, but careful) 5403 * 5404 * returns 1 for success, and mysteriously, 0 for most failures, and 5405 * -1 if the address found is IPv6 and we believe IPv6 isn't working. 5406 */ 5407 #ifndef SIM 5408 static int 5409 getnetnum( 5410 const char *num, 5411 sockaddr_u *addr, 5412 int complain, 5413 enum gnn_type a_type /* ignored */ 5414 ) 5415 { 5416 REQUIRE(AF_UNSPEC == AF(addr) || 5417 AF_INET == AF(addr) || 5418 AF_INET6 == AF(addr)); 5419 5420 if (!is_ip_address(num, AF(addr), addr)) 5421 return 0; 5422 5423 if (IS_IPV6(addr) && !ipv6_works) 5424 return -1; 5425 5426 # ifdef ISC_PLATFORM_HAVESALEN 5427 addr->sa.sa_len = SIZEOF_SOCKADDR(AF(addr)); 5428 # endif 5429 SET_PORT(addr, NTP_PORT); 5430 5431 DPRINTF(2, ("getnetnum given %s, got %s\n", num, stoa(addr))); 5432 5433 return 1; 5434 } 5435 #endif /* !SIM */ 5436 5437 #if defined(HAVE_SETRLIMIT) 5438 void 5439 ntp_rlimit( 5440 int rl_what, 5441 rlim_t rl_value, 5442 int rl_scale, 5443 const char * rl_sstr 5444 ) 5445 { 5446 struct rlimit rl; 5447 5448 switch (rl_what) { 5449 # ifdef RLIMIT_MEMLOCK 5450 case RLIMIT_MEMLOCK: 5451 if (HAVE_OPT( SAVECONFIGQUIT )) { 5452 break; 5453 } 5454 /* 5455 * The default RLIMIT_MEMLOCK is very low on Linux systems. 5456 * Unless we increase this limit malloc calls are likely to 5457 * fail if we drop root privilege. To be useful the value 5458 * has to be larger than the largest ntpd resident set size. 5459 */ 5460 DPRINTF(2, ("ntp_rlimit: MEMLOCK: %d %s\n", 5461 (int)(rl_value / rl_scale), rl_sstr)); 5462 rl.rlim_cur = rl.rlim_max = rl_value; 5463 if (setrlimit(RLIMIT_MEMLOCK, &rl) == -1) 5464 msyslog(LOG_ERR, "Cannot set RLIMIT_MEMLOCK: %m"); 5465 break; 5466 # endif /* RLIMIT_MEMLOCK */ 5467 5468 # ifdef RLIMIT_NOFILE 5469 case RLIMIT_NOFILE: 5470 /* 5471 * For large systems the default file descriptor limit may 5472 * not be enough. 5473 */ 5474 DPRINTF(2, ("ntp_rlimit: NOFILE: %d %s\n", 5475 (int)(rl_value / rl_scale), rl_sstr)); 5476 rl.rlim_cur = rl.rlim_max = rl_value; 5477 if (setrlimit(RLIMIT_NOFILE, &rl) == -1) 5478 msyslog(LOG_ERR, "Cannot set RLIMIT_NOFILE: %m"); 5479 break; 5480 # endif /* RLIMIT_NOFILE */ 5481 5482 # ifdef RLIMIT_STACK 5483 case RLIMIT_STACK: 5484 /* 5485 * Provide a way to set the stack limit to something 5486 * smaller, so that we don't lock a lot of unused 5487 * stack memory. 5488 */ 5489 DPRINTF(2, ("ntp_rlimit: STACK: %d %s pages\n", 5490 (int)(rl_value / rl_scale), rl_sstr)); 5491 if (-1 == getrlimit(RLIMIT_STACK, &rl)) { 5492 msyslog(LOG_ERR, "getrlimit(RLIMIT_STACK) failed: %m"); 5493 } else { 5494 if (rl_value > rl.rlim_max) { 5495 msyslog(LOG_WARNING, 5496 "ntp_rlimit: using maximum allowed stack limit %lu instead of %lu.", 5497 (u_long)rl.rlim_max, 5498 (u_long)rl_value); 5499 rl_value = rl.rlim_max; 5500 } 5501 rl.rlim_cur = rl_value; 5502 if (-1 == setrlimit(RLIMIT_STACK, &rl)) { 5503 msyslog(LOG_ERR, 5504 "ntp_rlimit: Cannot set RLIMIT_STACK: %m"); 5505 } 5506 } 5507 break; 5508 # endif /* RLIMIT_STACK */ 5509 5510 default: 5511 fatal_error("ntp_rlimit: unexpected RLIMIT case: %d", rl_what); 5512 } 5513 } 5514 #endif /* HAVE_SETRLIMIT */ 5515 5516 5517 char * 5518 build_iflags( 5519 u_int32 iflags 5520 ) 5521 { 5522 static char ifs[1024]; 5523 5524 ifs[0] = '\0'; 5525 5526 if (iflags & INT_UP) { 5527 iflags &= ~INT_UP; 5528 appendstr(ifs, sizeof ifs, "up"); 5529 } 5530 5531 if (iflags & INT_PPP) { 5532 iflags &= ~INT_PPP; 5533 appendstr(ifs, sizeof ifs, "ppp"); 5534 } 5535 5536 if (iflags & INT_LOOPBACK) { 5537 iflags &= ~INT_LOOPBACK; 5538 appendstr(ifs, sizeof ifs, "loopback"); 5539 } 5540 5541 if (iflags & INT_BROADCAST) { 5542 iflags &= ~INT_BROADCAST; 5543 appendstr(ifs, sizeof ifs, "broadcast"); 5544 } 5545 5546 if (iflags & INT_MULTICAST) { 5547 iflags &= ~INT_MULTICAST; 5548 appendstr(ifs, sizeof ifs, "multicast"); 5549 } 5550 5551 if (iflags & INT_BCASTOPEN) { 5552 iflags &= ~INT_BCASTOPEN; 5553 appendstr(ifs, sizeof ifs, "bcastopen"); 5554 } 5555 5556 if (iflags & INT_MCASTOPEN) { 5557 iflags &= ~INT_MCASTOPEN; 5558 appendstr(ifs, sizeof ifs, "mcastopen"); 5559 } 5560 5561 if (iflags & INT_WILDCARD) { 5562 iflags &= ~INT_WILDCARD; 5563 appendstr(ifs, sizeof ifs, "wildcard"); 5564 } 5565 5566 if (iflags & INT_MCASTIF) { 5567 iflags &= ~INT_MCASTIF; 5568 appendstr(ifs, sizeof ifs, "MCASTif"); 5569 } 5570 5571 if (iflags & INT_PRIVACY) { 5572 iflags &= ~INT_PRIVACY; 5573 appendstr(ifs, sizeof ifs, "IPv6privacy"); 5574 } 5575 5576 if (iflags & INT_BCASTXMIT) { 5577 iflags &= ~INT_BCASTXMIT; 5578 appendstr(ifs, sizeof ifs, "bcastxmit"); 5579 } 5580 5581 if (iflags) { 5582 char string[10]; 5583 5584 snprintf(string, sizeof string, "%0x", iflags); 5585 appendstr(ifs, sizeof ifs, string); 5586 } 5587 5588 return ifs; 5589 } 5590 5591 5592 char * 5593 build_mflags( 5594 u_short mflags 5595 ) 5596 { 5597 static char mfs[1024]; 5598 5599 mfs[0] = '\0'; 5600 5601 if (mflags & RESM_NTPONLY) { 5602 mflags &= ~RESM_NTPONLY; 5603 appendstr(mfs, sizeof mfs, "ntponly"); 5604 } 5605 5606 if (mflags & RESM_SOURCE) { 5607 mflags &= ~RESM_SOURCE; 5608 appendstr(mfs, sizeof mfs, "source"); 5609 } 5610 5611 if (mflags) { 5612 char string[10]; 5613 5614 snprintf(string, sizeof string, "%0x", mflags); 5615 appendstr(mfs, sizeof mfs, string); 5616 } 5617 5618 return mfs; 5619 } 5620 5621 5622 char * 5623 build_rflags( 5624 u_short rflags 5625 ) 5626 { 5627 static char rfs[1024]; 5628 5629 rfs[0] = '\0'; 5630 5631 if (rflags & RES_FLAKE) { 5632 rflags &= ~RES_FLAKE; 5633 appendstr(rfs, sizeof rfs, "flake"); 5634 } 5635 5636 if (rflags & RES_IGNORE) { 5637 rflags &= ~RES_IGNORE; 5638 appendstr(rfs, sizeof rfs, "ignore"); 5639 } 5640 5641 if (rflags & RES_KOD) { 5642 rflags &= ~RES_KOD; 5643 appendstr(rfs, sizeof rfs, "kod"); 5644 } 5645 5646 if (rflags & RES_MSSNTP) { 5647 rflags &= ~RES_MSSNTP; 5648 appendstr(rfs, sizeof rfs, "mssntp"); 5649 } 5650 5651 if (rflags & RES_LIMITED) { 5652 rflags &= ~RES_LIMITED; 5653 appendstr(rfs, sizeof rfs, "limited"); 5654 } 5655 5656 if (rflags & RES_LPTRAP) { 5657 rflags &= ~RES_LPTRAP; 5658 appendstr(rfs, sizeof rfs, "lptrap"); 5659 } 5660 5661 if (rflags & RES_NOMODIFY) { 5662 rflags &= ~RES_NOMODIFY; 5663 appendstr(rfs, sizeof rfs, "nomodify"); 5664 } 5665 5666 if (rflags & RES_NOMRULIST) { 5667 rflags &= ~RES_NOMRULIST; 5668 appendstr(rfs, sizeof rfs, "nomrulist"); 5669 } 5670 5671 if (rflags & RES_NOEPEER) { 5672 rflags &= ~RES_NOEPEER; 5673 appendstr(rfs, sizeof rfs, "noepeer"); 5674 } 5675 5676 if (rflags & RES_NOPEER) { 5677 rflags &= ~RES_NOPEER; 5678 appendstr(rfs, sizeof rfs, "nopeer"); 5679 } 5680 5681 if (rflags & RES_NOQUERY) { 5682 rflags &= ~RES_NOQUERY; 5683 appendstr(rfs, sizeof rfs, "noquery"); 5684 } 5685 5686 if (rflags & RES_DONTSERVE) { 5687 rflags &= ~RES_DONTSERVE; 5688 appendstr(rfs, sizeof rfs, "dontserve"); 5689 } 5690 5691 if (rflags & RES_NOTRAP) { 5692 rflags &= ~RES_NOTRAP; 5693 appendstr(rfs, sizeof rfs, "notrap"); 5694 } 5695 5696 if (rflags & RES_DONTTRUST) { 5697 rflags &= ~RES_DONTTRUST; 5698 appendstr(rfs, sizeof rfs, "notrust"); 5699 } 5700 5701 if (rflags & RES_SRVRSPFUZ) { 5702 rflags &= ~RES_SRVRSPFUZ; 5703 appendstr(rfs, sizeof rfs, "srvrspfuz"); 5704 } 5705 5706 if (rflags & RES_VERSION) { 5707 rflags &= ~RES_VERSION; 5708 appendstr(rfs, sizeof rfs, "version"); 5709 } 5710 5711 if (rflags) { 5712 char string[10]; 5713 5714 snprintf(string, sizeof string, "%0x", rflags); 5715 appendstr(rfs, sizeof rfs, string); 5716 } 5717 5718 if ('\0' == rfs[0]) { 5719 appendstr(rfs, sizeof rfs, "(none)"); 5720 } 5721 5722 return rfs; 5723 } 5724 5725 5726 static void 5727 appendstr( 5728 char *string, 5729 size_t s, 5730 const char *new 5731 ) 5732 { 5733 if (*string != '\0') { 5734 (void)strlcat(string, ",", s); 5735 } 5736 (void)strlcat(string, new, s); 5737 5738 return; 5739 } 5740