contrib/ntp/ntpd/ntp_config.c

   1 /*
   2  * ntp_config.c - read and apply configuration information
   3  */
   4 #ifdef HAVE_CONFIG_H
   5 # include <config.h>
   6 #endif
   7
   8 #ifdef HAVE_NETINFO
   9 # include <netinfo/ni.h>
  10 #endif
  11
  12 #include "ntpd.h"
  13 #include "ntp_io.h"
  14 #include "ntp_unixtime.h"
  15 #include "ntp_refclock.h"
  16 #include "ntp_filegen.h"
  17 #include "ntp_stdlib.h"
  18 #include <ntp_random.h>
  19 #include <isc/net.h>
  20 #include <isc/result.h>
  21
  22 #include <stdio.h>
  23 #include <ctype.h>
  24 #ifdef HAVE_SYS_PARAM_H
  25 #include <sys/param.h>
  26 #endif
  27 #include <signal.h>
  28 #ifndef SIGCHLD
  29 # define SIGCHLD SIGCLD
  30 #endif
  31 #if !defined(VMS)
  32 # ifdef HAVE_SYS_WAIT_H
  33 #  include <sys/wait.h>
  34 # endif
  35 #endif /* VMS */
  36
  37 #ifdef SYS_WINNT
  38 # include <io.h>
  39 static HANDLE ResolverThreadHandle = NULL;
  40 HANDLE ResolverEventHandle;
  41 #else
  42 int resolver_pipe_fd[2];  /* used to let the resolver process alert the parent process */
  43 #endif /* SYS_WINNT */
  44
  45 /*
  46  * [Bug 467]: Some linux headers collide with CONFIG_PHONE and CONFIG_KEYS
  47  * so #include these later.
  48  */
  49
  50 #include "ntp_config.h"
  51 #include "ntp_cmdargs.h"
  52
  53 extern int priority_done;
  54
  55 /*
  56  * These routines are used to read the configuration file at
  57  * startup time.  An entry in the file must fit on a single line.
  58  * Entries are processed as multiple tokens separated by white space
  59  * Lines are considered terminated when a '#' is encountered.  Blank
  60  * lines are ignored.
  61  */
  62 /*
  63  * Translation table - keywords to function index
  64  */
  65 struct keyword {
  66         const char *text;
  67         int keytype;
  68 };
  69
  70 /*
  71  * Command keywords
  72  */
  73 static  struct keyword keywords[] = {
  74         { "automax",            CONFIG_AUTOMAX },
  75         { "broadcast",          CONFIG_BROADCAST },
  76         { "broadcastclient",    CONFIG_BROADCASTCLIENT },
  77         { "broadcastdelay",     CONFIG_BDELAY },
  78         { "calldelay",          CONFIG_CDELAY},
  79 #ifdef OPENSSL
  80         { "crypto",             CONFIG_CRYPTO },
  81 #endif /* OPENSSL */
  82         { "controlkey",         CONFIG_CONTROLKEY },
  83         { "disable",            CONFIG_DISABLE },
  84         { "driftfile",          CONFIG_DRIFTFILE },
  85         { "enable",             CONFIG_ENABLE },
  86         { "end",                CONFIG_END },
  87         { "filegen",            CONFIG_FILEGEN },
  88         { "fudge",              CONFIG_FUDGE },
  89         { "includefile",        CONFIG_INCLUDEFILE },
  90         { "keys",               CONFIG_KEYS },
  91         { "keysdir",            CONFIG_KEYSDIR },
  92         { "logconfig",          CONFIG_LOGCONFIG },
  93         { "logfile",            CONFIG_LOGFILE },
  94         { "manycastclient",     CONFIG_MANYCASTCLIENT },
  95         { "manycastserver",     CONFIG_MANYCASTSERVER },
  96         { "multicastclient",    CONFIG_MULTICASTCLIENT },
  97         { "peer",               CONFIG_PEER },
  98         { "phone",              CONFIG_PHONE },
  99         { "pidfile",            CONFIG_PIDFILE },
 100         { "discard",            CONFIG_DISCARD },
 101         { "requestkey",         CONFIG_REQUESTKEY },
 102         { "restrict",           CONFIG_RESTRICT },
 103         { "revoke",             CONFIG_REVOKE },
 104         { "server",             CONFIG_SERVER },
 105         { "setvar",             CONFIG_SETVAR },
 106         { "statistics",         CONFIG_STATISTICS },
 107         { "statsdir",           CONFIG_STATSDIR },
 108         { "tick",               CONFIG_ADJ },
 109         { "tinker",             CONFIG_TINKER },
 110         { "tos",                CONFIG_TOS },
 111         { "trap",               CONFIG_TRAP },
 112         { "trustedkey",         CONFIG_TRUSTEDKEY },
 113         { "ttl",                CONFIG_TTL },
 114         { "",                   CONFIG_UNKNOWN }
 115 };
 116
 117 /*
 118  * "peer", "server", "broadcast" modifier keywords
 119  */
 120 static  struct keyword mod_keywords[] = {
 121         { "autokey",            CONF_MOD_SKEY },
 122         { "burst",              CONF_MOD_BURST },
 123         { "iburst",             CONF_MOD_IBURST },
 124         { "key",                CONF_MOD_KEY },
 125         { "maxpoll",            CONF_MOD_MAXPOLL },
 126         { "minpoll",            CONF_MOD_MINPOLL },
 127         { "mode",               CONF_MOD_MODE },    /* refclocks */
 128         { "noselect",           CONF_MOD_NOSELECT },
 129         { "preempt",            CONF_MOD_PREEMPT },
 130         { "true",               CONF_MOD_TRUE },
 131         { "prefer",             CONF_MOD_PREFER },
 132         { "ttl",                CONF_MOD_TTL },     /* NTP peers */
 133         { "version",            CONF_MOD_VERSION },
 134         { "dynamic",            CONF_MOD_DYNAMIC },
 135         { "",                   CONFIG_UNKNOWN }
 136 };
 137
 138 /*
 139  * "restrict" modifier keywords
 140  */
 141 static  struct keyword res_keywords[] = {
 142         { "ignore",             CONF_RES_IGNORE },
 143         { "limited",            CONF_RES_LIMITED },
 144         { "kod",                CONF_RES_DEMOBILIZE },
 145         { "lowpriotrap",        CONF_RES_LPTRAP },
 146         { "mask",               CONF_RES_MASK },
 147         { "nomodify",           CONF_RES_NOMODIFY },
 148         { "nopeer",             CONF_RES_NOPEER },
 149         { "noquery",            CONF_RES_NOQUERY },
 150         { "noserve",            CONF_RES_NOSERVE },
 151         { "notrap",             CONF_RES_NOTRAP },
 152         { "notrust",            CONF_RES_NOTRUST },
 153         { "ntpport",            CONF_RES_NTPPORT },
 154         { "version",            CONF_RES_VERSION },
 155         { "",                   CONFIG_UNKNOWN }
 156 };
 157
 158 /*
 159  * "trap" modifier keywords
 160  */
 161 static  struct keyword trap_keywords[] = {
 162         { "port",               CONF_TRAP_PORT },
 163         { "interface",          CONF_TRAP_INTERFACE },
 164         { "",                   CONFIG_UNKNOWN }
 165 };
 166
 167 /*
 168  * "fudge" modifier keywords
 169  */
 170 static  struct keyword fudge_keywords[] = {
 171         { "flag1",              CONF_FDG_FLAG1 },
 172         { "flag2",              CONF_FDG_FLAG2 },
 173         { "flag3",              CONF_FDG_FLAG3 },
 174         { "flag4",              CONF_FDG_FLAG4 },
 175         { "refid",              CONF_FDG_REFID }, /* this mapping should be cleaned up (endianness, \0) - kd 20041031 */
 176         { "stratum",            CONF_FDG_STRATUM },
 177         { "time1",              CONF_FDG_TIME1 },
 178         { "time2",              CONF_FDG_TIME2 },
 179         { "",                   CONFIG_UNKNOWN }
 180 };
 181
 182 /*
 183  * "filegen" modifier keywords
 184  */
 185 static  struct keyword filegen_keywords[] = {
 186         { "disable",            CONF_FGEN_FLAG_DISABLE },
 187         { "enable",             CONF_FGEN_FLAG_ENABLE },
 188         { "file",               CONF_FGEN_FILE },
 189         { "link",               CONF_FGEN_FLAG_LINK },
 190         { "nolink",             CONF_FGEN_FLAG_NOLINK },
 191         { "type",               CONF_FGEN_TYPE },
 192         { "",                   CONFIG_UNKNOWN }
 193 };
 194
 195 /*
 196  * "type" modifier keywords
 197  */
 198 static  struct keyword fgen_types[] = {
 199         { "age",                FILEGEN_AGE   },
 200         { "day",                FILEGEN_DAY   },
 201         { "month",              FILEGEN_MONTH },
 202         { "none",               FILEGEN_NONE  },
 203         { "pid",                FILEGEN_PID   },
 204         { "week",               FILEGEN_WEEK  },
 205         { "year",               FILEGEN_YEAR  },
 206         { "",                   CONFIG_UNKNOWN}
 207 };
 208
 209 /*
 210  * "enable", "disable" modifier keywords
 211  */
 212 static struct keyword flags_keywords[] = {
 213         { "auth",               PROTO_AUTHENTICATE },
 214         { "bclient",            PROTO_BROADCLIENT },
 215         { "calibrate",          PROTO_CAL },
 216         { "kernel",             PROTO_KERNEL },
 217         { "monitor",            PROTO_MONITOR },
 218         { "ntp",                PROTO_NTP },
 219         { "stats",              PROTO_FILEGEN },
 220         { "",                   CONFIG_UNKNOWN }
 221 };
 222
 223 /*
 224  * "discard" modifier keywords
 225  */
 226 static struct keyword discard_keywords[] = {
 227         { "average",            CONF_DISCARD_AVERAGE },
 228         { "minimum",            CONF_DISCARD_MINIMUM },
 229         { "monitor",            CONF_DISCARD_MONITOR },
 230         { "",                   CONFIG_UNKNOWN }
 231 };
 232
 233 /*
 234  * "tinker" modifier keywords
 235  */
 236 static struct keyword tinker_keywords[] = {
 237         { "step",               CONF_CLOCK_MAX },
 238         { "panic",              CONF_CLOCK_PANIC },
 239         { "dispersion",         CONF_CLOCK_PHI },
 240         { "stepout",            CONF_CLOCK_MINSTEP },
 241         { "allan",              CONF_CLOCK_ALLAN },
 242         { "huffpuff",           CONF_CLOCK_HUFFPUFF },
 243         { "freq",               CONF_CLOCK_FREQ },
 244         { "",                   CONFIG_UNKNOWN }
 245 };
 246
 247 /*
 248  * "tos" modifier keywords
 249  */
 250 static struct keyword tos_keywords[] = {
 251         { "minclock",           CONF_TOS_MINCLOCK },
 252         { "maxclock",           CONF_TOS_MAXCLOCK },
 253         { "minsane",            CONF_TOS_MINSANE },
 254         { "floor",              CONF_TOS_FLOOR },
 255         { "ceiling",            CONF_TOS_CEILING },
 256         { "cohort",             CONF_TOS_COHORT },
 257         { "mindist",            CONF_TOS_MINDISP },
 258         { "maxdist",            CONF_TOS_MAXDIST },
 259         { "maxhop",             CONF_TOS_MAXHOP },
 260         { "beacon",             CONF_TOS_BEACON },
 261         { "orphan",             CONF_TOS_ORPHAN },
 262         { "",                   CONFIG_UNKNOWN }
 263 };
 264
 265 #ifdef OPENSSL
 266 /*
 267  * "crypto" modifier keywords
 268  */
 269 static struct keyword crypto_keywords[] = {
 270         { "cert",               CONF_CRYPTO_CERT },
 271         { "gqpar",              CONF_CRYPTO_GQPAR },
 272         { "host",               CONF_CRYPTO_RSA },
 273         { "ident",              CONF_CRYPTO_IDENT },
 274         { "iffpar",             CONF_CRYPTO_IFFPAR },
 275         { "leap",               CONF_CRYPTO_LEAP },
 276         { "mvpar",              CONF_CRYPTO_MVPAR },
 277         { "pw",                 CONF_CRYPTO_PW },
 278         { "randfile",           CONF_CRYPTO_RAND },
 279         { "sign",               CONF_CRYPTO_SIGN },
 280         { "",                   CONFIG_UNKNOWN }
 281 };
 282 #endif /* OPENSSL */
 283
 284 /*
 285  * Address type selection, IPv4 or IPv4.
 286  * Used on various lines.
 287  */
 288 static struct keyword addr_type[] = {
 289         { "-4",                 CONF_ADDR_IPV4 },
 290         { "-6",                 CONF_ADDR_IPV6 },
 291         { "",                   CONFIG_UNKNOWN }
 292 };
 293
 294 /*
 295  * "logconfig" building blocks
 296  */
 297 struct masks {
 298         const char        *name;
 299         unsigned long mask;
 300 };
 301
 302 static struct masks logcfg_class[] = {
 303         { "clock",              NLOG_OCLOCK },
 304         { "peer",               NLOG_OPEER },
 305         { "sync",               NLOG_OSYNC },
 306         { "sys",                NLOG_OSYS },
 307         { (char *)0,    0 }
 308 };
 309
 310 static struct masks logcfg_item[] = {
 311         { "info",               NLOG_INFO },
 312         { "allinfo",            NLOG_SYSINFO|NLOG_PEERINFO|NLOG_CLOCKINFO|NLOG_SYNCINFO },
 313         { "events",             NLOG_EVENT },
 314         { "allevents",          NLOG_SYSEVENT|NLOG_PEEREVENT|NLOG_CLOCKEVENT|NLOG_SYNCEVENT },
 315         { "status",             NLOG_STATUS },
 316         { "allstatus",          NLOG_SYSSTATUS|NLOG_PEERSTATUS|NLOG_CLOCKSTATUS|NLOG_SYNCSTATUS },
 317         { "statistics",         NLOG_STATIST },
 318         { "allstatistics",      NLOG_SYSSTATIST|NLOG_PEERSTATIST|NLOG_CLOCKSTATIST|NLOG_SYNCSTATIST },
 319         { "allclock",           (NLOG_INFO|NLOG_STATIST|NLOG_EVENT|NLOG_STATUS)<<NLOG_OCLOCK },
 320         { "allpeer",            (NLOG_INFO|NLOG_STATIST|NLOG_EVENT|NLOG_STATUS)<<NLOG_OPEER },
 321         { "allsys",             (NLOG_INFO|NLOG_STATIST|NLOG_EVENT|NLOG_STATUS)<<NLOG_OSYS },
 322         { "allsync",            (NLOG_INFO|NLOG_STATIST|NLOG_EVENT|NLOG_STATUS)<<NLOG_OSYNC },
 323         { "all",                NLOG_SYSMASK|NLOG_PEERMASK|NLOG_CLOCKMASK|NLOG_SYNCMASK },
 324         { (char *)0,    0 }
 325 };
 326
 327 /*
 328  * Limits on things
 329  */
 330 #define MAXTOKENS       20      /* 20 tokens on line */
 331 #define MAXLINE         1024    /* maximum length of line */
 332 #define MAXPHONE        10      /* maximum number of phone strings */
 333 #define MAXPPS          20      /* maximum length of PPS device string */
 334 #define MAXINCLUDELEVEL 5       /* maximum include file levels */
 335
 336 /*
 337  * Miscellaneous macros
 338  */
 339 #define STRSAME(s1, s2) (*(s1) == *(s2) && strcmp((s1), (s2)) == 0)
 340 #define ISEOL(c)        ((c) == '#' || (c) == '\n' || (c) == '\0')
 341 #define ISSPACE(c)      ((c) == ' ' || (c) == '\t')
 342 #define STREQ(a, b)     (*(a) == *(b) && strcmp((a), (b)) == 0)
 343
 344 #define KEY_TYPE_MD5    4
 345
 346 /*
 347  * File descriptor used by the resolver save routines, and temporary file
 348  * name.
 349  */
 350 int call_resolver = 1;          /* ntp-genkeys sets this to 0, for example */
 351 static FILE *res_fp;
 352 #ifndef SYS_WINNT
 353 static char res_file[20];       /* enough for /tmp/ntpXXXXXX\0 */
 354 #define RES_TEMPFILE    "/tmp/ntpXXXXXX"
 355 #else
 356 static char res_file[MAX_PATH];
 357 #endif /* SYS_WINNT */
 358
 359 /*
 360  * Definitions of things either imported from or exported to outside
 361  */
 362
 363 short default_ai_family = AF_UNSPEC;    /* Default either IPv4 or IPv6 */
 364 char    *sys_phone[MAXPHONE] = {NULL}; /* ACTS phone numbers */
 365 char    *keysdir = NTP_KEYSDIR; /* crypto keys directory */
 366 #if defined(HAVE_SCHED_SETSCHEDULER)
 367 int     config_priority_override = 0;
 368 int     config_priority;
 369 #endif
 370
 371 const char *config_file;
 372 #ifdef HAVE_NETINFO
 373  struct netinfo_config_state *config_netinfo = NULL;
 374  int check_netinfo = 1;
 375 #endif /* HAVE_NETINFO */
 376 #ifdef SYS_WINNT
 377  char *alt_config_file;
 378  LPTSTR temp;
 379  char config_file_storage[MAX_PATH];
 380  char alt_config_file_storage[MAX_PATH];
 381 #endif /* SYS_WINNT */
 382
 383 #ifdef HAVE_NETINFO
 384 /*
 385  * NetInfo configuration state
 386  */
 387 struct netinfo_config_state {
 388         void *domain;           /* domain with config */
 389         ni_id config_dir;       /* ID config dir      */
 390         int prop_index;         /* current property   */
 391         int val_index;          /* current value      */
 392         char **val_list;        /* value list         */
 393 };
 394 #endif
 395
 396 /*
 397  * Function prototypes
 398  */
 399 static  unsigned long get_pfxmatch P((char **, struct masks *));
 400 static  unsigned long get_match P((char *, struct masks *));
 401 static  unsigned long get_logmask P((char *));
 402 #ifdef HAVE_NETINFO
 403 static  struct netinfo_config_state *get_netinfo_config P((void));
 404 static  void free_netinfo_config P((struct netinfo_config_state *));
 405 static  int gettokens_netinfo P((struct netinfo_config_state *, char **, int *));
 406 #endif
 407 static  int gettokens P((FILE *, char *, char **, int *));
 408 static  int matchkey P((char *, struct keyword *, int));
 409 enum gnn_type {
 410         t_UNK,          /* Unknown */
 411         t_REF,          /* Refclock */
 412         t_MSK           /* Network Mask */
 413         };
 414 static  int getnetnum P((const char *, struct sockaddr_storage *, int,
 415                          enum gnn_type));
 416 static  void save_resolve P((char *, int, int, int, int, u_int, int,
 417     keyid_t, u_char *, u_char));
 418 static  void do_resolve_internal P((void));
 419 static  void abort_resolve P((void));
 420 #if !defined(VMS) && !defined(SYS_WINNT)
 421 static  RETSIGTYPE catchchild P((int));
 422 #endif /* VMS */
 423
 424 /*
 425  * get_pfxmatch - find value for prefixmatch
 426  * and update char * accordingly
 427  */
 428 static unsigned long
 429 get_pfxmatch(
 430         char ** s,
 431         struct masks *m
 432         )
 433 {
 434         while (m->name) {
 435                 if (strncmp(*s, m->name, strlen(m->name)) == 0) {
 436                         *s += strlen(m->name);
 437                         return m->mask;
 438                 } else {
 439                         m++;
 440                 }
 441         }
 442         return 0;
 443 }
 444
 445 /*
 446  * get_match - find logmask value
 447  */
 448 static unsigned long
 449 get_match(
 450         char *s,
 451         struct masks *m
 452         )
 453 {
 454         while (m->name) {
 455                 if (strcmp(s, m->name) == 0) {
 456                         return m->mask;
 457                 } else {
 458                         m++;
 459                 }
 460         }
 461         return 0;
 462 }
 463
 464 /*
 465  * get_logmask - build bitmask for ntp_syslogmask
 466  */
 467 static unsigned long
 468 get_logmask(
 469         char *s
 470         )
 471 {
 472         char *t;
 473         unsigned long offset;
 474         unsigned long mask;
 475
 476         t = s;
 477         offset = get_pfxmatch(&t, logcfg_class);
 478         mask   = get_match(t, logcfg_item);
 479
 480         if (mask)
 481                 return mask << offset;
 482         else
 483                 msyslog(LOG_ERR, "logconfig: illegal argument %s - ignored", s);
 484
 485         return 0;
 486 }
 487
 488
 489 /*
 490  * getconfig - get command line options and read the configuration file
 491  */
 492 void
 493 getconfig(
 494         int argc,
 495         char *argv[]
 496         )
 497 {
 498         register int i;
 499         int c;
 500         int errflg;
 501         int status;
 502         int istart;
 503         int peerversion;
 504         int minpoll;
 505         int maxpoll;
 506         int ttl;
 507         long stratum;
 508         unsigned long ul;
 509         keyid_t peerkey;
 510         u_char *peerkeystr;
 511         u_long fudgeflag;
 512         u_int peerflags;
 513         int hmode;
 514         struct sockaddr_storage peeraddr;
 515         struct sockaddr_storage maskaddr;
 516         FILE *fp[MAXINCLUDELEVEL+1];
 517         FILE *includefile;
 518         int includelevel = 0;
 519         char line[MAXLINE];
 520         char *(tokens[MAXTOKENS]);
 521         int ntokens = 0;
 522         int tok = CONFIG_UNKNOWN;
 523         struct interface *localaddr;
 524         struct refclockstat clock_stat;
 525         FILEGEN *filegen;
 526
 527         /*
 528          * Initialize, initialize
 529          */
 530         errflg = 0;
 531
 532 #ifndef SYS_WINNT
 533         config_file = CONFIG_FILE;
 534 #else
 535         temp = CONFIG_FILE;
 536         if (!ExpandEnvironmentStrings((LPCTSTR)temp, (LPTSTR)config_file_storage, (DWORD)sizeof(config_file_storage))) {
 537                 msyslog(LOG_ERR, "ExpandEnvironmentStrings CONFIG_FILE failed: %m\n");
 538                 exit(1);
 539         }
 540         config_file = config_file_storage;
 541
 542         temp = ALT_CONFIG_FILE;
 543         if (!ExpandEnvironmentStrings((LPCTSTR)temp, (LPTSTR)alt_config_file_storage, (DWORD)sizeof(alt_config_file_storage))) {
 544                 msyslog(LOG_ERR, "ExpandEnvironmentStrings ALT_CONFIG_FILE failed: %m\n");
 545                 exit(1);
 546         }
 547         alt_config_file = alt_config_file_storage;
 548
 549 #endif /* SYS_WINNT */
 550         res_fp = NULL;
 551         ntp_syslogmask = NLOG_SYNCMASK; /* set more via logconfig */
 552
 553         /*
 554          * install a non default variable with this daemon version
 555          */
 556         (void) sprintf(line, "daemon_version=\"%s\"", Version);
 557         set_sys_var(line, strlen(line)+1, RO);
 558
 559         /*
 560          * Say how we're setting the time of day
 561          */
 562         (void) sprintf(line, "settimeofday=\"%s\"", set_tod_using);
 563         set_sys_var(line, strlen(line)+1, RO);
 564
 565         /*
 566          * Initialize the loop.
 567          */
 568         loop_config(LOOP_DRIFTINIT, 0.);
 569
 570         getCmdOpts(argc, argv);
 571
 572         if (
 573             (fp[0] = fopen(FindConfig(config_file), "r")) == NULL
 574 #ifdef HAVE_NETINFO
 575             /* If there is no config_file, try NetInfo. */
 576             && check_netinfo && !(config_netinfo = get_netinfo_config())
 577 #endif /* HAVE_NETINFO */
 578             ) {
 579                 fprintf(stderr, "getconfig: Couldn't open <%s>\n", FindConfig(config_file));
 580                 msyslog(LOG_INFO, "getconfig: Couldn't open <%s>", FindConfig(config_file));
 581 #ifdef SYS_WINNT
 582                 /* Under WinNT try alternate_config_file name, first NTP.CONF, then NTP.INI */
 583
 584                 if ((fp[0] = fopen(FindConfig(alt_config_file), "r")) == NULL) {
 585
 586                         /*
 587                          * Broadcast clients can sometimes run without
 588                          * a configuration file.
 589                          */
 590
 591                         fprintf(stderr, "getconfig: Couldn't open <%s>\n", FindConfig(alt_config_file));
 592                         msyslog(LOG_INFO, "getconfig: Couldn't open <%s>", FindConfig(alt_config_file));
 593                         return;
 594                 }
 595 #else  /* not SYS_WINNT */
 596                 return;
 597 #endif /* not SYS_WINNT */
 598         }
 599
 600         for (;;) {
 601                 if (tok == CONFIG_END)
 602                         break;
 603                 if (fp[includelevel])
 604                         tok = gettokens(fp[includelevel], line, tokens, &ntokens);
 605 #ifdef HAVE_NETINFO
 606                 else
 607                         tok = gettokens_netinfo(config_netinfo, tokens, &ntokens);
 608 #endif /* HAVE_NETINFO */
 609
 610                 if (tok == CONFIG_UNKNOWN) {
 611                     if (includelevel > 0) {
 612                         fclose(fp[includelevel--]);
 613                         continue;
 614                     } else {
 615                         break;
 616                     }
 617                 }
 618
 619                 switch(tok) {
 620                     case CONFIG_PEER:
 621                     case CONFIG_SERVER:
 622                     case CONFIG_MANYCASTCLIENT:
 623                     case CONFIG_BROADCAST:
 624                         if (tok == CONFIG_PEER)
 625                             hmode = MODE_ACTIVE;
 626                         else if (tok == CONFIG_SERVER)
 627                             hmode = MODE_CLIENT;
 628                         else if (tok == CONFIG_MANYCASTCLIENT)
 629                             hmode = MODE_CLIENT;
 630                         else
 631                             hmode = MODE_BROADCAST;
 632
 633                         if (ntokens < 2) {
 634                                 msyslog(LOG_ERR,
 635                                         "No address for %s, line ignored",
 636                                         tokens[0]);
 637                                 break;
 638                         }
 639
 640                         istart = 1;
 641                         memset((char *)&peeraddr, 0, sizeof(peeraddr));
 642                         peeraddr.ss_family = default_ai_family;
 643                         switch (matchkey(tokens[istart], addr_type, 0)) {
 644                         case CONF_ADDR_IPV4:
 645                                 peeraddr.ss_family = AF_INET;
 646                                 istart++;
 647                                 break;
 648                         case CONF_ADDR_IPV6:
 649                                 peeraddr.ss_family = AF_INET6;
 650                                 istart++;
 651                                 break;
 652                         }
 653
 654                         status = getnetnum(tokens[istart], &peeraddr, 0, t_UNK);
 655                         if (status == -1)
 656                                 break;          /* Found IPv6 address */
 657                         if(status != 1) {
 658                                 errflg = -1;
 659                         } else {
 660                                 errflg = 0;
 661
 662                                 if (
 663 #ifdef REFCLOCK
 664                                         !ISREFCLOCKADR(&peeraddr) &&
 665 #endif
 666                                         ISBADADR(&peeraddr)) {
 667                                         msyslog(LOG_ERR,
 668                                                 "attempt to configure invalid address %s",
 669                                                 stoa(&peeraddr));
 670                                         break;
 671                                 }
 672                                 /*
 673                                  * Shouldn't be able to specify multicast
 674                                  * address for server/peer!
 675                                  * and unicast address for manycastclient!
 676                                  */
 677                                 if (peeraddr.ss_family == AF_INET) {
 678                                         if (((tok == CONFIG_SERVER) ||
 679                                         (tok == CONFIG_PEER)) &&
 680 #ifdef REFCLOCK
 681                                         !ISREFCLOCKADR(&peeraddr) &&
 682 #endif
 683                                         IN_CLASSD(ntohl(((struct sockaddr_in*)&peeraddr)->sin_addr.s_addr))) {
 684                                                 msyslog(LOG_ERR,
 685                                                         "attempt to configure invalid address %s",
 686                                                         stoa(&peeraddr));
 687                                                 break;
 688                                         }
 689                                         if ((tok == CONFIG_MANYCASTCLIENT) &&
 690                                         !IN_CLASSD(ntohl(((struct sockaddr_in*)&peeraddr)->sin_addr.s_addr))) {
 691                                                 msyslog(LOG_ERR,
 692                                                         "attempt to configure invalid address %s",
 693                                                         stoa(&peeraddr));
 694                                                 break;
 695                                         }
 696                                 }
 697                                 else if(peeraddr.ss_family == AF_INET6) {
 698                                 if (((tok == CONFIG_SERVER) ||
 699                                      (tok == CONFIG_PEER)) &&
 700 #ifdef REFCLOCK
 701                                     !ISREFCLOCKADR(&peeraddr) &&
 702 #endif
 703                                         IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)&peeraddr)->sin6_addr)) {
 704                                                 msyslog(LOG_ERR,
 705                                                         "attempt to configure in valid address %s",
 706                                                         stoa(&peeraddr));
 707                                                 break;
 708                                         }
 709                                         if ((tok == CONFIG_MANYCASTCLIENT) &&
 710                                             !IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)&peeraddr)->sin6_addr)) {
 711                                                         msyslog(LOG_ERR,
 712                                                         "attempt to configure in valid address %s",
 713                                                         stoa(&peeraddr));
 714                                                 break;
 715                                         }
 716                                 }
 717                         }
 718                         if (peeraddr.ss_family == AF_INET6 &&
 719                             isc_net_probeipv6() != ISC_R_SUCCESS)
 720                                 break;
 721
 722                         peerversion = NTP_VERSION;
 723                         minpoll = NTP_MINDPOLL;
 724                         maxpoll = NTP_MAXDPOLL;
 725                         peerkey = 0;
 726                         peerkeystr = (u_char *)"*";
 727                         peerflags = 0;
 728                         ttl = 0;
 729                         istart++;
 730                         for (i = istart; i < ntokens; i++)
 731                             switch (matchkey(tokens[i], mod_keywords, 1)) {
 732                                 case CONF_MOD_VERSION:
 733                                     if (i >= ntokens-1) {
 734                                             msyslog(LOG_ERR,
 735                                                     "peer/server version requires an argument");
 736                                             errflg = 1;
 737                                             break;
 738                                     }
 739                                     peerversion = atoi(tokens[++i]);
 740                                     if ((u_char)peerversion > NTP_VERSION
 741                                         || (u_char)peerversion < NTP_OLDVERSION) {
 742                                             msyslog(LOG_ERR,
 743                                                     "inappropriate version number %s, line ignored",
 744                                                     tokens[i]);
 745                                             errflg = 1;
 746                                     }
 747                                     break;
 748
 749                                 case CONF_MOD_KEY:
 750                                     if (i >= ntokens-1) {
 751                                             msyslog(LOG_ERR,
 752                                                     "key: argument required");
 753                                             errflg = 1;
 754                                             break;
 755                                     }
 756                                     peerkey = (int)atol(tokens[++i]);
 757                                     peerflags |= FLAG_AUTHENABLE;
 758                                     break;
 759
 760                                 case CONF_MOD_MINPOLL:
 761                                     if (i >= ntokens-1) {
 762                                             msyslog(LOG_ERR,
 763                                                     "minpoll: argument required");
 764                                             errflg = 1;
 765                                             break;
 766                                     }
 767                                     minpoll = atoi(tokens[++i]);
 768                                     if (minpoll < NTP_MINPOLL) {
 769                                             msyslog(LOG_INFO,
 770                                                     "minpoll: provided value (%d) is below minimum (%d)",
 771                                                     minpoll, NTP_MINPOLL);
 772                                         minpoll = NTP_MINPOLL;
 773                                     }
 774                                     break;
 775
 776                                 case CONF_MOD_MAXPOLL:
 777                                     if (i >= ntokens-1) {
 778                                             msyslog(LOG_ERR,
 779                                                     "maxpoll: argument required"
 780                                                     );
 781                                             errflg = 1;
 782                                             break;
 783                                     }
 784                                     maxpoll = atoi(tokens[++i]);
 785                                     if (maxpoll > NTP_MAXPOLL) {
 786                                             msyslog(LOG_INFO,
 787                                                     "maxpoll: provided value (%d) is above maximum (%d)",
 788                                                     maxpoll, NTP_MAXPOLL);
 789                                         maxpoll = NTP_MAXPOLL;
 790                                     }
 791                                     break;
 792
 793                                 case CONF_MOD_PREFER:
 794                                     peerflags |= FLAG_PREFER;
 795                                     break;
 796
 797                                 case CONF_MOD_PREEMPT:
 798                                     peerflags |= FLAG_PREEMPT;
 799                                     break;
 800
 801                                 case CONF_MOD_NOSELECT:
 802                                     peerflags |= FLAG_NOSELECT;
 803                                     break;
 804
 805                                 case CONF_MOD_TRUE:
 806                                     peerflags |= FLAG_TRUE;
 807
 808                                 case CONF_MOD_BURST:
 809                                     peerflags |= FLAG_BURST;
 810                                     break;
 811
 812                                 case CONF_MOD_IBURST:
 813                                     peerflags |= FLAG_IBURST;
 814                                     break;
 815
 816                                 case CONF_MOD_DYNAMIC:
 817                                     msyslog(LOG_WARNING,
 818                                         "Warning: the \"dynamic\" keyword has been obsoleted"
 819                                         " and will be removed in the next release\n");
 820                                     break;
 821
 822 #ifdef OPENSSL
 823                                 case CONF_MOD_SKEY:
 824                                     peerflags |= FLAG_SKEY |
 825                                         FLAG_AUTHENABLE;
 826                                     break;
 827 #endif /* OPENSSL */
 828
 829                                 case CONF_MOD_TTL:
 830                                     if (i >= ntokens-1) {
 831                                         msyslog(LOG_ERR,
 832                                             "ttl: argument required");
 833                                         errflg = 1;
 834                                         break;
 835                                     }
 836                                     ttl = atoi(tokens[++i]);
 837                                     if (ttl >= MAX_TTL) {
 838                                         msyslog(LOG_ERR,
 839                                             "ttl: invalid argument");
 840                                         errflg = 1;
 841                                     }
 842                                     break;
 843
 844                                 case CONF_MOD_MODE:
 845                                     if (i >= ntokens-1) {
 846                                         msyslog(LOG_ERR,
 847                                             "mode: argument required");
 848                                         errflg = 1;
 849                                         break;
 850                                     }
 851                                     ttl = atoi(tokens[++i]);
 852                                     break;
 853
 854                                 case CONFIG_UNKNOWN:
 855                                     errflg = 1;
 856                                     break;
 857                             }
 858                         if (minpoll > maxpoll) {
 859                                 msyslog(LOG_ERR,
 860                                     "config error: minpoll > maxpoll");
 861                                 errflg = 1;
 862                         }
 863                         if (errflg == 0) {
 864                             if (peer_config(&peeraddr,
 865                                 ANY_INTERFACE_CHOOSE(&peeraddr), hmode,
 866                                 peerversion, minpoll, maxpoll, peerflags,
 867                                 ttl, peerkey, peerkeystr) == 0) {
 868                                         msyslog(LOG_ERR,
 869                                                 "configuration of %s failed",
 870                                                 stoa(&peeraddr));
 871                             }
 872                         } else if (errflg == -1) {
 873                                 save_resolve(tokens[istart - 1], hmode, peerversion,
 874                                     minpoll, maxpoll, peerflags, ttl,
 875                                     peerkey, peerkeystr, peeraddr.ss_family);
 876                         }
 877                         break;
 878
 879                     case CONFIG_DRIFTFILE:
 880                         if (ntokens >= 2)
 881                             stats_config(STATS_FREQ_FILE, tokens[1]);
 882                         else
 883                             stats_config(STATS_FREQ_FILE, (char *)0);
 884                         stats_write_period = stats_write_tolerance = 0;
 885                         if (ntokens >= 3)
 886                              stats_write_period = 60 * atol(tokens[2]);
 887                         if (stats_write_period <= 0)
 888                              stats_write_period = 3600;
 889                         if (ntokens >= 4) {
 890                              double ftemp;
 891                              sscanf(tokens[3], "%lf", &ftemp);
 892                              stats_write_tolerance = ftemp / 100;
 893                         }
 894                         break;
 895
 896                     case CONFIG_PIDFILE:
 897                         if (ntokens >= 2)
 898                             stats_config(STATS_PID_FILE, tokens[1]);
 899                         else
 900                             stats_config(STATS_PID_FILE, (char *)0);
 901                         break;
 902
 903                     case CONFIG_END:
 904                         for ( i = 0; i <= includelevel; i++ ) {
 905                                 fclose(fp[i]);
 906                         }
 907                         break;
 908
 909                     case CONFIG_INCLUDEFILE:
 910                         if (ntokens < 2) {
 911                             msyslog(LOG_ERR, "includefile needs one argument");
 912                             break;
 913                         }
 914                         if (includelevel >= MAXINCLUDELEVEL) {
 915                             fprintf(stderr, "getconfig: Maximum include file level exceeded.\n");
 916                             msyslog(LOG_INFO, "getconfig: Maximum include file level exceeded.");
 917                             break;
 918                         }
 919                         includefile = fopen(FindConfig(tokens[1]), "r");
 920                         if (includefile == NULL) {
 921                             fprintf(stderr, "getconfig: Couldn't open <%s>\n", FindConfig(tokens[1]));
 922                             msyslog(LOG_INFO, "getconfig: Couldn't open <%s>", FindConfig(tokens[1]));
 923                             break;
 924                         }
 925                         fp[++includelevel] = includefile;
 926                         break;
 927
 928                     case CONFIG_LOGFILE:
 929                         if (ntokens >= 2) {
 930                                 FILE *new_file;
 931
 932                                 new_file = fopen(tokens[1], "a");
 933                                 if (new_file != NULL) {
 934                                         NLOG(NLOG_SYSINFO) /* conditional if clause for conditional syslog */
 935                                             msyslog(LOG_NOTICE, "logging to file %s", tokens[1]);
 936                                         if (syslog_file != NULL &&
 937                                             fileno(syslog_file) != fileno(new_file))
 938                                             (void)fclose(syslog_file);
 939
 940                                         syslog_file = new_file;
 941                                         syslogit = 0;
 942                                 }
 943                                 else
 944                                     msyslog(LOG_ERR,
 945                                             "Cannot open log file %s",
 946                                             tokens[1]);
 947                         }
 948                         else
 949                             msyslog(LOG_ERR, "logfile needs one argument");
 950                         break;
 951
 952                     case CONFIG_LOGCONFIG:
 953                         for (i = 1; i < ntokens; i++)
 954                         {
 955                                 int add = 1;
 956                                 int equals = 0;
 957                                 char * s = &tokens[i][0];
 958
 959                                 switch (*s) {
 960                                     case '+':
 961                                     case '-':
 962                                     case '=':
 963                                         add = *s == '+';
 964                                         equals = *s == '=';
 965                                         s++;
 966                                         break;
 967
 968                                     default:
 969                                         break;
 970                                 }
 971                                 if (equals) {
 972                                         ntp_syslogmask = get_logmask(s);
 973                                 } else {
 974                                         if (add) {
 975                                                 ntp_syslogmask |= get_logmask(s);
 976                                         } else {
 977                                                 ntp_syslogmask &= ~get_logmask(s);
 978                                         }
 979                                 }
 980 #ifdef DEBUG
 981                                 if (debug)
 982                                     printf("ntp_syslogmask = 0x%08lx (%s)\n", ntp_syslogmask, tokens[i]);
 983 #endif
 984                         }
 985                         break;
 986
 987                     case CONFIG_BROADCASTCLIENT:
 988                         if (ntokens == 1) {
 989                                 proto_config(PROTO_BROADCLIENT, 1, 0., NULL);
 990                         } else {
 991                                 proto_config(PROTO_BROADCLIENT, 2, 0., NULL);
 992                         }
 993                         break;
 994
 995                     case CONFIG_MULTICASTCLIENT:
 996                     case CONFIG_MANYCASTSERVER:
 997                         if (ntokens > 1) {
 998                                 istart = 1;
 999                                 memset((char *)&peeraddr, 0, sizeof(peeraddr));
1000                                 peeraddr.ss_family = default_ai_family;
1001                                 switch (matchkey(tokens[istart],
1002                                     addr_type, 0)) {
1003                                 case CONF_ADDR_IPV4:
1004                                         peeraddr.ss_family = AF_INET;
1005                                         istart++;
1006                                         break;
1007                                 case CONF_ADDR_IPV6:
1008                                         peeraddr.ss_family = AF_INET6;
1009                                         istart++;
1010                                         break;
1011                                 }
1012                                 /*
1013                                  * Abuse maskaddr to store the prefered ip
1014                                  * version.
1015                                  */
1016                                 memset((char *)&maskaddr, 0, sizeof(maskaddr));
1017                                 maskaddr.ss_family = peeraddr.ss_family;
1018
1019                                 for (i = istart; i < ntokens; i++) {
1020                                         memset((char *)&peeraddr, 0,
1021                                             sizeof(peeraddr));
1022                                         peeraddr.ss_family = maskaddr.ss_family;
1023                                         if (getnetnum(tokens[i], &peeraddr, 1,
1024                                                       t_UNK)  == 1)
1025                                             proto_config(PROTO_MULTICAST_ADD,
1026                                                          0, 0., &peeraddr);
1027                                 }
1028                         } else
1029                             proto_config(PROTO_MULTICAST_ADD,
1030                                          0, 0., NULL);
1031                         if (tok == CONFIG_MULTICASTCLIENT)
1032                                 proto_config(PROTO_MULTICAST_ADD, 1, 0., NULL);
1033                         else if (tok == CONFIG_MANYCASTSERVER)
1034                                 sys_manycastserver = 1;
1035                         break;
1036
1037                     case CONFIG_KEYS:
1038                         if (ntokens >= 2) {
1039                                 getauthkeys(tokens[1]);
1040                         }
1041                         break;
1042
1043                     case CONFIG_KEYSDIR:
1044                         if (ntokens < 2) {
1045                             msyslog(LOG_ERR,
1046                                 "Keys directory name required");
1047                             break;
1048                         }
1049                         keysdir = (char *)emalloc(strlen(tokens[1]) + 1);
1050                         strcpy(keysdir, tokens[1]);
1051                         break;
1052
1053                     case CONFIG_TINKER:
1054                         for (i = 1; i < ntokens; i++) {
1055                             int temp;
1056                             double ftemp;
1057
1058                             temp = matchkey(tokens[i++], tinker_keywords, 1);
1059                             if (i > ntokens - 1) {
1060                                 msyslog(LOG_ERR,
1061                                     "tinker: missing argument");
1062                                 errflg++;
1063                                 break;
1064                             }
1065                             sscanf(tokens[i], "%lf", &ftemp);
1066                             switch(temp) {
1067
1068                             case CONF_CLOCK_MAX:
1069                                 loop_config(LOOP_MAX, ftemp);
1070                                 break;
1071
1072                             case CONF_CLOCK_PANIC:
1073                                 loop_config(LOOP_PANIC, ftemp);
1074                                 break;
1075
1076                             case CONF_CLOCK_PHI:
1077                                 loop_config(LOOP_PHI, ftemp);
1078                                 break;
1079
1080                             case CONF_CLOCK_MINSTEP:
1081                                 loop_config(LOOP_MINSTEP, ftemp);
1082                                 break;
1083
1084                             case CONF_CLOCK_ALLAN:
1085                                 loop_config(LOOP_ALLAN, ftemp);
1086                                 break;
1087
1088                             case CONF_CLOCK_HUFFPUFF:
1089                                 loop_config(LOOP_HUFFPUFF, ftemp);
1090                                 break;
1091
1092                             case CONF_CLOCK_FREQ:
1093                                 loop_config(LOOP_FREQ, ftemp);
1094                                 break;
1095                             }
1096                         }
1097                         break;
1098
1099                     case CONFIG_TOS:
1100                         for (i = 1; i < ntokens; i++) {
1101                             int temp;
1102                             double ftemp;
1103
1104                             temp = matchkey(tokens[i++], tos_keywords, 1);
1105                             if (i > ntokens - 1) {
1106                                 msyslog(LOG_ERR,
1107                                     "tos: missing argument");
1108                                 errflg++;
1109                                 break;
1110                             }
1111                             sscanf(tokens[i], "%lf", &ftemp);
1112                             switch(temp) {
1113
1114                             case CONF_TOS_MINCLOCK:
1115                                 proto_config(PROTO_MINCLOCK, 0, ftemp, NULL);
1116                                 break;
1117
1118                             case CONF_TOS_MAXCLOCK:
1119                                 proto_config(PROTO_MAXCLOCK, 0, ftemp, NULL);
1120                                 break;
1121
1122                             case CONF_TOS_MINSANE:
1123                                 proto_config(PROTO_MINSANE, 0, ftemp, NULL);
1124                                 break;
1125
1126                             case CONF_TOS_FLOOR:
1127                                 proto_config(PROTO_FLOOR, 0, ftemp, NULL);
1128                                 break;
1129
1130                             case CONF_TOS_CEILING:
1131                                 proto_config(PROTO_CEILING, 0, ftemp, NULL);
1132                                 break;
1133
1134                             case CONF_TOS_COHORT:
1135                                 proto_config(PROTO_COHORT, 0, ftemp, NULL);
1136                                 break;
1137
1138                             case CONF_TOS_MINDISP:
1139                                 proto_config(PROTO_MINDISP, 0, ftemp, NULL);
1140                                 break;
1141
1142                             case CONF_TOS_MAXDIST:
1143                                 proto_config(PROTO_MAXDIST, 0, ftemp, NULL);
1144                                 break;
1145
1146                             case CONF_TOS_MAXHOP:
1147                                 proto_config(PROTO_MAXHOP, 0, ftemp, NULL);
1148                                 break;
1149
1150                             case CONF_TOS_ORPHAN:
1151                                 proto_config(PROTO_ORPHAN, 0, ftemp, NULL);
1152                                 break;
1153
1154                             case CONF_TOS_BEACON:
1155                                 proto_config(PROTO_BEACON, 0, ftemp, NULL);
1156                                 break;
1157                             }
1158                         }
1159                         break;
1160
1161                     case CONFIG_TTL:
1162                         for (i = 1; i < ntokens && i < MAX_TTL; i++) {
1163                             sys_ttl[i - 1] = (u_char) atoi(tokens[i]);
1164                             sys_ttlmax = i - 1;
1165                         }
1166                         break;
1167
1168                     case CONFIG_DISCARD:
1169                         for (i = 1; i < ntokens; i++) {
1170                             int temp;
1171
1172                             temp = matchkey(tokens[i++],
1173                                 discard_keywords, 1);
1174                             if (i > ntokens - 1) {
1175                                 msyslog(LOG_ERR,
1176                                     "discard: missing argument");
1177                                 errflg++;
1178                                 break;
1179                             }
1180                             switch(temp) {
1181                             case CONF_DISCARD_AVERAGE:
1182                                 res_avg_interval = atoi(tokens[i]);
1183                                 break;
1184
1185                             case CONF_DISCARD_MINIMUM:
1186                                 res_min_interval = atoi(tokens[i]);
1187                                 break;
1188
1189                             case CONF_DISCARD_MONITOR:
1190                                 mon_age = atoi(tokens[i]);
1191                                 break;
1192
1193                             default:
1194                                 msyslog(LOG_ERR,
1195                                     "discard: unknown keyword");
1196                                 break;
1197                             }
1198                         }
1199                         break;
1200
1201 #ifdef OPENSSL
1202                     case CONFIG_REVOKE:
1203                         if (ntokens >= 2)
1204                             sys_revoke = (u_char) max(atoi(tokens[1]), KEY_REVOKE);
1205                         break;
1206
1207                     case CONFIG_AUTOMAX:
1208                         if (ntokens >= 2)
1209                             sys_automax = 1 << max(atoi(tokens[1]), 10);
1210                         break;
1211
1212                     case CONFIG_CRYPTO:
1213                         if (ntokens == 1) {
1214                                 crypto_config(CRYPTO_CONF_NONE, NULL);
1215                                 break;
1216                         }
1217                         for (i = 1; i < ntokens; i++) {
1218                             int temp;
1219
1220                             temp = matchkey(tokens[i++],
1221                                  crypto_keywords, 1);
1222                             if (i > ntokens - 1) {
1223                                 msyslog(LOG_ERR,
1224                                     "crypto: missing argument");
1225                                 errflg++;
1226                                 break;
1227                             }
1228                             switch(temp) {
1229
1230                             case CONF_CRYPTO_CERT:
1231                                 crypto_config(CRYPTO_CONF_CERT,
1232                                     tokens[i]);
1233                                 break;
1234
1235                             case CONF_CRYPTO_RSA:
1236                                 crypto_config(CRYPTO_CONF_PRIV,
1237                                     tokens[i]);
1238                                 break;
1239
1240                             case CONF_CRYPTO_IDENT:
1241                                 crypto_config(CRYPTO_CONF_IDENT,
1242                                     tokens[i]);
1243                                 break;
1244
1245                             case CONF_CRYPTO_IFFPAR:
1246                                 crypto_config(CRYPTO_CONF_IFFPAR,
1247                                     tokens[i]);
1248                                 break;
1249
1250                             case CONF_CRYPTO_GQPAR:
1251                                 crypto_config(CRYPTO_CONF_GQPAR,
1252                                     tokens[i]);
1253                                 break;
1254
1255                             case CONF_CRYPTO_MVPAR:
1256                                 crypto_config(CRYPTO_CONF_MVPAR,
1257                                     tokens[i]);
1258                                 break;
1259
1260                             case CONF_CRYPTO_LEAP:
1261                                 crypto_config(CRYPTO_CONF_LEAP,
1262                                     tokens[i]);
1263                                 break;
1264
1265                             case CONF_CRYPTO_PW:
1266                                 crypto_config(CRYPTO_CONF_PW,
1267                                     tokens[i]);
1268                                 break;
1269
1270                             case CONF_CRYPTO_RAND:
1271                                 crypto_config(CRYPTO_CONF_RAND,
1272                                     tokens[i]);
1273                                 break;
1274
1275                             case CONF_CRYPTO_SIGN:
1276                                 crypto_config(CRYPTO_CONF_SIGN,
1277                                     tokens[i]);
1278                                 break;
1279
1280                             default:
1281                                 msyslog(LOG_ERR,
1282                                     "crypto: unknown keyword");
1283                                 break;
1284                             }
1285                         }
1286                         break;
1287 #endif /* OPENSSL */
1288
1289                     case CONFIG_RESTRICT:
1290                         if (ntokens < 2) {
1291                                 msyslog(LOG_ERR, "restrict requires an address");
1292                                 break;
1293                         }
1294                         istart = 1;
1295                         memset((char *)&peeraddr, 0, sizeof(peeraddr));
1296                         peeraddr.ss_family = default_ai_family;
1297                         switch (matchkey(tokens[istart], addr_type, 0)) {
1298                         case CONF_ADDR_IPV4:
1299                                 peeraddr.ss_family = AF_INET;
1300                                 istart++;
1301                                 break;
1302                         case CONF_ADDR_IPV6:
1303                                 peeraddr.ss_family = AF_INET6;
1304                                 istart++;
1305                                 break;
1306                         }
1307
1308                         /*
1309                          * Assume default means an IPv4 address, except
1310                          * if forced by a -4 or -6.
1311                          */
1312                         if (STREQ(tokens[istart], "default")) {
1313                                 if (peeraddr.ss_family == 0)
1314                                         peeraddr.ss_family = AF_INET;
1315                         } else if (getnetnum(tokens[istart], &peeraddr, 1,
1316                                               t_UNK) != 1)
1317                                 break;
1318
1319                         /*
1320                          * Use peerversion as flags, peerkey as mflags.  Ick.
1321                          */
1322                         peerversion = 0;
1323                         peerkey = 0;
1324                         errflg = 0;
1325                         SET_HOSTMASK(&maskaddr, peeraddr.ss_family);
1326                         istart++;
1327                         for (i = istart; i < ntokens; i++) {
1328                                 switch (matchkey(tokens[i], res_keywords, 1)) {
1329                                     case CONF_RES_MASK:
1330                                         if (i >= ntokens-1) {
1331                                                 msyslog(LOG_ERR,
1332                                                         "mask keyword needs argument");
1333                                                 errflg++;
1334                                                 break;
1335                                         }
1336                                         i++;
1337                                         if (getnetnum(tokens[i], &maskaddr, 1,
1338                                                        t_MSK) != 1)
1339                                             errflg++;
1340                                         break;
1341
1342                                     case CONF_RES_IGNORE:
1343                                         peerversion |= RES_IGNORE;
1344                                         break;
1345
1346                                     case CONF_RES_NOSERVE:
1347                                         peerversion |= RES_DONTSERVE;
1348                                         break;
1349
1350                                     case CONF_RES_NOTRUST:
1351                                         peerversion |= RES_DONTTRUST;
1352                                         break;
1353
1354                                     case CONF_RES_NOQUERY:
1355                                         peerversion |= RES_NOQUERY;
1356                                         break;
1357
1358                                     case CONF_RES_NOMODIFY:
1359                                         peerversion |= RES_NOMODIFY;
1360                                         break;
1361
1362                                     case CONF_RES_NOPEER:
1363                                         peerversion |= RES_NOPEER;
1364                                         break;
1365
1366                                     case CONF_RES_NOTRAP:
1367                                         peerversion |= RES_NOTRAP;
1368                                         break;
1369
1370                                     case CONF_RES_LPTRAP:
1371                                         peerversion |= RES_LPTRAP;
1372                                         break;
1373
1374                                     case CONF_RES_NTPPORT:
1375                                         peerkey |= RESM_NTPONLY;
1376                                         break;
1377
1378                                     case CONF_RES_VERSION:
1379                                         peerversion |= RES_VERSION;
1380                                         break;
1381
1382                                     case CONF_RES_DEMOBILIZE:
1383                                         peerversion |= RES_DEMOBILIZE;
1384                                         break;
1385
1386                                     case CONF_RES_LIMITED:
1387                                         peerversion |= RES_LIMITED;
1388                                         break;
1389
1390                                     case CONFIG_UNKNOWN:
1391                                         errflg++;
1392                                         break;
1393                                 }
1394                         }
1395                         if (SOCKNUL(&peeraddr))
1396                             ANYSOCK(&maskaddr);
1397                         if (!errflg)
1398                             hack_restrict(RESTRICT_FLAGS, &peeraddr, &maskaddr,
1399                                           (int)peerkey, peerversion);
1400                         break;
1401
1402                     case CONFIG_BDELAY:
1403                         if (ntokens >= 2) {
1404                                 double tmp;
1405
1406                                 if (sscanf(tokens[1], "%lf", &tmp) != 1) {
1407                                         msyslog(LOG_ERR,
1408                                                 "broadcastdelay value %s undecodable",
1409                                                 tokens[1]);
1410                                 } else {
1411                                         proto_config(PROTO_BROADDELAY, 0, tmp, NULL);
1412                                 }
1413                         }
1414                         break;
1415
1416                     case CONFIG_CDELAY:
1417                         if (ntokens >= 2) {
1418                                 u_long ui;
1419
1420                                 if (sscanf(tokens[1], "%ld", &ui) != 1)
1421                                         msyslog(LOG_ERR,
1422                                             "illegal value - line ignored");
1423                                 else
1424                                         proto_config(PROTO_CALLDELAY, ui, 0, NULL);
1425                         }
1426                         break;
1427
1428                     case CONFIG_TRUSTEDKEY:
1429                         for (i = 1; i < ntokens; i++) {
1430                                 keyid_t tkey;
1431
1432                                 tkey = atol(tokens[i]);
1433                                 if (tkey == 0) {
1434                                         msyslog(LOG_ERR,
1435                                                 "trusted key %s unlikely",
1436                                                 tokens[i]);
1437                                 } else {
1438                                         authtrust(tkey, 1);
1439                                 }
1440                         }
1441                         break;
1442
1443                     case CONFIG_REQUESTKEY:
1444                         if (ntokens >= 2) {
1445                                 if (!atouint(tokens[1], &ul)) {
1446                                         msyslog(LOG_ERR,
1447                                                 "%s is undecodable as request key",
1448                                                 tokens[1]);
1449                                 } else if (ul == 0) {
1450                                         msyslog(LOG_ERR,
1451                                                 "%s makes a poor request keyid",
1452                                                 tokens[1]);
1453                                 } else {
1454 #ifdef DEBUG
1455                                         if (debug > 3)
1456                                             printf(
1457                                                     "set info_auth_key to %08lx\n", ul);
1458 #endif
1459                                         info_auth_keyid = (keyid_t)ul;
1460                                 }
1461                         }
1462                         break;
1463
1464                     case CONFIG_CONTROLKEY:
1465                         if (ntokens >= 2) {
1466                                 keyid_t ckey;
1467
1468                                 ckey = atol(tokens[1]);
1469                                 if (ckey == 0) {
1470                                         msyslog(LOG_ERR,
1471                                                 "%s makes a poor control keyid",
1472                                                 tokens[1]);
1473                                 } else {
1474                                         ctl_auth_keyid = ckey;
1475                                 }
1476                         }
1477                         break;
1478
1479                     case CONFIG_TRAP:
1480                         if (ntokens < 2) {
1481                                 msyslog(LOG_ERR,
1482                                         "no address for trap command, line ignored");
1483                                 break;
1484                         }
1485                         istart = 1;
1486                         memset((char *)&peeraddr, 0, sizeof(peeraddr));
1487                         peeraddr.ss_family = default_ai_family;
1488                         switch (matchkey(tokens[istart], addr_type, 0)) {
1489                         case CONF_ADDR_IPV4:
1490                                 peeraddr.ss_family = AF_INET;
1491                                 istart++;
1492                                 break;
1493                         case CONF_ADDR_IPV6:
1494                                 peeraddr.ss_family = AF_INET6;
1495                                 istart++;
1496                                 break;
1497                         }
1498
1499                         if (getnetnum(tokens[istart], &peeraddr, 1, t_UNK) != 1)
1500                             break;
1501
1502                         /*
1503                          * Use peerversion for port number.  Barf.
1504                          */
1505                         errflg = 0;
1506                         peerversion = 0;
1507                         localaddr = 0;
1508                         istart++;
1509                         for (i = istart; i < ntokens-1; i++)
1510                             switch (matchkey(tokens[i], trap_keywords, 1)) {
1511                                 case CONF_TRAP_PORT:
1512                                     if (i >= ntokens-1) {
1513                                             msyslog(LOG_ERR,
1514                                                     "trap port requires an argument");
1515                                             errflg = 1;
1516                                             break;
1517                                     }
1518                                     peerversion = atoi(tokens[++i]);
1519                                     if (peerversion <= 0
1520                                         || peerversion > 32767) {
1521                                             msyslog(LOG_ERR,
1522                                                     "invalid port number %s, trap ignored",
1523                                                     tokens[i]);
1524                                             errflg = 1;
1525                                     }
1526                                     break;
1527
1528                                 case CONF_TRAP_INTERFACE:
1529                                     if (i >= ntokens-1) {
1530                                             msyslog(LOG_ERR,
1531                                                     "trap interface requires an argument");
1532                                             errflg = 1;
1533                                             break;
1534                                     }
1535
1536                                     memset((char *)&maskaddr, 0,
1537                                         sizeof(maskaddr));
1538                                     maskaddr.ss_family = peeraddr.ss_family;
1539                                     if (getnetnum(tokens[++i],
1540                                                    &maskaddr, 1, t_UNK) != 1) {
1541                                             errflg = 1;
1542                                             break;
1543                                     }
1544
1545                                     localaddr = findinterface(&maskaddr);
1546                                     if (localaddr == NULL) {
1547                                             msyslog(LOG_ERR,
1548                                                     "can't find interface with address %s",
1549                                                     stoa(&maskaddr));
1550                                             errflg = 1;
1551                                     }
1552                                     break;
1553
1554                                 case CONFIG_UNKNOWN:
1555                                     errflg++;
1556                                     break;
1557                             }
1558
1559                         if (!errflg) {
1560                                 if (peerversion != 0)
1561                                     ((struct sockaddr_in6*)&peeraddr)->sin6_port = htons( (u_short) peerversion);
1562                                 else
1563                                     ((struct sockaddr_in6*)&peeraddr)->sin6_port = htons(TRAPPORT);
1564                                 if (localaddr == NULL)
1565                                     localaddr = ANY_INTERFACE_CHOOSE(&peeraddr);
1566                                 if (!ctlsettrap(&peeraddr, localaddr, 0,
1567                                                 NTP_VERSION))
1568                                     msyslog(LOG_ERR,
1569                                             "can't set trap for %s, no resources",
1570                                             stoa(&peeraddr));
1571                         }
1572                         break;
1573
1574                     case CONFIG_FUDGE:
1575                         if (ntokens < 2) {
1576                                 msyslog(LOG_ERR,
1577                                         "no address for fudge command, line ignored");
1578                                 break;
1579                         }
1580                         memset((char *)&peeraddr, 0, sizeof(peeraddr));
1581                         if (getnetnum(tokens[1], &peeraddr, 1, t_REF) != 1)
1582                             break;
1583
1584                         if (!ISREFCLOCKADR(&peeraddr)) {
1585                                 msyslog(LOG_ERR,
1586                                         "%s is inappropriate address for the fudge command, line ignored",
1587                                         stoa(&peeraddr));
1588                                 break;
1589                         }
1590
1591                         memset((void *)&clock_stat, 0, sizeof clock_stat);
1592                         fudgeflag = 0;
1593                         errflg = 0;
1594                         for (i = 2; i < ntokens-1; i++) {
1595                                 switch (c = matchkey(tokens[i],
1596                                     fudge_keywords, 1)) {
1597                                     case CONF_FDG_TIME1:
1598                                         if (sscanf(tokens[++i], "%lf",
1599                                                    &clock_stat.fudgetime1) != 1) {
1600                                                 msyslog(LOG_ERR,
1601                                                         "fudge %s time1 value in error",
1602                                                         stoa(&peeraddr));
1603                                                 errflg = i;
1604                                                 break;
1605                                         }
1606                                         clock_stat.haveflags |= CLK_HAVETIME1;
1607                                         break;
1608
1609                                     case CONF_FDG_TIME2:
1610                                         if (sscanf(tokens[++i], "%lf",
1611                                                    &clock_stat.fudgetime2) != 1) {
1612                                                 msyslog(LOG_ERR,
1613                                                         "fudge %s time2 value in error",
1614                                                         stoa(&peeraddr));
1615                                                 errflg = i;
1616                                                 break;
1617                                         }
1618                                         clock_stat.haveflags |= CLK_HAVETIME2;
1619                                         break;
1620
1621
1622                                     case CONF_FDG_STRATUM:
1623                                       if (!atoint(tokens[++i], &stratum))
1624                                         {
1625                                                 msyslog(LOG_ERR,
1626                                                         "fudge %s stratum value in error",
1627                                                         stoa(&peeraddr));
1628                                                 errflg = i;
1629                                                 break;
1630                                         }
1631                                         clock_stat.fudgeval1 = stratum;
1632                                         clock_stat.haveflags |= CLK_HAVEVAL1;
1633                                         break;
1634
1635                                     case CONF_FDG_REFID:
1636                                         i++;
1637                                         memcpy(&clock_stat.fudgeval2,
1638                                             tokens[i], min(strlen(tokens[i]),
1639                                             4));
1640                                         clock_stat.haveflags |= CLK_HAVEVAL2;
1641                                         break;
1642
1643                                     case CONF_FDG_FLAG1:
1644                                     case CONF_FDG_FLAG2:
1645                                     case CONF_FDG_FLAG3:
1646                                     case CONF_FDG_FLAG4:
1647                                         if (!atouint(tokens[++i], &fudgeflag)
1648                                             || fudgeflag > 1) {
1649                                                 msyslog(LOG_ERR,
1650                                                         "fudge %s flag value in error",
1651                                                         stoa(&peeraddr));
1652                                                 errflg = i;
1653                                                 break;
1654                                         }
1655                                         switch(c) {
1656                                             case CONF_FDG_FLAG1:
1657                                                 c = CLK_FLAG1;
1658                                                 clock_stat.haveflags|=CLK_HAVEFLAG1;
1659                                                 break;
1660                                             case CONF_FDG_FLAG2:
1661                                                 c = CLK_FLAG2;
1662                                                 clock_stat.haveflags|=CLK_HAVEFLAG2;
1663                                                 break;
1664                                             case CONF_FDG_FLAG3:
1665                                                 c = CLK_FLAG3;
1666                                                 clock_stat.haveflags|=CLK_HAVEFLAG3;
1667                                                 break;
1668                                             case CONF_FDG_FLAG4:
1669                                                 c = CLK_FLAG4;
1670                                                 clock_stat.haveflags|=CLK_HAVEFLAG4;
1671                                                 break;
1672                                         }
1673                                         if (fudgeflag == 0)
1674                                             clock_stat.flags &= ~c;
1675                                         else
1676                                             clock_stat.flags |= c;
1677                                         break;
1678
1679                                     case CONFIG_UNKNOWN:
1680                                         errflg = -1;
1681                                         break;
1682                                 }
1683                         }
1684
1685 #ifdef REFCLOCK
1686                         /*
1687                          * If reference clock support isn't defined the
1688                          * fudge line will still be accepted and syntax
1689                          * checked, but will essentially do nothing.
1690                          */
1691                         if (!errflg) {
1692                                 refclock_control(&peeraddr, &clock_stat,
1693                                     (struct refclockstat *)0);
1694                         }
1695 #endif
1696                         break;
1697
1698                     case CONFIG_STATSDIR:
1699                         if (ntokens >= 2)
1700                                 stats_config(STATS_STATSDIR,tokens[1]);
1701                         break;
1702
1703                     case CONFIG_STATISTICS:
1704                         for (i = 1; i < ntokens; i++) {
1705                                 filegen = filegen_get(tokens[i]);
1706
1707                                 if (filegen == NULL) {
1708                                         msyslog(LOG_ERR,
1709                                                 "no statistics named %s available",
1710                                                 tokens[i]);
1711                                         continue;
1712                                 }
1713 #ifdef DEBUG
1714                                 if (debug > 3)
1715                                     printf("enabling filegen for %s statistics \"%s%s\"\n",
1716                                            tokens[i], filegen->prefix, filegen->basename);
1717 #endif
1718                                 filegen->flag |= FGEN_FLAG_ENABLED;
1719                         }
1720                         break;
1721
1722                     case CONFIG_FILEGEN:
1723                         if (ntokens < 2) {
1724                                 msyslog(LOG_ERR,
1725                                         "no id for filegen command, line ignored");
1726                                 break;
1727                         }
1728
1729                         filegen = filegen_get(tokens[1]);
1730                         if (filegen == NULL) {
1731                                 msyslog(LOG_ERR,
1732                                         "unknown filegen \"%s\" ignored",
1733                                         tokens[1]);
1734                                 break;
1735                         }
1736                         /*
1737                          * peerversion is (ab)used for filegen file (index)
1738                          * peerkey         is (ab)used for filegen type
1739                          * peerflags   is (ab)used for filegen flags
1740                          */
1741                         peerversion = 0;
1742                         peerkey =         filegen->type;
1743                         peerflags =   filegen->flag;
1744                         errflg = 0;
1745
1746                         for (i = 2; i < ntokens; i++) {
1747                                 switch (matchkey(tokens[i],
1748                                     filegen_keywords, 1)) {
1749                                     case CONF_FGEN_FILE:
1750                                         if (i >= ntokens - 1) {
1751                                                 msyslog(LOG_ERR,
1752                                                         "filegen %s file requires argument",
1753                                                         tokens[1]);
1754                                                 errflg = i;
1755                                                 break;
1756                                         }
1757                                         peerversion = ++i;
1758                                         break;
1759                                     case CONF_FGEN_TYPE:
1760                                         if (i >= ntokens -1) {
1761                                                 msyslog(LOG_ERR,
1762                                                         "filegen %s type requires argument",
1763                                                         tokens[1]);
1764                                                 errflg = i;
1765                                                 break;
1766                                         }
1767                                         peerkey = matchkey(tokens[++i],
1768                                             fgen_types, 1);
1769                                         if (peerkey == CONFIG_UNKNOWN) {
1770                                                 msyslog(LOG_ERR,
1771                                                         "filegen %s unknown type \"%s\"",
1772                                                         tokens[1], tokens[i]);
1773                                                 errflg = i;
1774                                                 break;
1775                                         }
1776                                         break;
1777
1778                                     case CONF_FGEN_FLAG_LINK:
1779                                         peerflags |= FGEN_FLAG_LINK;
1780                                         break;
1781
1782                                     case CONF_FGEN_FLAG_NOLINK:
1783                                         peerflags &= ~FGEN_FLAG_LINK;
1784                                         break;
1785
1786                                     case CONF_FGEN_FLAG_ENABLE:
1787                                         peerflags |= FGEN_FLAG_ENABLED;
1788                                         break;
1789
1790                                     case CONF_FGEN_FLAG_DISABLE:
1791                                         peerflags &= ~FGEN_FLAG_ENABLED;
1792                                         break;
1793                                 }
1794                         }
1795                         if (!errflg)
1796                                 filegen_config(filegen, tokens[peerversion],
1797                                    (u_char)peerkey, (u_char)peerflags);
1798                         break;
1799
1800                     case CONFIG_SETVAR:
1801                         if (ntokens < 2) {
1802                                 msyslog(LOG_ERR,
1803                                         "no value for setvar command - line ignored");
1804                         } else {
1805                                 set_sys_var(tokens[1], strlen(tokens[1])+1,
1806                                             (u_short) (RW |
1807                                             ((((ntokens > 2)
1808                                                && !strcmp(tokens[2],
1809                                                           "default")))
1810                                              ? DEF
1811                                              : 0)));
1812                         }
1813                         break;
1814
1815                     case CONFIG_ENABLE:
1816                         for (i = 1; i < ntokens; i++) {
1817                                 int flag;
1818
1819                                 flag = matchkey(tokens[i], flags_keywords, 1);
1820                                 if (flag == CONFIG_UNKNOWN) {
1821                                         msyslog(LOG_ERR,
1822                                                 "enable unknown flag %s",
1823                                                 tokens[i]);
1824                                         errflg = 1;
1825                                         break;
1826                                 }
1827                                 proto_config(flag, 1, 0., NULL);
1828                         }
1829                         break;
1830
1831                     case CONFIG_DISABLE:
1832                         for (i = 1; i < ntokens; i++) {
1833                                 int flag;
1834
1835                                 flag = matchkey(tokens[i], flags_keywords, 1);
1836                                 if (flag == CONFIG_UNKNOWN) {
1837                                         msyslog(LOG_ERR,
1838                                                 "disable unknown flag %s",
1839                                                 tokens[i]);
1840                                         errflg = 1;
1841                                         break;
1842                                 }
1843                                 proto_config(flag, 0, 0., NULL);
1844                         }
1845                         break;
1846
1847                     case CONFIG_PHONE:
1848                         for (i = 1; i < ntokens && i < MAXPHONE - 1; i++) {
1849                                 sys_phone[i - 1] =
1850                                     emalloc(strlen(tokens[i]) + 1);
1851                                 strcpy(sys_phone[i - 1], tokens[i]);
1852                         }
1853                         sys_phone[i] = NULL;
1854                         break;
1855
1856                     case CONFIG_ADJ: {
1857                             double ftemp;
1858
1859                             sscanf(tokens[1], "%lf", &ftemp);
1860                             proto_config(PROTO_ADJ, 0, ftemp, NULL);
1861                         }
1862                         break;
1863
1864                 }
1865         }
1866         if (fp[0])
1867                 (void)fclose(fp[0]);
1868
1869 #ifdef HAVE_NETINFO
1870         if (config_netinfo)
1871                 free_netinfo_config(config_netinfo);
1872 #endif /* HAVE_NETINFO */
1873
1874 #if !defined(VMS) && !defined(SYS_VXWORKS)
1875         /* find a keyid */
1876         if (info_auth_keyid == 0)
1877                 req_keyid = 65535;
1878         else
1879                 req_keyid = info_auth_keyid;
1880
1881         /* if doesn't exist, make up one at random */
1882         if (!authhavekey(req_keyid)) {
1883                 char rankey[9];
1884                 int j;
1885
1886                 for (i = 0; i < 8; i++)
1887                         for (j = 1; j < 100; ++j) {
1888                                 rankey[i] = (char) (ntp_random() & 0xff);
1889                                 if (rankey[i] != 0) break;
1890                         }
1891                 rankey[8] = 0;
1892                 authusekey(req_keyid, KEY_TYPE_MD5, (u_char *)rankey);
1893                 authtrust(req_keyid, 1);
1894                 if (!authhavekey(req_keyid)) {
1895                         msyslog(LOG_ERR, "getconfig: Couldn't generate a valid random key!");
1896                         /* HMS: Should this be fatal? */
1897                 }
1898         }
1899
1900         /* save keyid so we will accept config requests with it */
1901         info_auth_keyid = req_keyid;
1902 #endif /* !defined(VMS) && !defined(SYS_VXWORKS) */
1903
1904         if (res_fp != NULL) {
1905                 if (call_resolver) {
1906                         /*
1907                          * Need name resolution
1908                          */
1909                         do_resolve_internal();
1910                 }
1911         }
1912 }
1913
1914
1915 #ifdef HAVE_NETINFO
1916
1917 /*
1918  * get_netinfo_config - find the nearest NetInfo domain with an ntp
1919  * configuration and initialize the configuration state.
1920  */
1921 static struct netinfo_config_state *
1922 get_netinfo_config()
1923 {
1924         ni_status status;
1925         void *domain;
1926         ni_id config_dir;
1927         struct netinfo_config_state *config;
1928
1929         if (ni_open(NULL, ".", &domain) != NI_OK) return NULL;
1930
1931         while ((status = ni_pathsearch(domain, &config_dir, NETINFO_CONFIG_DIR)) == NI_NODIR) {
1932                 void *next_domain;
1933                 if (ni_open(domain, "..", &next_domain) != NI_OK) {
1934                         ni_free(next_domain);
1935                         break;
1936                 }
1937                 ni_free(domain);
1938                 domain = next_domain;
1939         }
1940         if (status != NI_OK) {
1941                 ni_free(domain);
1942                 return NULL;
1943         }
1944
1945         config = (struct netinfo_config_state *)malloc(sizeof(struct netinfo_config_state));
1946         config->domain = domain;
1947         config->config_dir = config_dir;
1948         config->prop_index = 0;
1949         config->val_index = 0;
1950         config->val_list = NULL;
1951
1952         return config;
1953 }
1954
1955
1956
1957 /*
1958  * free_netinfo_config - release NetInfo configuration state
1959  */
1960 static void
1961 free_netinfo_config(struct netinfo_config_state *config)
1962 {
1963         ni_free(config->domain);
1964         free(config);
1965 }
1966
1967
1968
1969 /*
1970  * gettokens_netinfo - return tokens from NetInfo
1971  */
1972 static int
1973 gettokens_netinfo (
1974         struct netinfo_config_state *config,
1975         char **tokenlist,
1976         int *ntokens
1977         )
1978 {
1979         int prop_index = config->prop_index;
1980         int val_index = config->val_index;
1981         char **val_list = config->val_list;
1982
1983         /*
1984          * Iterate through each keyword and look for a property that matches it.
1985          */
1986         again:
1987         if (!val_list) {
1988                 for (; prop_index < (sizeof(keywords)/sizeof(keywords[0])); prop_index++)
1989                 {
1990                         ni_namelist namelist;
1991                         struct keyword current_prop = keywords[prop_index];
1992
1993                         /*
1994                          * For each value associated in the property, we're going to return
1995                          * a separate line. We squirrel away the values in the config state
1996                          * so the next time through, we don't need to do this lookup.
1997                          */
1998                         NI_INIT(&namelist);
1999                         if (ni_lookupprop(config->domain, &config->config_dir, current_prop.text, &namelist) == NI_OK) {
2000                                 ni_index index;
2001
2002                                 /* Found the property, but it has no values */
2003                                 if (namelist.ni_namelist_len == 0) continue;
2004
2005                                 if (! (val_list = config->val_list = (char**)malloc(sizeof(char*) * (namelist.ni_namelist_len + 1))))
2006                                         { msyslog(LOG_ERR, "out of memory while configuring"); break; }
2007
2008                                 for (index = 0; index < namelist.ni_namelist_len; index++) {
2009                                         char *value = namelist.ni_namelist_val[index];
2010
2011                                         if (! (val_list[index] = (char*)malloc(strlen(value)+1)))
2012                                                 { msyslog(LOG_ERR, "out of memory while configuring"); break; }
2013
2014                                         strcpy(val_list[index], value);
2015                                 }
2016                                 val_list[index] = NULL;
2017
2018                                 break;
2019                         }
2020                         ni_namelist_free(&namelist);
2021                 }
2022                 config->prop_index = prop_index;
2023         }
2024
2025         /* No list; we're done here. */
2026         if (!val_list) return CONFIG_UNKNOWN;
2027
2028         /*
2029          * We have a list of values for the current property.
2030          * Iterate through them and return each in order.
2031          */
2032         if (val_list[val_index])
2033         {
2034                 int ntok = 1;
2035                 int quoted = 0;
2036                 char *tokens = val_list[val_index];
2037
2038                 msyslog(LOG_INFO, "%s %s", keywords[prop_index].text, val_list[val_index]);
2039
2040                 (const char*)tokenlist[0] = keywords[prop_index].text;
2041                 for (ntok = 1; ntok < MAXTOKENS; ntok++) {
2042                         tokenlist[ntok] = tokens;
2043                         while (!ISEOL(*tokens) && (!ISSPACE(*tokens) || quoted))
2044                                 quoted ^= (*tokens++ == '"');
2045
2046                         if (ISEOL(*tokens)) {
2047                                 *tokens = '\0';
2048                                 break;
2049                         } else {                /* must be space */
2050                                 *tokens++ = '\0';
2051                                 while (ISSPACE(*tokens)) tokens++;
2052                                 if (ISEOL(*tokens)) break;
2053                         }
2054                 }
2055
2056                 if (ntok == MAXTOKENS) {
2057                         /* HMS: chomp it to lose the EOL? */
2058                         msyslog(LOG_ERR,
2059                             "gettokens_netinfo: too many tokens.  Ignoring: %s",
2060                             tokens);
2061                 } else {
2062                         *ntokens = ntok + 1;
2063                 }
2064
2065                 config->val_index++;    /* HMS: Should this be in the 'else'? */
2066
2067                 return keywords[prop_index].keytype;
2068         }
2069
2070         /* We're done with the current property. */
2071         prop_index = ++config->prop_index;
2072
2073         /* Free val_list and reset counters. */
2074         for (val_index = 0; val_list[val_index]; val_index++)
2075                 free(val_list[val_index]);
2076         free(val_list); val_list = config->val_list = NULL; val_index = config->val_index = 0;
2077
2078         goto again;
2079 }
2080
2081 #endif /* HAVE_NETINFO */
2082
2083
2084 /*
2085  * gettokens - read a line and return tokens
2086  */
2087 static int
2088 gettokens (
2089         FILE *fp,
2090         char *line,
2091         char **tokenlist,
2092         int *ntokens
2093         )
2094 {
2095         register char *cp;
2096         register int ntok;
2097         register int quoted = 0;
2098
2099         /*
2100          * Find start of first token
2101          */
2102         again:
2103         while ((cp = fgets(line, MAXLINE, fp)) != NULL) {
2104                 cp = line;
2105                 while (ISSPACE(*cp))
2106                         cp++;
2107                 if (!ISEOL(*cp))
2108                         break;
2109         }
2110         if (cp == NULL) {
2111                 *ntokens = 0;
2112                 return CONFIG_UNKNOWN;  /* hack.  Is recognized as EOF */
2113         }
2114
2115         /*
2116          * Now separate out the tokens
2117          */
2118         for (ntok = 0; ntok < MAXTOKENS; ntok++) {
2119                 tokenlist[ntok] = cp;
2120                 while (!ISEOL(*cp) && (!ISSPACE(*cp) || quoted))
2121                         quoted ^= (*cp++ == '"');
2122
2123                 if (ISEOL(*cp)) {
2124                         *cp = '\0';
2125                         break;
2126                 } else {                /* must be space */
2127                         *cp++ = '\0';
2128                         while (ISSPACE(*cp))
2129                                 cp++;
2130                         if (ISEOL(*cp))
2131                                 break;
2132                 }
2133         }
2134
2135      /* Heiko: Remove leading and trailing quotes around tokens */
2136      {
2137             int i,j = 0;
2138
2139
2140                         for (i = 0; i < ntok; i++) {
2141                                         /* Now check if the first char is a quote and remove that */
2142                                         if ( tokenlist[ntok][0] == '"' )
2143                                                         tokenlist[ntok]++;
2144
2145                                         /* Now check the last char ... */
2146                                         j = strlen(tokenlist[ntok])-1;
2147                                         if ( tokenlist[ntok][j] == '"' )
2148                                                         tokenlist[ntok][j] = '\0';
2149                         }
2150
2151     }
2152
2153         if (ntok == MAXTOKENS) {
2154                 --ntok;
2155                 /* HMS: chomp it to lose the EOL? */
2156                 msyslog(LOG_ERR,
2157                     "gettokens: too many tokens on the line. Ignoring %s",
2158                     cp);
2159         } else {
2160                 /*
2161                  * Return the match
2162                  */
2163                 *ntokens = ntok + 1;
2164                 ntok = matchkey(tokenlist[0], keywords, 1);
2165                 if (ntok == CONFIG_UNKNOWN)
2166                         goto again;
2167         }
2168
2169         return ntok;
2170 }
2171
2172
2173
2174 /*
2175  * matchkey - match a keyword to a list
2176  */
2177 static int
2178 matchkey(
2179         register char *word,
2180         register struct keyword *keys,
2181         int complain
2182         )
2183 {
2184         for (;;) {
2185                 if (keys->keytype == CONFIG_UNKNOWN) {
2186                         if (complain)
2187                                 msyslog(LOG_ERR,
2188                                     "configure: keyword \"%s\" unknown, line ignored",
2189                                     word);
2190                         return CONFIG_UNKNOWN;
2191                 }
2192                 if (STRSAME(word, keys->text))
2193                         return keys->keytype;
2194                 keys++;
2195         }
2196 }
2197
2198
2199 /*
2200  * getnetnum - return a net number (this is crude, but careful)
2201  */
2202 static int
2203 getnetnum(
2204         const char *num,
2205         struct sockaddr_storage *addr,
2206         int complain,
2207         enum gnn_type a_type
2208         )
2209 {
2210         struct addrinfo hints;
2211         struct addrinfo *ptr;
2212         int retval;
2213
2214 #if 0
2215         printf("getnetnum: <%s> is a %s (%d)\n",
2216                 num,
2217                 (a_type == t_UNK)
2218                 ? "t_UNK"
2219                 : (a_type == t_REF)
2220                   ? "t_REF"
2221                   : (a_type == t_MSK)
2222                     ? "t_MSK"
2223                     : "???",
2224                 a_type);
2225 #endif
2226
2227         /* Get host address. Looking for UDP datagram connection */
2228         memset(&hints, 0, sizeof (hints));
2229         if (addr->ss_family == AF_INET || addr->ss_family == AF_INET6)
2230             hints.ai_family = addr->ss_family;
2231         else
2232             hints.ai_family = AF_UNSPEC;
2233         /*
2234          * If we don't have an IPv6 stack, just look up IPv4 addresses
2235          */
2236         if (isc_net_probeipv6() != ISC_R_SUCCESS)
2237                 hints.ai_family = AF_INET;
2238
2239         hints.ai_socktype = SOCK_DGRAM;
2240
2241         if (a_type != t_UNK) {
2242                 hints.ai_flags = AI_NUMERICHOST;
2243         }
2244
2245 #ifdef DEBUG
2246         if (debug > 3)
2247                 printf("getnetnum: calling getaddrinfo(%s,...)\n", num);
2248 #endif
2249         retval = getaddrinfo(num, "ntp", &hints, &ptr);
2250         if (retval != 0 ||
2251            (ptr->ai_family == AF_INET6 && isc_net_probeipv6() != ISC_R_SUCCESS)) {
2252                 if (complain)
2253                         msyslog(LOG_ERR,
2254                                 "getaddrinfo: \"%s\" invalid host address, ignored",
2255                                 num);
2256 #ifdef DEBUG
2257                 if (debug > 0)
2258                         printf(
2259                                 "getaddrinfo: \"%s\" invalid host address%s.\n",
2260                                 num, (complain)
2261                                 ? ", ignored"
2262                                 : "");
2263 #endif
2264                 if (retval == 0 &&
2265                     ptr->ai_family == AF_INET6 &&
2266                     isc_net_probeipv6() != ISC_R_SUCCESS)
2267                 {
2268                         return -1;
2269                 }
2270                 else {
2271                         return 0;
2272                 }
2273         }
2274
2275         memcpy(addr, ptr->ai_addr, ptr->ai_addrlen);
2276 #ifdef DEBUG
2277         if (debug > 1)
2278                 printf("getnetnum given %s, got %s (%s/%d)\n",
2279                    num, stoa(addr),
2280                         (a_type == t_UNK)
2281                         ? "t_UNK"
2282                         : (a_type == t_REF)
2283                           ? "t_REF"
2284                           : (a_type == t_MSK)
2285                             ? "t_MSK"
2286                             : "???",
2287                         a_type);
2288 #endif
2289         freeaddrinfo(ptr);
2290         return 1;
2291 }
2292
2293
2294 #if !defined(VMS) && !defined(SYS_WINNT)
2295 /*
2296  * catchchild - receive the resolver's exit status
2297  */
2298 static RETSIGTYPE
2299 catchchild(
2300         int sig
2301         )
2302 {
2303         /*
2304          * We only start up one child, and if we're here
2305          * it should have already exited.  Hence the following
2306          * shouldn't hang.  If it does, please tell me.
2307          */
2308 #if !defined (SYS_WINNT) && !defined(SYS_VXWORKS)
2309         (void) wait(0);
2310 #endif /* SYS_WINNT  && VXWORKS*/
2311 }
2312 #endif /* VMS */
2313
2314
2315 /*
2316  * save_resolve - save configuration info into a file for later name resolution
2317  */
2318 static void
2319 save_resolve(
2320         char *name,
2321         int mode,
2322         int version,
2323         int minpoll,
2324         int maxpoll,
2325         u_int flags,
2326         int ttl,
2327         keyid_t keyid,
2328         u_char *keystr,
2329         u_char peeraf
2330         )
2331 {
2332 #ifndef SYS_VXWORKS
2333         if (res_fp == NULL) {
2334 #ifndef SYS_WINNT
2335                 (void) strcpy(res_file, RES_TEMPFILE);
2336 #else
2337                 /* no /tmp directory under NT */
2338                 {
2339                         if(!(GetTempPath((DWORD)MAX_PATH, (LPTSTR)res_file))) {
2340                                 msyslog(LOG_ERR, "cannot get pathname for temporary directory: %m");
2341                                 return;
2342                         }
2343                         (void) strcat(res_file, "ntpdXXXXXX");
2344                 }
2345 #endif /* SYS_WINNT */
2346 #ifdef HAVE_MKSTEMP
2347                 {
2348                         int fd;
2349
2350                         res_fp = NULL;
2351                         if ((fd = mkstemp(res_file)) != -1)
2352                                 res_fp = fdopen(fd, "r+");
2353                 }
2354 #else
2355                 (void) mktemp(res_file);
2356                 res_fp = fopen(res_file, "w");
2357 #endif
2358                 if (res_fp == NULL) {
2359                         msyslog(LOG_ERR, "open failed for %s: %m", res_file);
2360                         return;
2361                 }
2362         }
2363 #ifdef DEBUG
2364         if (debug) {
2365                 printf("resolving %s\n", name);
2366         }
2367 #endif
2368
2369         (void)fprintf(res_fp, "%s %u %d %d %d %d %d %d %u %s\n", name, peeraf,
2370             mode, version, minpoll, maxpoll, flags, ttl, keyid, keystr);
2371 #ifdef DEBUG
2372         if (debug > 1)
2373                 printf("config: %s %u %d %d %d %d %x %d %u %s\n", name, peeraf, mode,
2374                     version, minpoll, maxpoll, flags, ttl, keyid, keystr);
2375 #endif
2376
2377 #else  /* SYS_VXWORKS */
2378         /* save resolve info to a struct */
2379 #endif /* SYS_VXWORKS */
2380 }
2381
2382
2383 /*
2384  * abort_resolve - terminate the resolver stuff and delete the file
2385  */
2386 static void
2387 abort_resolve(void)
2388 {
2389         /*
2390          * In an ideal world we would might reread the file and
2391          * log the hosts which aren't getting configured.  Since
2392          * this is too much work, however, just close and delete
2393          * the temp file.
2394          */
2395         if (res_fp != NULL)
2396                 (void) fclose(res_fp);
2397         res_fp = NULL;
2398
2399 #ifndef SYS_VXWORKS             /* we don't open the file to begin with */
2400 #if !defined(VMS)
2401         (void) unlink(res_file);
2402 #else
2403         (void) delete(res_file);
2404 #endif /* VMS */
2405 #endif /* SYS_VXWORKS */
2406 }
2407
2408
2409 /*
2410  * do_resolve_internal - start up the resolver function (not program)
2411  */
2412 /*
2413  * On VMS, this routine will simply refuse to resolve anything.
2414  *
2415  * Possible implementation: keep `res_file' in memory, do async
2416  * name resolution via QIO, update from within completion AST.
2417  * I'm unlikely to find the time for doing this, though. -wjm
2418  */
2419 static void
2420 do_resolve_internal(void)
2421 {
2422         int i;
2423
2424         if (res_fp == NULL) {
2425                 /* belch */
2426                 msyslog(LOG_ERR,
2427                         "do_resolve_internal: Fatal: res_fp == NULL");
2428                 exit(1);
2429         }
2430
2431         /* we are done with this now */
2432         (void) fclose(res_fp);
2433         res_fp = NULL;
2434
2435 #if !defined(VMS) && !defined (SYS_VXWORKS)
2436         req_file = res_file;    /* set up pointer to res file */
2437 #ifndef SYS_WINNT
2438         (void) signal_no_reset(SIGCHLD, catchchild);
2439
2440 #ifndef SYS_VXWORKS
2441         /* the parent process will write to the pipe
2442          * in order to wake up to child process
2443          * which may be waiting in a select() call
2444          * on the read fd */
2445         if (pipe(resolver_pipe_fd) < 0) {
2446                 msyslog(LOG_ERR,
2447                         "unable to open resolver pipe");
2448                 exit(1);
2449         }
2450
2451         i = fork();
2452         /* Shouldn't the code below be re-ordered?
2453          * I.e. first check if the fork() returned an error, then
2454          * check whether we're parent or child.
2455          *     Martin Burnicki
2456          */
2457         if (i == 0) {
2458                 /*
2459                  * this used to close everything
2460                  * I don't think this is necessary
2461                  */
2462                 /*
2463                  * To the unknown commenter above:
2464                  * Well, I think it's better to clean up
2465                  * after oneself. I have had problems with
2466                  * refclock-io when intres was running - things
2467                  * where fine again when ntpintres was gone.
2468                  * So some systems react erratic at least.
2469                  *
2470                  *                      Frank Kardel
2471                  *
2472                  * 94-11-16:
2473                  * Further debugging has proven that the above is
2474                  * absolutely harmful. The internal resolver
2475                  * is still in the SIGIO process group and the lingering
2476                  * async io information causes it to process requests from
2477                  * all file decriptor causing a race between the NTP daemon
2478                  * and the resolver. which then eats data when it wins 8-(.
2479                  * It is absolutly necessary to kill any IO associations
2480                  * shared with the NTP daemon.
2481                  *
2482                  * We also block SIGIO (currently no ports means to
2483                  * disable the signal handle for IO).
2484                  *
2485                  * Thanks to wgstuken@informatik.uni-erlangen.de to notice
2486                  * that it is the ntp-resolver child running into trouble.
2487                  *
2488                  * THUS:
2489                  */
2490
2491                 /* This is the child process who will read the pipe,
2492                  * so we close the write fd */
2493                 close(resolver_pipe_fd[1]);
2494                 closelog();
2495                 kill_asyncio(0);
2496
2497                 (void) signal_no_reset(SIGCHLD, SIG_DFL);
2498
2499 #ifdef DEBUG
2500                 if (0)
2501                     debug = 2;
2502 #endif
2503
2504 # ifndef LOG_DAEMON
2505                 openlog("ntpd_initres", LOG_PID);
2506 # else /* LOG_DAEMON */
2507
2508 #  ifndef LOG_NTP
2509 #   define      LOG_NTP LOG_DAEMON
2510 #  endif
2511                 openlog("ntpd_initres", LOG_PID | LOG_NDELAY, LOG_NTP);
2512 #ifndef SYS_CYGWIN32
2513 #  ifdef DEBUG
2514                 if (debug)
2515                     setlogmask(LOG_UPTO(LOG_DEBUG));
2516                 else
2517 #  endif /* DEBUG */
2518                     setlogmask(LOG_UPTO(LOG_DEBUG)); /* @@@ was INFO */
2519 # endif /* LOG_DAEMON */
2520 #endif
2521
2522                 ntp_intres();
2523
2524                 /*
2525                  * If we got here, the intres code screwed up.
2526                  * Print something so we don't die without complaint
2527                  */
2528                 msyslog(LOG_ERR, "call to ntp_intres lost");
2529                 abort_resolve();
2530                 exit(1);
2531         }
2532 #else
2533          /* vxWorks spawns a thread... -casey */
2534          i = sp (ntp_intres);
2535          /*i = taskSpawn("ntp_intres",100,VX_FP_TASK,20000,ntp_intres);*/
2536 #endif
2537         if (i == -1) {
2538                 msyslog(LOG_ERR, "fork() failed, can't start ntp_intres: %m");
2539                 (void) signal_no_reset(SIGCHLD, SIG_DFL);
2540                 abort_resolve();
2541         }
2542         else {
2543                 /* This is the parent process who will write to the pipe,
2544                  * so we close the read fd */
2545                 close(resolver_pipe_fd[0]);
2546         }
2547 #else /* SYS_WINNT */
2548         {
2549                 /* NT's equivalent of fork() is _spawn(), but the start point
2550                  * of the new process is an executable filename rather than
2551                  * a function name as desired here.
2552                  */
2553                 DWORD dwThreadId;
2554                 fflush(stdout);
2555                 ResolverEventHandle = CreateEvent(NULL, FALSE, FALSE, NULL);
2556                 if (ResolverEventHandle == NULL) {
2557                         msyslog(LOG_ERR, "Unable to create resolver event object, can't start ntp_intres");
2558                         abort_resolve();
2559                 }
2560                 ResolverThreadHandle = CreateThread(
2561                         NULL,                            /* no security attributes      */
2562                         0,                               /* use default stack size      */
2563                         (LPTHREAD_START_ROUTINE) ntp_intres, /* thread function         */
2564                         NULL,                            /* argument to thread function   */
2565                         0,                               /* use default creation flags    */
2566                         &dwThreadId);                    /* returns the thread identifier */
2567                 if (ResolverThreadHandle == NULL) {
2568                         msyslog(LOG_ERR, "CreateThread() failed, can't start ntp_intres");
2569                         CloseHandle(ResolverEventHandle);
2570                         ResolverEventHandle = NULL;
2571                         abort_resolve();
2572                 }
2573         }
2574 #endif /* SYS_WINNT */
2575 #else /* VMS  VX_WORKS */
2576         msyslog(LOG_ERR,
2577                 "Name resolution not implemented for VMS - use numeric addresses");
2578         abort_resolve();
2579 #endif /* VMS VX_WORKS */
2580 }