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